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