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 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24#include <linux/module.h> 25#include <linux/kernel.h> 26#include <linux/usb.h> 27#include <linux/i2c.h> 28 29#include "em28xx.h" 30#include "tuner-xc2028.h" 31#include <media/v4l2-common.h> 32#include <media/tuner.h> 33 34/* ----------------------------------------------------------- */ 35 36static unsigned int i2c_scan; 37module_param(i2c_scan, int, 0444); 38MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time"); 39 40static unsigned int i2c_debug; 41module_param(i2c_debug, int, 0644); 42MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]"); 43 44#define dprintk2(lvl, fmt, args...) \ 45do { \ 46 if (i2c_debug >= lvl) { \ 47 printk(KERN_DEBUG "%s at %s: " fmt, \ 48 dev->name, __func__ , ##args); \ 49 } \ 50} while (0) 51 52/* 53 * em2800_i2c_send_max4() 54 * send up to 4 bytes to the i2c device 55 */ 56static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr, 57 char *buf, int len) 58{ 59 int ret; 60 int write_timeout; 61 unsigned char b2[6]; 62 BUG_ON(len < 1 || len > 4); 63 b2[5] = 0x80 + len - 1; 64 b2[4] = addr; 65 b2[3] = buf[0]; 66 if (len > 1) 67 b2[2] = buf[1]; 68 if (len > 2) 69 b2[1] = buf[2]; 70 if (len > 3) 71 b2[0] = buf[3]; 72 73 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len); 74 if (ret != 2 + len) { 75 em28xx_warn("writing to i2c device failed (error=%i)\n", ret); 76 return -EIO; 77 } 78 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0; 79 write_timeout -= 5) { 80 ret = dev->em28xx_read_reg(dev, 0x05); 81 if (ret == 0x80 + len - 1) 82 return len; 83 msleep(5); 84 } 85 em28xx_warn("i2c write timed out\n"); 86 return -EIO; 87} 88 89/* 90 * em2800_i2c_send_bytes() 91 */ 92static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf, 93 short len) 94{ 95 char *bufPtr = buf; 96 int ret; 97 int wrcount = 0; 98 int count; 99 int maxLen = 4; 100 struct em28xx *dev = (struct em28xx *)data; 101 while (len > 0) { 102 count = (len > maxLen) ? maxLen : len; 103 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count); 104 if (ret > 0) { 105 len -= count; 106 bufPtr += count; 107 wrcount += count; 108 } else 109 return (ret < 0) ? ret : -EFAULT; 110 } 111 return wrcount; 112} 113 114/* 115 * em2800_i2c_check_for_device() 116 * check if there is a i2c_device at the supplied address 117 */ 118static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr) 119{ 120 char msg; 121 int ret; 122 int write_timeout; 123 msg = addr; 124 ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1); 125 if (ret < 0) { 126 em28xx_warn("setting i2c device address failed (error=%i)\n", 127 ret); 128 return ret; 129 } 130 msg = 0x84; 131 ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1); 132 if (ret < 0) { 133 em28xx_warn("preparing i2c read failed (error=%i)\n", ret); 134 return ret; 135 } 136 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0; 137 write_timeout -= 5) { 138 unsigned reg = dev->em28xx_read_reg(dev, 0x5); 139 140 if (reg == 0x94) 141 return -ENODEV; 142 else if (reg == 0x84) 143 return 0; 144 msleep(5); 145 } 146 return -ENODEV; 147} 148 149/* 150 * em2800_i2c_recv_bytes() 151 * read from the i2c device 152 */ 153static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr, 154 char *buf, int len) 155{ 156 int ret; 157 /* check for the device and set i2c read address */ 158 ret = em2800_i2c_check_for_device(dev, addr); 159 if (ret) { 160 em28xx_warn 161 ("preparing read at i2c address 0x%x failed (error=%i)\n", 162 addr, ret); 163 return ret; 164 } 165 ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len); 166 if (ret < 0) { 167 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)", 168 addr, ret); 169 return ret; 170 } 171 return ret; 172} 173 174/* 175 * em28xx_i2c_send_bytes() 176 */ 177static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf, 178 short len, int stop) 179{ 180 int wrcount = 0; 181 struct em28xx *dev = (struct em28xx *)data; 182 int write_timeout, ret; 183 184 wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len); 185 186 /* Seems to be required after a write */ 187 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0; 188 write_timeout -= 5) { 189 ret = dev->em28xx_read_reg(dev, 0x05); 190 if (!ret) 191 break; 192 msleep(5); 193 } 194 195 return wrcount; 196} 197 198/* 199 * em28xx_i2c_recv_bytes() 200 * read a byte from the i2c device 201 */ 202static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr, 203 char *buf, int len) 204{ 205 int ret; 206 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len); 207 if (ret < 0) { 208 em28xx_warn("reading i2c device failed (error=%i)\n", ret); 209 return ret; 210 } 211 if (dev->em28xx_read_reg(dev, 0x5) != 0) 212 return -ENODEV; 213 return ret; 214} 215 216/* 217 * em28xx_i2c_check_for_device() 218 * check if there is a i2c_device at the supplied address 219 */ 220static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr) 221{ 222 int ret; 223 224 ret = dev->em28xx_read_reg_req(dev, 2, addr); 225 if (ret < 0) { 226 em28xx_warn("reading from i2c device failed (error=%i)\n", ret); 227 return ret; 228 } 229 if (dev->em28xx_read_reg(dev, 0x5) != 0) 230 return -ENODEV; 231 return 0; 232} 233 234/* 235 * em28xx_i2c_xfer() 236 * the main i2c transfer function 237 */ 238static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap, 239 struct i2c_msg msgs[], int num) 240{ 241 struct em28xx *dev = i2c_adap->algo_data; 242 int addr, rc, i, byte; 243 244 if (num <= 0) 245 return 0; 246 for (i = 0; i < num; i++) { 247 addr = msgs[i].addr << 1; 248 dprintk2(2, "%s %s addr=%x len=%d:", 249 (msgs[i].flags & I2C_M_RD) ? "read" : "write", 250 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len); 251 if (!msgs[i].len) { /* no len: check only for device presence */ 252 if (dev->board.is_em2800) 253 rc = em2800_i2c_check_for_device(dev, addr); 254 else 255 rc = em28xx_i2c_check_for_device(dev, addr); 256 if (rc < 0) { 257 dprintk2(2, " no device\n"); 258 return rc; 259 } 260 261 } else if (msgs[i].flags & I2C_M_RD) { 262 /* read bytes */ 263 if (dev->board.is_em2800) 264 rc = em2800_i2c_recv_bytes(dev, addr, 265 msgs[i].buf, 266 msgs[i].len); 267 else 268 rc = em28xx_i2c_recv_bytes(dev, addr, 269 msgs[i].buf, 270 msgs[i].len); 271 if (i2c_debug >= 2) { 272 for (byte = 0; byte < msgs[i].len; byte++) 273 printk(" %02x", msgs[i].buf[byte]); 274 } 275 } else { 276 /* write bytes */ 277 if (i2c_debug >= 2) { 278 for (byte = 0; byte < msgs[i].len; byte++) 279 printk(" %02x", msgs[i].buf[byte]); 280 } 281 if (dev->board.is_em2800) 282 rc = em2800_i2c_send_bytes(dev, addr, 283 msgs[i].buf, 284 msgs[i].len); 285 else 286 rc = em28xx_i2c_send_bytes(dev, addr, 287 msgs[i].buf, 288 msgs[i].len, 289 i == num - 1); 290 } 291 if (rc < 0) 292 goto err; 293 if (i2c_debug >= 2) 294 printk("\n"); 295 } 296 297 return num; 298err: 299 dprintk2(2, " ERROR: %i\n", rc); 300 return rc; 301} 302 303/* based on linux/sunrpc/svcauth.h and linux/hash.h 304 * The original hash function returns a different value, if arch is x86_64 305 * or i386. 306 */ 307static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits) 308{ 309 unsigned long hash = 0; 310 unsigned long l = 0; 311 int len = 0; 312 unsigned char c; 313 do { 314 if (len == length) { 315 c = (char)len; 316 len = -1; 317 } else 318 c = *buf++; 319 l = (l << 8) | c; 320 len++; 321 if ((len & (32 / 8 - 1)) == 0) 322 hash = ((hash^l) * 0x9e370001UL); 323 } while (len); 324 325 return (hash >> (32 - bits)) & 0xffffffffUL; 326} 327 328static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len) 329{ 330 unsigned char buf, *p = eedata; 331 struct em28xx_eeprom *em_eeprom = (void *)eedata; 332 int i, err, size = len, block; 333 334 if (dev->chip_id == CHIP_ID_EM2874 || 335 dev->chip_id == CHIP_ID_EM28174 || 336 dev->chip_id == CHIP_ID_EM2884) { 337 /* Empia switched to a 16-bit addressable eeprom in newer 338 devices. While we could certainly write a routine to read 339 the eeprom, there is nothing of use in there that cannot be 340 accessed through registers, and there is the risk that we 341 could corrupt the eeprom (since a 16-bit read call is 342 interpreted as a write call by 8-bit eeproms). 343 */ 344 return 0; 345 } 346 347 dev->i2c_client.addr = 0xa0 >> 1; 348 349 /* Check if board has eeprom */ 350 err = i2c_master_recv(&dev->i2c_client, &buf, 0); 351 if (err < 0) { 352 em28xx_errdev("board has no eeprom\n"); 353 memset(eedata, 0, len); 354 return -ENODEV; 355 } 356 357 buf = 0; 358 359 err = i2c_master_send(&dev->i2c_client, &buf, 1); 360 if (err != 1) { 361 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n", 362 dev->name, err); 363 return err; 364 } 365 while (size > 0) { 366 if (size > 16) 367 block = 16; 368 else 369 block = size; 370 371 if (block != 372 (err = i2c_master_recv(&dev->i2c_client, p, block))) { 373 printk(KERN_WARNING 374 "%s: i2c eeprom read error (err=%d)\n", 375 dev->name, err); 376 return err; 377 } 378 size -= block; 379 p += block; 380 } 381 for (i = 0; i < len; i++) { 382 if (0 == (i % 16)) 383 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i); 384 printk(" %02x", eedata[i]); 385 if (15 == (i % 16)) 386 printk("\n"); 387 } 388 389 if (em_eeprom->id == 0x9567eb1a) 390 dev->hash = em28xx_hash_mem(eedata, len, 32); 391 392 printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n", 393 dev->name, em_eeprom->id, dev->hash); 394 395 printk(KERN_INFO "%s: EEPROM info:\n", dev->name); 396 397 switch (em_eeprom->chip_conf >> 4 & 0x3) { 398 case 0: 399 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name); 400 break; 401 case 1: 402 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n", 403 dev->name); 404 break; 405 case 2: 406 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n", 407 dev->name); 408 break; 409 case 3: 410 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n", 411 dev->name); 412 break; 413 } 414 415 if (em_eeprom->chip_conf & 1 << 3) 416 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name); 417 418 if (em_eeprom->chip_conf & 1 << 2) 419 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name); 420 421 switch (em_eeprom->chip_conf & 0x3) { 422 case 0: 423 printk(KERN_INFO "%s:\t500mA max power\n", dev->name); 424 break; 425 case 1: 426 printk(KERN_INFO "%s:\t400mA max power\n", dev->name); 427 break; 428 case 2: 429 printk(KERN_INFO "%s:\t300mA max power\n", dev->name); 430 break; 431 case 3: 432 printk(KERN_INFO "%s:\t200mA max power\n", dev->name); 433 break; 434 } 435 printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n", 436 dev->name, 437 em_eeprom->string_idx_table, 438 em_eeprom->string1, 439 em_eeprom->string2, 440 em_eeprom->string3); 441 442 return 0; 443} 444 445/* ----------------------------------------------------------- */ 446 447/* 448 * functionality() 449 */ 450static u32 functionality(struct i2c_adapter *adap) 451{ 452 return I2C_FUNC_SMBUS_EMUL; 453} 454 455static struct i2c_algorithm em28xx_algo = { 456 .master_xfer = em28xx_i2c_xfer, 457 .functionality = functionality, 458}; 459 460static struct i2c_adapter em28xx_adap_template = { 461 .owner = THIS_MODULE, 462 .name = "em28xx", 463 .algo = &em28xx_algo, 464}; 465 466static struct i2c_client em28xx_client_template = { 467 .name = "em28xx internal", 468}; 469 470/* ----------------------------------------------------------- */ 471 472/* 473 * i2c_devs 474 * incomplete list of known devices 475 */ 476static char *i2c_devs[128] = { 477 [0x4a >> 1] = "saa7113h", 478 [0x60 >> 1] = "remote IR sensor", 479 [0x8e >> 1] = "remote IR sensor", 480 [0x86 >> 1] = "tda9887", 481 [0x80 >> 1] = "msp34xx", 482 [0x88 >> 1] = "msp34xx", 483 [0xa0 >> 1] = "eeprom", 484 [0xb0 >> 1] = "tda9874", 485 [0xb8 >> 1] = "tvp5150a", 486 [0xba >> 1] = "webcam sensor or tvp5150a", 487 [0xc0 >> 1] = "tuner (analog)", 488 [0xc2 >> 1] = "tuner (analog)", 489 [0xc4 >> 1] = "tuner (analog)", 490 [0xc6 >> 1] = "tuner (analog)", 491}; 492 493/* 494 * do_i2c_scan() 495 * check i2c address range for devices 496 */ 497void em28xx_do_i2c_scan(struct em28xx *dev) 498{ 499 u8 i2c_devicelist[128]; 500 unsigned char buf; 501 int i, rc; 502 503 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist)); 504 505 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) { 506 dev->i2c_client.addr = i; 507 rc = i2c_master_recv(&dev->i2c_client, &buf, 0); 508 if (rc < 0) 509 continue; 510 i2c_devicelist[i] = i; 511 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n", 512 dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???"); 513 } 514 515 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist, 516 ARRAY_SIZE(i2c_devicelist), 32); 517} 518 519/* 520 * em28xx_i2c_register() 521 * register i2c bus 522 */ 523int em28xx_i2c_register(struct em28xx *dev) 524{ 525 int retval; 526 527 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg); 528 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req); 529 dev->i2c_adap = em28xx_adap_template; 530 dev->i2c_adap.dev.parent = &dev->udev->dev; 531 strcpy(dev->i2c_adap.name, dev->name); 532 dev->i2c_adap.algo_data = dev; 533 i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev); 534 535 retval = i2c_add_adapter(&dev->i2c_adap); 536 if (retval < 0) { 537 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n", 538 __func__, retval); 539 return retval; 540 } 541 542 dev->i2c_client = em28xx_client_template; 543 dev->i2c_client.adapter = &dev->i2c_adap; 544 545 retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata)); 546 if ((retval < 0) && (retval != -ENODEV)) { 547 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n", 548 __func__, retval); 549 550 return retval; 551 } 552 553 if (i2c_scan) 554 em28xx_do_i2c_scan(dev); 555 556 /* Instantiate the IR receiver device, if present */ 557 em28xx_register_i2c_ir(dev); 558 559 return 0; 560} 561 562/* 563 * em28xx_i2c_unregister() 564 * unregister i2c_bus 565 */ 566int em28xx_i2c_unregister(struct em28xx *dev) 567{ 568 i2c_del_adapter(&dev->i2c_adap); 569 return 0; 570} 571