1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices 4 // 5 // Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it> 6 // Markus Rechberger <mrechberger@gmail.com> 7 // Mauro Carvalho Chehab <mchehab@kernel.org> 8 // Sascha Sommer <saschasommer@freenet.de> 9 // Copyright (C) 2013 Frank Schäfer <fschaefer.oss@googlemail.com> 10 11 #include "em28xx.h" 12 13 #include <linux/module.h> 14 #include <linux/kernel.h> 15 #include <linux/usb.h> 16 #include <linux/i2c.h> 17 #include <linux/jiffies.h> 18 19 #include "xc2028.h" 20 #include <media/v4l2-common.h> 21 #include <media/tuner.h> 22 23 /* ----------------------------------------------------------- */ 24 25 static unsigned int i2c_scan; 26 module_param(i2c_scan, int, 0444); 27 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time"); 28 29 static unsigned int i2c_debug; 30 module_param(i2c_debug, int, 0644); 31 MODULE_PARM_DESC(i2c_debug, "i2c debug message level (1: normal debug, 2: show I2C transfers)"); 32 33 #define dprintk(level, fmt, arg...) do { \ 34 if (i2c_debug > level) \ 35 dev_printk(KERN_DEBUG, &dev->intf->dev, \ 36 "i2c: %s: " fmt, __func__, ## arg); \ 37 } while (0) 38 39 /* 40 * Time in msecs to wait for i2c xfers to finish. 41 * 35ms is the maximum time a SMBUS device could wait when 42 * clock stretching is used. As the transfer itself will take 43 * some time to happen, set it to 35 ms. 44 * 45 * Ok, I2C doesn't specify any limit. So, eventually, we may need 46 * to increase this timeout. 47 */ 48 #define EM28XX_I2C_XFER_TIMEOUT 35 /* ms */ 49 50 static int em28xx_i2c_timeout(struct em28xx *dev) 51 { 52 int time = EM28XX_I2C_XFER_TIMEOUT; 53 54 switch (dev->i2c_speed & 0x03) { 55 case EM28XX_I2C_FREQ_25_KHZ: 56 time += 4; /* Assume 4 ms for transfers */ 57 break; 58 case EM28XX_I2C_FREQ_100_KHZ: 59 case EM28XX_I2C_FREQ_400_KHZ: 60 time += 1; /* Assume 1 ms for transfers */ 61 break; 62 default: /* EM28XX_I2C_FREQ_1_5_MHZ */ 63 break; 64 } 65 66 return msecs_to_jiffies(time); 67 } 68 69 /* 70 * em2800_i2c_send_bytes() 71 * send up to 4 bytes to the em2800 i2c device 72 */ 73 static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len) 74 { 75 unsigned long timeout = jiffies + em28xx_i2c_timeout(dev); 76 int ret; 77 u8 b2[6]; 78 79 if (len < 1 || len > 4) 80 return -EOPNOTSUPP; 81 82 b2[5] = 0x80 + len - 1; 83 b2[4] = addr; 84 b2[3] = buf[0]; 85 if (len > 1) 86 b2[2] = buf[1]; 87 if (len > 2) 88 b2[1] = buf[2]; 89 if (len > 3) 90 b2[0] = buf[3]; 91 92 /* trigger write */ 93 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len); 94 if (ret != 2 + len) { 95 dev_warn(&dev->intf->dev, 96 "failed to trigger write to i2c address 0x%x (error=%i)\n", 97 addr, ret); 98 return (ret < 0) ? ret : -EIO; 99 } 100 /* wait for completion */ 101 while (time_is_after_jiffies(timeout)) { 102 ret = dev->em28xx_read_reg(dev, 0x05); 103 if (ret == 0x80 + len - 1) 104 return len; 105 if (ret == 0x94 + len - 1) { 106 dprintk(1, "R05 returned 0x%02x: I2C ACK error\n", ret); 107 return -ENXIO; 108 } 109 if (ret < 0) { 110 dev_warn(&dev->intf->dev, 111 "failed to get i2c transfer status from bridge register (error=%i)\n", 112 ret); 113 return ret; 114 } 115 usleep_range(5000, 6000); 116 } 117 dprintk(0, "write to i2c device at 0x%x timed out\n", addr); 118 return -ETIMEDOUT; 119 } 120 121 /* 122 * em2800_i2c_recv_bytes() 123 * read up to 4 bytes from the em2800 i2c device 124 */ 125 static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len) 126 { 127 unsigned long timeout = jiffies + em28xx_i2c_timeout(dev); 128 u8 buf2[4]; 129 int ret; 130 int i; 131 132 if (len < 1 || len > 4) 133 return -EOPNOTSUPP; 134 135 /* trigger read */ 136 buf2[1] = 0x84 + len - 1; 137 buf2[0] = addr; 138 ret = dev->em28xx_write_regs(dev, 0x04, buf2, 2); 139 if (ret != 2) { 140 dev_warn(&dev->intf->dev, 141 "failed to trigger read from i2c address 0x%x (error=%i)\n", 142 addr, ret); 143 return (ret < 0) ? ret : -EIO; 144 } 145 146 /* wait for completion */ 147 while (time_is_after_jiffies(timeout)) { 148 ret = dev->em28xx_read_reg(dev, 0x05); 149 if (ret == 0x84 + len - 1) 150 break; 151 if (ret == 0x94 + len - 1) { 152 dprintk(1, "R05 returned 0x%02x: I2C ACK error\n", 153 ret); 154 return -ENXIO; 155 } 156 if (ret < 0) { 157 dev_warn(&dev->intf->dev, 158 "failed to get i2c transfer status from bridge register (error=%i)\n", 159 ret); 160 return ret; 161 } 162 usleep_range(5000, 6000); 163 } 164 if (ret != 0x84 + len - 1) 165 dprintk(0, "read from i2c device at 0x%x timed out\n", addr); 166 167 /* get the received message */ 168 ret = dev->em28xx_read_reg_req_len(dev, 0x00, 4 - len, buf2, len); 169 if (ret != len) { 170 dev_warn(&dev->intf->dev, 171 "reading from i2c device at 0x%x failed: couldn't get the received message from the bridge (error=%i)\n", 172 addr, ret); 173 return (ret < 0) ? ret : -EIO; 174 } 175 for (i = 0; i < len; i++) 176 buf[i] = buf2[len - 1 - i]; 177 178 return ret; 179 } 180 181 /* 182 * em2800_i2c_check_for_device() 183 * check if there is an i2c device at the supplied address 184 */ 185 static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr) 186 { 187 u8 buf; 188 int ret; 189 190 ret = em2800_i2c_recv_bytes(dev, addr, &buf, 1); 191 if (ret == 1) 192 return 0; 193 return (ret < 0) ? ret : -EIO; 194 } 195 196 /* 197 * em28xx_i2c_send_bytes() 198 */ 199 static int em28xx_i2c_send_bytes(struct em28xx *dev, u16 addr, u8 *buf, 200 u16 len, int stop) 201 { 202 unsigned long timeout = jiffies + em28xx_i2c_timeout(dev); 203 int ret; 204 205 if (len < 1 || len > 64) 206 return -EOPNOTSUPP; 207 /* 208 * NOTE: limited by the USB ctrl message constraints 209 * Zero length reads always succeed, even if no device is connected 210 */ 211 212 /* Write to i2c device */ 213 ret = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len); 214 if (ret != len) { 215 if (ret < 0) { 216 dev_warn(&dev->intf->dev, 217 "writing to i2c device at 0x%x failed (error=%i)\n", 218 addr, ret); 219 return ret; 220 } 221 dev_warn(&dev->intf->dev, 222 "%i bytes write to i2c device at 0x%x requested, but %i bytes written\n", 223 len, addr, ret); 224 return -EIO; 225 } 226 227 /* wait for completion */ 228 while (time_is_after_jiffies(timeout)) { 229 ret = dev->em28xx_read_reg(dev, 0x05); 230 if (ret == 0) /* success */ 231 return len; 232 if (ret == 0x10) { 233 dprintk(1, "I2C ACK error on writing to addr 0x%02x\n", 234 addr); 235 return -ENXIO; 236 } 237 if (ret < 0) { 238 dev_warn(&dev->intf->dev, 239 "failed to get i2c transfer status from bridge register (error=%i)\n", 240 ret); 241 return ret; 242 } 243 usleep_range(5000, 6000); 244 /* 245 * NOTE: do we really have to wait for success ? 246 * Never seen anything else than 0x00 or 0x10 247 * (even with high payload) ... 248 */ 249 } 250 251 if (ret == 0x02 || ret == 0x04) { 252 /* NOTE: these errors seem to be related to clock stretching */ 253 dprintk(0, 254 "write to i2c device at 0x%x timed out (status=%i)\n", 255 addr, ret); 256 return -ETIMEDOUT; 257 } 258 259 dev_warn(&dev->intf->dev, 260 "write to i2c device at 0x%x failed with unknown error (status=%i)\n", 261 addr, ret); 262 return -EIO; 263 } 264 265 /* 266 * em28xx_i2c_recv_bytes() 267 * read a byte from the i2c device 268 */ 269 static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len) 270 { 271 int ret; 272 273 if (len < 1 || len > 64) 274 return -EOPNOTSUPP; 275 /* 276 * NOTE: limited by the USB ctrl message constraints 277 * Zero length reads always succeed, even if no device is connected 278 */ 279 280 /* Read data from i2c device */ 281 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len); 282 if (ret < 0) { 283 dev_warn(&dev->intf->dev, 284 "reading from i2c device at 0x%x failed (error=%i)\n", 285 addr, ret); 286 return ret; 287 } else if (ret != len) { 288 dev_dbg(&dev->intf->dev, 289 "%i bytes read from i2c device at 0x%x requested, but %i bytes written\n", 290 ret, addr, len); 291 } 292 /* 293 * NOTE: some devices with two i2c buses have the bad habit to return 0 294 * bytes if we are on bus B AND there was no write attempt to the 295 * specified slave address before AND no device is present at the 296 * requested slave address. 297 * Anyway, the next check will fail with -ENXIO in this case, so avoid 298 * spamming the system log on device probing and do nothing here. 299 */ 300 301 /* Check success of the i2c operation */ 302 ret = dev->em28xx_read_reg(dev, 0x05); 303 if (ret == 0) /* success */ 304 return len; 305 if (ret < 0) { 306 dev_warn(&dev->intf->dev, 307 "failed to get i2c transfer status from bridge register (error=%i)\n", 308 ret); 309 return ret; 310 } 311 if (ret == 0x10) { 312 dprintk(1, "I2C ACK error on writing to addr 0x%02x\n", 313 addr); 314 return -ENXIO; 315 } 316 317 if (ret == 0x02 || ret == 0x04) { 318 /* NOTE: these errors seem to be related to clock stretching */ 319 dprintk(0, 320 "write to i2c device at 0x%x timed out (status=%i)\n", 321 addr, ret); 322 return -ETIMEDOUT; 323 } 324 325 dev_warn(&dev->intf->dev, 326 "read from i2c device at 0x%x failed with unknown error (status=%i)\n", 327 addr, ret); 328 return -EIO; 329 } 330 331 /* 332 * em28xx_i2c_check_for_device() 333 * check if there is a i2c_device at the supplied address 334 */ 335 static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr) 336 { 337 int ret; 338 u8 buf; 339 340 ret = em28xx_i2c_recv_bytes(dev, addr, &buf, 1); 341 if (ret == 1) 342 return 0; 343 return (ret < 0) ? ret : -EIO; 344 } 345 346 /* 347 * em25xx_bus_B_send_bytes 348 * write bytes to the i2c device 349 */ 350 static int em25xx_bus_B_send_bytes(struct em28xx *dev, u16 addr, u8 *buf, 351 u16 len) 352 { 353 int ret; 354 355 if (len < 1 || len > 64) 356 return -EOPNOTSUPP; 357 /* 358 * NOTE: limited by the USB ctrl message constraints 359 * Zero length reads always succeed, even if no device is connected 360 */ 361 362 /* Set register and write value */ 363 ret = dev->em28xx_write_regs_req(dev, 0x06, addr, buf, len); 364 if (ret != len) { 365 if (ret < 0) { 366 dev_warn(&dev->intf->dev, 367 "writing to i2c device at 0x%x failed (error=%i)\n", 368 addr, ret); 369 return ret; 370 } 371 372 dev_warn(&dev->intf->dev, 373 "%i bytes write to i2c device at 0x%x requested, but %i bytes written\n", 374 len, addr, ret); 375 return -EIO; 376 } 377 /* Check success */ 378 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000); 379 /* 380 * NOTE: the only error we've seen so far is 381 * 0x01 when the slave device is not present 382 */ 383 if (!ret) 384 return len; 385 386 if (ret > 0) { 387 dprintk(1, "Bus B R08 returned 0x%02x: I2C ACK error\n", ret); 388 return -ENXIO; 389 } 390 391 return ret; 392 /* 393 * NOTE: With chip types (other chip IDs) which actually don't support 394 * this operation, it seems to succeed ALWAYS ! (even if there is no 395 * slave device or even no second i2c bus provided) 396 */ 397 } 398 399 /* 400 * em25xx_bus_B_recv_bytes 401 * read bytes from the i2c device 402 */ 403 static int em25xx_bus_B_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, 404 u16 len) 405 { 406 int ret; 407 408 if (len < 1 || len > 64) 409 return -EOPNOTSUPP; 410 /* 411 * NOTE: limited by the USB ctrl message constraints 412 * Zero length reads always succeed, even if no device is connected 413 */ 414 415 /* Read value */ 416 ret = dev->em28xx_read_reg_req_len(dev, 0x06, addr, buf, len); 417 if (ret < 0) { 418 dev_warn(&dev->intf->dev, 419 "reading from i2c device at 0x%x failed (error=%i)\n", 420 addr, ret); 421 return ret; 422 } 423 /* 424 * NOTE: some devices with two i2c buses have the bad habit to return 0 425 * bytes if we are on bus B AND there was no write attempt to the 426 * specified slave address before AND no device is present at the 427 * requested slave address. 428 * Anyway, the next check will fail with -ENXIO in this case, so avoid 429 * spamming the system log on device probing and do nothing here. 430 */ 431 432 /* Check success */ 433 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000); 434 /* 435 * NOTE: the only error we've seen so far is 436 * 0x01 when the slave device is not present 437 */ 438 if (!ret) 439 return len; 440 441 if (ret > 0) { 442 dprintk(1, "Bus B R08 returned 0x%02x: I2C ACK error\n", ret); 443 return -ENXIO; 444 } 445 446 return ret; 447 /* 448 * NOTE: With chip types (other chip IDs) which actually don't support 449 * this operation, it seems to succeed ALWAYS ! (even if there is no 450 * slave device or even no second i2c bus provided) 451 */ 452 } 453 454 /* 455 * em25xx_bus_B_check_for_device() 456 * check if there is a i2c device at the supplied address 457 */ 458 static int em25xx_bus_B_check_for_device(struct em28xx *dev, u16 addr) 459 { 460 u8 buf; 461 int ret; 462 463 ret = em25xx_bus_B_recv_bytes(dev, addr, &buf, 1); 464 if (ret < 0) 465 return ret; 466 467 return 0; 468 /* 469 * NOTE: With chips which do not support this operation, 470 * it seems to succeed ALWAYS ! (even if no device connected) 471 */ 472 } 473 474 static inline int i2c_check_for_device(struct em28xx_i2c_bus *i2c_bus, u16 addr) 475 { 476 struct em28xx *dev = i2c_bus->dev; 477 int rc = -EOPNOTSUPP; 478 479 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) 480 rc = em28xx_i2c_check_for_device(dev, addr); 481 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800) 482 rc = em2800_i2c_check_for_device(dev, addr); 483 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B) 484 rc = em25xx_bus_B_check_for_device(dev, addr); 485 return rc; 486 } 487 488 static inline int i2c_recv_bytes(struct em28xx_i2c_bus *i2c_bus, 489 struct i2c_msg msg) 490 { 491 struct em28xx *dev = i2c_bus->dev; 492 u16 addr = msg.addr << 1; 493 int rc = -EOPNOTSUPP; 494 495 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) 496 rc = em28xx_i2c_recv_bytes(dev, addr, msg.buf, msg.len); 497 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800) 498 rc = em2800_i2c_recv_bytes(dev, addr, msg.buf, msg.len); 499 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B) 500 rc = em25xx_bus_B_recv_bytes(dev, addr, msg.buf, msg.len); 501 return rc; 502 } 503 504 static inline int i2c_send_bytes(struct em28xx_i2c_bus *i2c_bus, 505 struct i2c_msg msg, int stop) 506 { 507 struct em28xx *dev = i2c_bus->dev; 508 u16 addr = msg.addr << 1; 509 int rc = -EOPNOTSUPP; 510 511 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) 512 rc = em28xx_i2c_send_bytes(dev, addr, msg.buf, msg.len, stop); 513 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800) 514 rc = em2800_i2c_send_bytes(dev, addr, msg.buf, msg.len); 515 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B) 516 rc = em25xx_bus_B_send_bytes(dev, addr, msg.buf, msg.len); 517 return rc; 518 } 519 520 /* 521 * em28xx_i2c_xfer() 522 * the main i2c transfer function 523 */ 524 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap, 525 struct i2c_msg msgs[], int num) 526 { 527 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data; 528 struct em28xx *dev = i2c_bus->dev; 529 unsigned int bus = i2c_bus->bus; 530 int addr, rc, i; 531 u8 reg; 532 533 /* 534 * prevent i2c xfer attempts after device is disconnected 535 * some fe's try to do i2c writes/reads from their release 536 * interfaces when called in disconnect path 537 */ 538 if (dev->disconnected) 539 return -ENODEV; 540 541 if (!rt_mutex_trylock(&dev->i2c_bus_lock)) 542 return -EAGAIN; 543 544 /* Switch I2C bus if needed */ 545 if (bus != dev->cur_i2c_bus && 546 i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) { 547 if (bus == 1) 548 reg = EM2874_I2C_SECONDARY_BUS_SELECT; 549 else 550 reg = 0; 551 em28xx_write_reg_bits(dev, EM28XX_R06_I2C_CLK, reg, 552 EM2874_I2C_SECONDARY_BUS_SELECT); 553 dev->cur_i2c_bus = bus; 554 } 555 556 for (i = 0; i < num; i++) { 557 addr = msgs[i].addr << 1; 558 if (!msgs[i].len) { 559 /* 560 * no len: check only for device presence 561 * This code is only called during device probe. 562 */ 563 rc = i2c_check_for_device(i2c_bus, addr); 564 565 if (rc == -ENXIO) 566 rc = -ENODEV; 567 } else if (msgs[i].flags & I2C_M_RD) { 568 /* read bytes */ 569 rc = i2c_recv_bytes(i2c_bus, msgs[i]); 570 } else { 571 /* write bytes */ 572 rc = i2c_send_bytes(i2c_bus, msgs[i], i == num - 1); 573 } 574 575 if (rc < 0) 576 goto error; 577 578 dprintk(2, "%s %s addr=%02x len=%d: %*ph\n", 579 (msgs[i].flags & I2C_M_RD) ? "read" : "write", 580 i == num - 1 ? "stop" : "nonstop", 581 addr, msgs[i].len, 582 msgs[i].len, msgs[i].buf); 583 } 584 585 rt_mutex_unlock(&dev->i2c_bus_lock); 586 return num; 587 588 error: 589 dprintk(2, "%s %s addr=%02x len=%d: %sERROR: %i\n", 590 (msgs[i].flags & I2C_M_RD) ? "read" : "write", 591 i == num - 1 ? "stop" : "nonstop", 592 addr, msgs[i].len, 593 (rc == -ENODEV) ? "no device " : "", 594 rc); 595 596 rt_mutex_unlock(&dev->i2c_bus_lock); 597 return rc; 598 } 599 600 /* 601 * based on linux/sunrpc/svcauth.h and linux/hash.h 602 * The original hash function returns a different value, if arch is x86_64 603 * or i386. 604 */ 605 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits) 606 { 607 unsigned long hash = 0; 608 unsigned long l = 0; 609 int len = 0; 610 unsigned char c; 611 612 do { 613 if (len == length) { 614 c = (char)len; 615 len = -1; 616 } else { 617 c = *buf++; 618 } 619 l = (l << 8) | c; 620 len++; 621 if ((len & (32 / 8 - 1)) == 0) 622 hash = ((hash ^ l) * 0x9e370001UL); 623 } while (len); 624 625 return (hash >> (32 - bits)) & 0xffffffffUL; 626 } 627 628 /* 629 * Helper function to read data blocks from i2c clients with 8 or 16 bit 630 * address width, 8 bit register width and auto incrementation been activated 631 */ 632 static int em28xx_i2c_read_block(struct em28xx *dev, unsigned int bus, u16 addr, 633 bool addr_w16, u16 len, u8 *data) 634 { 635 int remain = len, rsize, rsize_max, ret; 636 u8 buf[2]; 637 638 /* Sanity check */ 639 if (addr + remain > (addr_w16 * 0xff00 + 0xff + 1)) 640 return -EINVAL; 641 /* Select address */ 642 buf[0] = addr >> 8; 643 buf[1] = addr & 0xff; 644 ret = i2c_master_send(&dev->i2c_client[bus], 645 buf + !addr_w16, 1 + addr_w16); 646 if (ret < 0) 647 return ret; 648 /* Read data */ 649 if (dev->board.is_em2800) 650 rsize_max = 4; 651 else 652 rsize_max = 64; 653 while (remain > 0) { 654 if (remain > rsize_max) 655 rsize = rsize_max; 656 else 657 rsize = remain; 658 659 ret = i2c_master_recv(&dev->i2c_client[bus], data, rsize); 660 if (ret < 0) 661 return ret; 662 663 remain -= rsize; 664 data += rsize; 665 } 666 667 return len; 668 } 669 670 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned int bus, 671 u8 **eedata, u16 *eedata_len) 672 { 673 const u16 len = 256; 674 /* 675 * FIXME common length/size for bytes to read, to display, hash 676 * calculation and returned device dataset. Simplifies the code a lot, 677 * but we might have to deal with multiple sizes in the future ! 678 */ 679 int err; 680 struct em28xx_eeprom *dev_config; 681 u8 buf, *data; 682 683 *eedata = NULL; 684 *eedata_len = 0; 685 686 /* EEPROM is always on i2c bus 0 on all known devices. */ 687 688 dev->i2c_client[bus].addr = 0xa0 >> 1; 689 690 /* Check if board has eeprom */ 691 err = i2c_master_recv(&dev->i2c_client[bus], &buf, 0); 692 if (err < 0) { 693 dev_info(&dev->intf->dev, "board has no eeprom\n"); 694 return -ENODEV; 695 } 696 697 data = kzalloc(len, GFP_KERNEL); 698 if (!data) 699 return -ENOMEM; 700 701 /* Read EEPROM content */ 702 err = em28xx_i2c_read_block(dev, bus, 0x0000, 703 dev->eeprom_addrwidth_16bit, 704 len, data); 705 if (err != len) { 706 dev_err(&dev->intf->dev, 707 "failed to read eeprom (err=%d)\n", err); 708 goto error; 709 } 710 711 if (i2c_debug) { 712 /* Display eeprom content */ 713 print_hex_dump(KERN_DEBUG, "em28xx eeprom ", DUMP_PREFIX_OFFSET, 714 16, 1, data, len, true); 715 716 if (dev->eeprom_addrwidth_16bit) 717 dev_info(&dev->intf->dev, 718 "eeprom %06x: ... (skipped)\n", 256); 719 } 720 721 if (dev->eeprom_addrwidth_16bit && 722 data[0] == 0x26 && data[3] == 0x00) { 723 /* new eeprom format; size 4-64kb */ 724 u16 mc_start; 725 u16 hwconf_offset; 726 727 dev->hash = em28xx_hash_mem(data, len, 32); 728 mc_start = (data[1] << 8) + 4; /* usually 0x0004 */ 729 730 dev_info(&dev->intf->dev, 731 "EEPROM ID = %4ph, EEPROM hash = 0x%08lx\n", 732 data, dev->hash); 733 dev_info(&dev->intf->dev, 734 "EEPROM info:\n"); 735 dev_info(&dev->intf->dev, 736 "\tmicrocode start address = 0x%04x, boot configuration = 0x%02x\n", 737 mc_start, data[2]); 738 /* 739 * boot configuration (address 0x0002): 740 * [0] microcode download speed: 1 = 400 kHz; 0 = 100 kHz 741 * [1] always selects 12 kb RAM 742 * [2] USB device speed: 1 = force Full Speed; 0 = auto detect 743 * [4] 1 = force fast mode and no suspend for device testing 744 * [5:7] USB PHY tuning registers; determined by device 745 * characterization 746 */ 747 748 /* 749 * Read hardware config dataset offset from address 750 * (microcode start + 46) 751 */ 752 err = em28xx_i2c_read_block(dev, bus, mc_start + 46, 1, 2, 753 data); 754 if (err != 2) { 755 dev_err(&dev->intf->dev, 756 "failed to read hardware configuration data from eeprom (err=%d)\n", 757 err); 758 goto error; 759 } 760 761 /* Calculate hardware config dataset start address */ 762 hwconf_offset = mc_start + data[0] + (data[1] << 8); 763 764 /* Read hardware config dataset */ 765 /* 766 * NOTE: the microcode copy can be multiple pages long, but 767 * we assume the hardware config dataset is the same as in 768 * the old eeprom and not longer than 256 bytes. 769 * tveeprom is currently also limited to 256 bytes. 770 */ 771 err = em28xx_i2c_read_block(dev, bus, hwconf_offset, 1, len, 772 data); 773 if (err != len) { 774 dev_err(&dev->intf->dev, 775 "failed to read hardware configuration data from eeprom (err=%d)\n", 776 err); 777 goto error; 778 } 779 780 /* Verify hardware config dataset */ 781 /* NOTE: not all devices provide this type of dataset */ 782 if (data[0] != 0x1a || data[1] != 0xeb || 783 data[2] != 0x67 || data[3] != 0x95) { 784 dev_info(&dev->intf->dev, 785 "\tno hardware configuration dataset found in eeprom\n"); 786 kfree(data); 787 return 0; 788 } 789 790 /* 791 * TODO: decrypt eeprom data for camera bridges 792 * (em25xx, em276x+) 793 */ 794 795 } else if (!dev->eeprom_addrwidth_16bit && 796 data[0] == 0x1a && data[1] == 0xeb && 797 data[2] == 0x67 && data[3] == 0x95) { 798 dev->hash = em28xx_hash_mem(data, len, 32); 799 dev_info(&dev->intf->dev, 800 "EEPROM ID = %4ph, EEPROM hash = 0x%08lx\n", 801 data, dev->hash); 802 dev_info(&dev->intf->dev, 803 "EEPROM info:\n"); 804 } else { 805 dev_info(&dev->intf->dev, 806 "unknown eeprom format or eeprom corrupted !\n"); 807 err = -ENODEV; 808 goto error; 809 } 810 811 *eedata = data; 812 *eedata_len = len; 813 dev_config = (void *)*eedata; 814 815 switch (le16_to_cpu(dev_config->chip_conf) >> 4 & 0x3) { 816 case 0: 817 dev_info(&dev->intf->dev, "\tNo audio on board.\n"); 818 break; 819 case 1: 820 dev_info(&dev->intf->dev, "\tAC97 audio (5 sample rates)\n"); 821 break; 822 case 2: 823 if (dev->chip_id < CHIP_ID_EM2860) 824 dev_info(&dev->intf->dev, 825 "\tI2S audio, sample rate=32k\n"); 826 else 827 dev_info(&dev->intf->dev, 828 "\tI2S audio, 3 sample rates\n"); 829 break; 830 case 3: 831 if (dev->chip_id < CHIP_ID_EM2860) 832 dev_info(&dev->intf->dev, 833 "\tI2S audio, 3 sample rates\n"); 834 else 835 dev_info(&dev->intf->dev, 836 "\tI2S audio, 5 sample rates\n"); 837 break; 838 } 839 840 if (le16_to_cpu(dev_config->chip_conf) & 1 << 3) 841 dev_info(&dev->intf->dev, "\tUSB Remote wakeup capable\n"); 842 843 if (le16_to_cpu(dev_config->chip_conf) & 1 << 2) 844 dev_info(&dev->intf->dev, "\tUSB Self power capable\n"); 845 846 switch (le16_to_cpu(dev_config->chip_conf) & 0x3) { 847 case 0: 848 dev_info(&dev->intf->dev, "\t500mA max power\n"); 849 break; 850 case 1: 851 dev_info(&dev->intf->dev, "\t400mA max power\n"); 852 break; 853 case 2: 854 dev_info(&dev->intf->dev, "\t300mA max power\n"); 855 break; 856 case 3: 857 dev_info(&dev->intf->dev, "\t200mA max power\n"); 858 break; 859 } 860 dev_info(&dev->intf->dev, 861 "\tTable at offset 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n", 862 dev_config->string_idx_table, 863 le16_to_cpu(dev_config->string1), 864 le16_to_cpu(dev_config->string2), 865 le16_to_cpu(dev_config->string3)); 866 867 return 0; 868 869 error: 870 kfree(data); 871 return err; 872 } 873 874 /* ----------------------------------------------------------- */ 875 876 /* 877 * functionality() 878 */ 879 static u32 functionality(struct i2c_adapter *i2c_adap) 880 { 881 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data; 882 883 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX || 884 i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B) { 885 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 886 } else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800) { 887 return (I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL) & 888 ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA; 889 } 890 891 WARN(1, "Unknown i2c bus algorithm.\n"); 892 return 0; 893 } 894 895 static const struct i2c_algorithm em28xx_algo = { 896 .master_xfer = em28xx_i2c_xfer, 897 .functionality = functionality, 898 }; 899 900 static const struct i2c_adapter em28xx_adap_template = { 901 .owner = THIS_MODULE, 902 .name = "em28xx", 903 .algo = &em28xx_algo, 904 }; 905 906 static const struct i2c_client em28xx_client_template = { 907 .name = "em28xx internal", 908 }; 909 910 /* ----------------------------------------------------------- */ 911 912 /* 913 * i2c_devs 914 * incomplete list of known devices 915 */ 916 static char *i2c_devs[128] = { 917 [0x1c >> 1] = "lgdt330x", 918 [0x3e >> 1] = "remote IR sensor", 919 [0x4a >> 1] = "saa7113h", 920 [0x52 >> 1] = "drxk", 921 [0x60 >> 1] = "remote IR sensor", 922 [0x8e >> 1] = "remote IR sensor", 923 [0x86 >> 1] = "tda9887", 924 [0x80 >> 1] = "msp34xx", 925 [0x88 >> 1] = "msp34xx", 926 [0xa0 >> 1] = "eeprom", 927 [0xb0 >> 1] = "tda9874", 928 [0xb8 >> 1] = "tvp5150a", 929 [0xba >> 1] = "webcam sensor or tvp5150a", 930 [0xc0 >> 1] = "tuner (analog)", 931 [0xc2 >> 1] = "tuner (analog)", 932 [0xc4 >> 1] = "tuner (analog)", 933 [0xc6 >> 1] = "tuner (analog)", 934 }; 935 936 /* 937 * do_i2c_scan() 938 * check i2c address range for devices 939 */ 940 void em28xx_do_i2c_scan(struct em28xx *dev, unsigned int bus) 941 { 942 u8 i2c_devicelist[128]; 943 unsigned char buf; 944 int i, rc; 945 946 memset(i2c_devicelist, 0, sizeof(i2c_devicelist)); 947 948 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) { 949 dev->i2c_client[bus].addr = i; 950 rc = i2c_master_recv(&dev->i2c_client[bus], &buf, 0); 951 if (rc < 0) 952 continue; 953 i2c_devicelist[i] = i; 954 dev_info(&dev->intf->dev, 955 "found i2c device @ 0x%x on bus %d [%s]\n", 956 i << 1, bus, i2c_devs[i] ? i2c_devs[i] : "???"); 957 } 958 959 if (bus == dev->def_i2c_bus) 960 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist, 961 sizeof(i2c_devicelist), 32); 962 } 963 964 /* 965 * em28xx_i2c_register() 966 * register i2c bus 967 */ 968 int em28xx_i2c_register(struct em28xx *dev, unsigned int bus, 969 enum em28xx_i2c_algo_type algo_type) 970 { 971 int retval; 972 973 if (WARN_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg || 974 !dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req)) 975 return -ENODEV; 976 977 if (bus >= NUM_I2C_BUSES) 978 return -ENODEV; 979 980 dev->i2c_adap[bus] = em28xx_adap_template; 981 dev->i2c_adap[bus].dev.parent = &dev->intf->dev; 982 strscpy(dev->i2c_adap[bus].name, dev_name(&dev->intf->dev), 983 sizeof(dev->i2c_adap[bus].name)); 984 985 dev->i2c_bus[bus].bus = bus; 986 dev->i2c_bus[bus].algo_type = algo_type; 987 dev->i2c_bus[bus].dev = dev; 988 dev->i2c_adap[bus].algo_data = &dev->i2c_bus[bus]; 989 990 retval = i2c_add_adapter(&dev->i2c_adap[bus]); 991 if (retval < 0) { 992 dev_err(&dev->intf->dev, 993 "%s: i2c_add_adapter failed! retval [%d]\n", 994 __func__, retval); 995 return retval; 996 } 997 998 dev->i2c_client[bus] = em28xx_client_template; 999 dev->i2c_client[bus].adapter = &dev->i2c_adap[bus]; 1000 1001 /* Up to now, all eeproms are at bus 0 */ 1002 if (!bus) { 1003 retval = em28xx_i2c_eeprom(dev, bus, 1004 &dev->eedata, &dev->eedata_len); 1005 if (retval < 0 && retval != -ENODEV) { 1006 dev_err(&dev->intf->dev, 1007 "%s: em28xx_i2_eeprom failed! retval [%d]\n", 1008 __func__, retval); 1009 } 1010 } 1011 1012 if (i2c_scan) 1013 em28xx_do_i2c_scan(dev, bus); 1014 1015 return 0; 1016 } 1017 1018 /* 1019 * em28xx_i2c_unregister() 1020 * unregister i2c_bus 1021 */ 1022 int em28xx_i2c_unregister(struct em28xx *dev, unsigned int bus) 1023 { 1024 if (bus >= NUM_I2C_BUSES) 1025 return -ENODEV; 1026 1027 i2c_del_adapter(&dev->i2c_adap[bus]); 1028 return 0; 1029 } 1030