tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

staging: kpc2000: kpc_i2c: Fix lines over 80 chars

Fix lines over 80 characters warnings.
issue found by checkpatch.

Signed-off-by: Jamal Shareef <jamal.k.shareef@gmail.com>
Link: https://lore.kernel.org/r/8273ad9efccfb2c37ff1e9a25d5ccb26780567aa.1572293975.git.jamal.k.shareef@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Jamal Shareef and committed by
Greg Kroah-Hartman 9535e71e 883afa2d

+137 -64
+137 -64
drivers/staging/kpc2000/kpc2000_i2c.c
··· 99 99 #define SMBHSTSTS_INTR 0x02 100 100 #define SMBHSTSTS_HOST_BUSY 0x01 101 101 102 - #define STATUS_FLAGS (SMBHSTSTS_BYTE_DONE | SMBHSTSTS_FAILED | SMBHSTSTS_BUS_ERR | SMBHSTSTS_DEV_ERR | SMBHSTSTS_INTR) 102 + #define STATUS_FLAGS (SMBHSTSTS_BYTE_DONE | SMBHSTSTS_FAILED | \ 103 + SMBHSTSTS_BUS_ERR | SMBHSTSTS_DEV_ERR | SMBHSTSTS_INTR) 103 104 104 105 /* Older devices have their ID defined in <linux/pci_ids.h> */ 105 106 #define PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS 0x1c22 ··· 137 136 138 137 status = inb_p(SMBHSTSTS(priv)); 139 138 if (status & SMBHSTSTS_HOST_BUSY) { 140 - dev_err(&priv->adapter.dev, "SMBus is busy, can't use it! (status=%x)\n", status); 139 + dev_err(&priv->adapter.dev, 140 + "SMBus is busy, can't use it! (status=%x)\n", status); 141 141 return -EBUSY; 142 142 } 143 143 ··· 148 146 outb_p(status, SMBHSTSTS(priv)); 149 147 status = inb_p(SMBHSTSTS(priv)) & STATUS_FLAGS; 150 148 if (status) { 151 - dev_err(&priv->adapter.dev, "Failed clearing status flags (%02x)\n", status); 149 + dev_err(&priv->adapter.dev, 150 + "Failed clearing status flags (%02x)\n", status); 152 151 return -EBUSY; 153 152 } 154 153 } ··· 165 162 if (timeout) { 166 163 dev_err(&priv->adapter.dev, "Transaction timeout\n"); 167 164 /* try to stop the current command */ 168 - dev_dbg(&priv->adapter.dev, "Terminating the current operation\n"); 169 - outb_p(inb_p(SMBHSTCNT(priv)) | SMBHSTCNT_KILL, SMBHSTCNT(priv)); 165 + dev_dbg(&priv->adapter.dev, 166 + "Terminating the current operation\n"); 167 + outb_p(inb_p(SMBHSTCNT(priv)) | SMBHSTCNT_KILL, 168 + SMBHSTCNT(priv)); 170 169 usleep_range(1000, 2000); 171 - outb_p(inb_p(SMBHSTCNT(priv)) & (~SMBHSTCNT_KILL), SMBHSTCNT(priv)); 170 + outb_p(inb_p(SMBHSTCNT(priv)) & (~SMBHSTCNT_KILL), 171 + SMBHSTCNT(priv)); 172 172 173 173 /* Check if it worked */ 174 174 status = inb_p(SMBHSTSTS(priv)); 175 - if ((status & SMBHSTSTS_HOST_BUSY) || !(status & SMBHSTSTS_FAILED)) 176 - dev_err(&priv->adapter.dev, "Failed terminating the transaction\n"); 175 + if ((status & SMBHSTSTS_HOST_BUSY) || 176 + !(status & SMBHSTSTS_FAILED)) 177 + dev_err(&priv->adapter.dev, 178 + "Failed terminating the transaction\n"); 177 179 outb_p(STATUS_FLAGS, SMBHSTSTS(priv)); 178 180 return -ETIMEDOUT; 179 181 } ··· 252 244 outb_p(status, SMBHSTSTS(priv)); 253 245 } 254 246 255 - static int i801_block_transaction_by_block(struct i2c_device *priv, union i2c_smbus_data *data, char read_write, int hwpec) 247 + static int i801_block_transaction_by_block(struct i2c_device *priv, 248 + union i2c_smbus_data *data, 249 + char read_write, int hwpec) 256 250 { 257 251 int i, len; 258 252 int status; ··· 269 259 outb_p(data->block[i + 1], SMBBLKDAT(priv)); 270 260 } 271 261 272 - status = i801_transaction(priv, I801_BLOCK_DATA | ENABLE_INT9 | I801_PEC_EN * hwpec); 262 + status = i801_transaction(priv, 263 + I801_BLOCK_DATA | ENABLE_INT9 | I801_PEC_EN * hwpec); 273 264 if (status) 274 265 return status; 275 266 ··· 286 275 return 0; 287 276 } 288 277 289 - static int i801_block_transaction_byte_by_byte(struct i2c_device *priv, union i2c_smbus_data *data, char read_write, int command, int hwpec) 278 + static int i801_block_transaction_byte_by_byte(struct i2c_device *priv, 279 + union i2c_smbus_data *data, 280 + char read_write, int command, 281 + int hwpec) 290 282 { 291 283 int i, len; 292 284 int smbcmd; ··· 315 301 else 316 302 smbcmd = I801_BLOCK_LAST; 317 303 } else { 318 - if (command == I2C_SMBUS_I2C_BLOCK_DATA && read_write == I2C_SMBUS_READ) 304 + if (command == I2C_SMBUS_I2C_BLOCK_DATA && 305 + read_write == I2C_SMBUS_READ) 319 306 smbcmd = I801_I2C_BLOCK_DATA; 320 307 else 321 308 smbcmd = I801_BLOCK_DATA; ··· 324 309 outb_p(smbcmd | ENABLE_INT9, SMBHSTCNT(priv)); 325 310 326 311 if (i == 1) 327 - outb_p(inb(SMBHSTCNT(priv)) | I801_START, SMBHSTCNT(priv)); 312 + outb_p(inb(SMBHSTCNT(priv)) | I801_START, 313 + SMBHSTCNT(priv)); 328 314 /* We will always wait for a fraction of a second! */ 329 315 timeout = 0; 330 316 do { 331 317 usleep_range(250, 500); 332 318 status = inb_p(SMBHSTSTS(priv)); 333 - } while ((!(status & SMBHSTSTS_BYTE_DONE)) && (timeout++ < MAX_RETRIES)); 319 + } while (!(status & SMBHSTSTS_BYTE_DONE) && 320 + (timeout++ < MAX_RETRIES)); 334 321 335 322 result = i801_check_post(priv, status, timeout > MAX_RETRIES); 336 323 if (result < 0) 337 324 return result; 338 - if (i == 1 && read_write == I2C_SMBUS_READ && command != I2C_SMBUS_I2C_BLOCK_DATA) { 325 + if (i == 1 && read_write == I2C_SMBUS_READ && 326 + command != I2C_SMBUS_I2C_BLOCK_DATA) { 339 327 len = inb_p(SMBHSTDAT0(priv)); 340 328 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX) { 341 - dev_err(&priv->adapter.dev, "Illegal SMBus block read size %d\n", len); 329 + dev_err(&priv->adapter.dev, 330 + "Illegal SMBus block read size %d\n", 331 + len); 342 332 /* Recover */ 343 - while (inb_p(SMBHSTSTS(priv)) & SMBHSTSTS_HOST_BUSY) 344 - outb_p(SMBHSTSTS_BYTE_DONE, SMBHSTSTS(priv)); 345 - outb_p(SMBHSTSTS_INTR, SMBHSTSTS(priv)); 333 + while (inb_p(SMBHSTSTS(priv)) & 334 + SMBHSTSTS_HOST_BUSY) 335 + outb_p(SMBHSTSTS_BYTE_DONE, 336 + SMBHSTSTS(priv)); 337 + outb_p(SMBHSTSTS_INTR, 338 + SMBHSTSTS(priv)); 346 339 return -EPROTO; 347 340 } 348 341 data->block[0] = len; ··· 377 354 } 378 355 379 356 /* Block transaction function */ 380 - static int i801_block_transaction(struct i2c_device *priv, union i2c_smbus_data *data, char read_write, int command, int hwpec) 357 + static int i801_block_transaction(struct i2c_device *priv, 358 + union i2c_smbus_data *data, char read_write, 359 + int command, int hwpec) 381 360 { 382 361 int result = 0; 383 362 //unsigned char hostc; ··· 391 366 //pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &hostc); 392 367 //pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc | SMBHSTCFG_I2C_EN); 393 368 } else if (!(priv->features & FEATURE_I2C_BLOCK_READ)) { 394 - dev_err(&priv->adapter.dev, "I2C block read is unsupported!\n"); 369 + dev_err(&priv->adapter.dev, 370 + "I2C block read is unsupported!\n"); 395 371 return -EOPNOTSUPP; 396 372 } 397 373 } 398 374 399 - if (read_write == I2C_SMBUS_WRITE || command == I2C_SMBUS_I2C_BLOCK_DATA) { 375 + if (read_write == I2C_SMBUS_WRITE || 376 + command == I2C_SMBUS_I2C_BLOCK_DATA) { 400 377 if (data->block[0] < 1) 401 378 data->block[0] = 1; 402 379 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) ··· 411 384 * SMBus (not I2C) block transactions, even though the datasheet 412 385 * doesn't mention this limitation. 413 386 */ 414 - if ((priv->features & FEATURE_BLOCK_BUFFER) && command != I2C_SMBUS_I2C_BLOCK_DATA && i801_set_block_buffer_mode(priv) == 0) 415 - result = i801_block_transaction_by_block(priv, data, read_write, hwpec); 416 - else 417 - result = i801_block_transaction_byte_by_byte(priv, data, read_write, command, hwpec); 387 + if ((priv->features & FEATURE_BLOCK_BUFFER) && 388 + command != I2C_SMBUS_I2C_BLOCK_DATA && 389 + i801_set_block_buffer_mode(priv) == 0) { 390 + result = i801_block_transaction_by_block(priv, data, 391 + read_write, hwpec); 392 + } else { 393 + result = i801_block_transaction_byte_by_byte(priv, data, 394 + read_write, 395 + command, hwpec); 396 + } 397 + 418 398 if (result == 0 && hwpec) 419 399 i801_wait_hwpec(priv); 420 - if (command == I2C_SMBUS_I2C_BLOCK_DATA && read_write == I2C_SMBUS_WRITE) { 400 + if (command == I2C_SMBUS_I2C_BLOCK_DATA && 401 + read_write == I2C_SMBUS_WRITE) { 421 402 /* restore saved configuration register value */ 422 403 //TODO: Figure out the right thing to do here... 423 404 //pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc); ··· 434 399 } 435 400 436 401 /* Return negative errno on error. */ 437 - static s32 i801_access(struct i2c_adapter *adap, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data *data) 402 + static s32 i801_access(struct i2c_adapter *adap, u16 addr, 403 + unsigned short flags, char read_write, u8 command, 404 + int size, union i2c_smbus_data *data) 438 405 { 439 406 int hwpec; 440 407 int block = 0; 441 408 int ret, xact = 0; 442 409 struct i2c_device *priv = i2c_get_adapdata(adap); 443 410 444 - hwpec = (priv->features & FEATURE_SMBUS_PEC) && (flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA; 411 + hwpec = (priv->features & FEATURE_SMBUS_PEC) && 412 + (flags & I2C_CLIENT_PEC) && 413 + size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA; 445 414 446 415 switch (size) { 447 416 case I2C_SMBUS_QUICK: 448 417 dev_dbg(&priv->adapter.dev, " [acc] SMBUS_QUICK\n"); 449 - outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), SMBHSTADD(priv)); 418 + outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 419 + SMBHSTADD(priv)); 420 + 450 421 xact = I801_QUICK; 451 422 break; 452 423 case I2C_SMBUS_BYTE: 453 424 dev_dbg(&priv->adapter.dev, " [acc] SMBUS_BYTE\n"); 454 425 455 - outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), SMBHSTADD(priv)); 426 + outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 427 + SMBHSTADD(priv)); 456 428 if (read_write == I2C_SMBUS_WRITE) 457 429 outb_p(command, SMBHSTCMD(priv)); 458 430 xact = I801_BYTE; 459 431 break; 460 432 case I2C_SMBUS_BYTE_DATA: 461 433 dev_dbg(&priv->adapter.dev, " [acc] SMBUS_BYTE_DATA\n"); 462 - outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), SMBHSTADD(priv)); 434 + outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 435 + SMBHSTADD(priv)); 436 + 463 437 outb_p(command, SMBHSTCMD(priv)); 464 438 if (read_write == I2C_SMBUS_WRITE) 465 439 outb_p(data->byte, SMBHSTDAT0(priv)); ··· 476 432 break; 477 433 case I2C_SMBUS_WORD_DATA: 478 434 dev_dbg(&priv->adapter.dev, " [acc] SMBUS_WORD_DATA\n"); 479 - outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), SMBHSTADD(priv)); 435 + outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 436 + SMBHSTADD(priv)); 437 + 480 438 outb_p(command, SMBHSTCMD(priv)); 481 439 if (read_write == I2C_SMBUS_WRITE) { 482 440 outb_p(data->word & 0xff, SMBHSTDAT0(priv)); ··· 488 442 break; 489 443 case I2C_SMBUS_BLOCK_DATA: 490 444 dev_dbg(&priv->adapter.dev, " [acc] SMBUS_BLOCK_DATA\n"); 491 - outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), SMBHSTADD(priv)); 445 + outb_p(((addr & 0x7f) << 1) | (read_write & 0x01), 446 + SMBHSTADD(priv)); 447 + 492 448 outb_p(command, SMBHSTCMD(priv)); 493 449 block = 1; 494 450 break; ··· 511 463 block = 1; 512 464 break; 513 465 default: 514 - dev_dbg(&priv->adapter.dev, " [acc] Unsupported transaction %d\n", size); 466 + dev_dbg(&priv->adapter.dev, 467 + " [acc] Unsupported transaction %d\n", size); 515 468 return -EOPNOTSUPP; 516 469 } 517 470 ··· 521 472 outb_p(inb_p(SMBAUXCTL(priv)) | SMBAUXCTL_CRC, SMBAUXCTL(priv)); 522 473 } else { 523 474 dev_dbg(&priv->adapter.dev, " [acc] hwpec: no\n"); 524 - outb_p(inb_p(SMBAUXCTL(priv)) & (~SMBAUXCTL_CRC), SMBAUXCTL(priv)); 475 + outb_p(inb_p(SMBAUXCTL(priv)) & 476 + (~SMBAUXCTL_CRC), SMBAUXCTL(priv)); 525 477 } 526 478 527 479 if (block) { 528 480 //ret = 0; 529 481 dev_dbg(&priv->adapter.dev, " [acc] block: yes\n"); 530 - ret = i801_block_transaction(priv, data, read_write, size, hwpec); 482 + ret = i801_block_transaction(priv, data, read_write, size, 483 + hwpec); 531 484 } else { 532 485 dev_dbg(&priv->adapter.dev, " [acc] block: no\n"); 533 486 ret = i801_transaction(priv, xact | ENABLE_INT9); ··· 541 490 */ 542 491 if (hwpec || block) { 543 492 dev_dbg(&priv->adapter.dev, " [acc] hwpec || block\n"); 544 - outb_p(inb_p(SMBAUXCTL(priv)) & ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B), SMBAUXCTL(priv)); 493 + outb_p(inb_p(SMBAUXCTL(priv)) & ~(SMBAUXCTL_CRC | 494 + SMBAUXCTL_E32B), SMBAUXCTL(priv)); 545 495 } 546 496 if (block) { 547 497 dev_dbg(&priv->adapter.dev, " [acc] block\n"); ··· 553 501 return ret; 554 502 } 555 503 if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK)) { 556 - dev_dbg(&priv->adapter.dev, " [acc] I2C_SMBUS_WRITE || I801_QUICK -> ret 0\n"); 504 + dev_dbg(&priv->adapter.dev, 505 + " [acc] I2C_SMBUS_WRITE || I801_QUICK -> ret 0\n"); 557 506 return 0; 558 507 } 559 508 560 509 switch (xact & 0x7f) { 561 510 case I801_BYTE: /* Result put in SMBHSTDAT0 */ 562 511 case I801_BYTE_DATA: 563 - dev_dbg(&priv->adapter.dev, " [acc] I801_BYTE or I801_BYTE_DATA\n"); 512 + dev_dbg(&priv->adapter.dev, 513 + " [acc] I801_BYTE or I801_BYTE_DATA\n"); 564 514 data->byte = inb_p(SMBHSTDAT0(priv)); 565 515 break; 566 516 case I801_WORD_DATA: 567 517 dev_dbg(&priv->adapter.dev, " [acc] I801_WORD_DATA\n"); 568 - data->word = inb_p(SMBHSTDAT0(priv)) + (inb_p(SMBHSTDAT1(priv)) << 8); 518 + data->word = inb_p(SMBHSTDAT0(priv)) + 519 + (inb_p(SMBHSTDAT1(priv)) << 8); 569 520 break; 570 521 } 571 522 return 0; ··· 590 535 // http://lxr.free-electrons.com/source/include/uapi/linux/i2c.h#L85 591 536 592 537 u32 f = 593 - I2C_FUNC_I2C | /* 0x00000001 (I enabled this one) */ 594 - !I2C_FUNC_10BIT_ADDR | /* 0x00000002 */ 595 - !I2C_FUNC_PROTOCOL_MANGLING | /* 0x00000004 */ 596 - ((priv->features & FEATURE_SMBUS_PEC) ? I2C_FUNC_SMBUS_PEC : 0) | /* 0x00000008 */ 597 - !I2C_FUNC_SMBUS_BLOCK_PROC_CALL | /* 0x00008000 */ 598 - I2C_FUNC_SMBUS_QUICK | /* 0x00010000 */ 599 - !I2C_FUNC_SMBUS_READ_BYTE | /* 0x00020000 */ 600 - !I2C_FUNC_SMBUS_WRITE_BYTE | /* 0x00040000 */ 601 - !I2C_FUNC_SMBUS_READ_BYTE_DATA | /* 0x00080000 */ 602 - !I2C_FUNC_SMBUS_WRITE_BYTE_DATA | /* 0x00100000 */ 603 - !I2C_FUNC_SMBUS_READ_WORD_DATA | /* 0x00200000 */ 604 - !I2C_FUNC_SMBUS_WRITE_WORD_DATA | /* 0x00400000 */ 605 - !I2C_FUNC_SMBUS_PROC_CALL | /* 0x00800000 */ 606 - !I2C_FUNC_SMBUS_READ_BLOCK_DATA | /* 0x01000000 */ 607 - !I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | /* 0x02000000 */ 608 - ((priv->features & FEATURE_I2C_BLOCK_READ) ? I2C_FUNC_SMBUS_READ_I2C_BLOCK : 0) | /* 0x04000000 */ 609 - I2C_FUNC_SMBUS_WRITE_I2C_BLOCK | /* 0x08000000 */ 538 + I2C_FUNC_I2C | /* 0x00000001(I enabled this 539 + * one) 540 + */ 541 + !I2C_FUNC_10BIT_ADDR | /* 0x00000002 */ 542 + !I2C_FUNC_PROTOCOL_MANGLING | /* 0x00000004 */ 543 + ((priv->features & FEATURE_SMBUS_PEC) ? 544 + I2C_FUNC_SMBUS_PEC : 0) | /* 0x00000008 */ 545 + !I2C_FUNC_SMBUS_BLOCK_PROC_CALL | /* 0x00008000 */ 546 + I2C_FUNC_SMBUS_QUICK | /* 0x00010000 */ 547 + !I2C_FUNC_SMBUS_READ_BYTE | /* 0x00020000 */ 548 + !I2C_FUNC_SMBUS_WRITE_BYTE | /* 0x00040000 */ 549 + !I2C_FUNC_SMBUS_READ_BYTE_DATA | /* 0x00080000 */ 550 + !I2C_FUNC_SMBUS_WRITE_BYTE_DATA | /* 0x00100000 */ 551 + !I2C_FUNC_SMBUS_READ_WORD_DATA | /* 0x00200000 */ 552 + !I2C_FUNC_SMBUS_WRITE_WORD_DATA | /* 0x00400000 */ 553 + !I2C_FUNC_SMBUS_PROC_CALL | /* 0x00800000 */ 554 + !I2C_FUNC_SMBUS_READ_BLOCK_DATA | /* 0x01000000 */ 555 + !I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | /* 0x02000000 */ 556 + ((priv->features & FEATURE_I2C_BLOCK_READ) ? 557 + I2C_FUNC_SMBUS_READ_I2C_BLOCK : 0) | /* 0x04000000 */ 558 + I2C_FUNC_SMBUS_WRITE_I2C_BLOCK | /* 0x08000000 */ 610 559 611 560 I2C_FUNC_SMBUS_BYTE | /* _READ_BYTE _WRITE_BYTE */ 612 - I2C_FUNC_SMBUS_BYTE_DATA | /* _READ_BYTE_DATA _WRITE_BYTE_DATA */ 613 - I2C_FUNC_SMBUS_WORD_DATA | /* _READ_WORD_DATA _WRITE_WORD_DATA */ 614 - I2C_FUNC_SMBUS_BLOCK_DATA | /* _READ_BLOCK_DATA _WRITE_BLOCK_DATA */ 615 - !I2C_FUNC_SMBUS_I2C_BLOCK | /* _READ_I2C_BLOCK _WRITE_I2C_BLOCK */ 616 - !I2C_FUNC_SMBUS_EMUL; /* _QUICK _BYTE _BYTE_DATA _WORD_DATA _PROC_CALL _WRITE_BLOCK_DATA _I2C_BLOCK _PEC */ 561 + I2C_FUNC_SMBUS_BYTE_DATA | /* _READ_BYTE_DATA 562 + * _WRITE_BYTE_DATA 563 + */ 564 + I2C_FUNC_SMBUS_WORD_DATA | /* _READ_WORD_DATA 565 + * _WRITE_WORD_DATA 566 + */ 567 + I2C_FUNC_SMBUS_BLOCK_DATA | /* _READ_BLOCK_DATA 568 + * _WRITE_BLOCK_DATA 569 + */ 570 + !I2C_FUNC_SMBUS_I2C_BLOCK | /* _READ_I2C_BLOCK 571 + * _WRITE_I2C_BLOCK 572 + */ 573 + !I2C_FUNC_SMBUS_EMUL; /* _QUICK _BYTE 574 + * _BYTE_DATA _WORD_DATA 575 + * _PROC_CALL 576 + * _WRITE_BLOCK_DATA 577 + * _I2C_BLOCK _PEC 578 + */ 617 579 return f; 618 580 } 619 581 ··· 683 611 priv->adapter.retries = 3; 684 612 685 613 //snprintf(priv->adapter.name, sizeof(priv->adapter.name), "Fake SMBus I801 adapter at %04lx", priv->smba); 686 - snprintf(priv->adapter.name, sizeof(priv->adapter.name), "Fake SMBus I801 adapter"); 614 + snprintf(priv->adapter.name, sizeof(priv->adapter.name), 615 + "Fake SMBus I801 adapter"); 687 616 688 617 err = i2c_add_adapter(&priv->adapter); 689 618 if (err) {