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