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