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