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 * algo_control() 387 */ 388static int algo_control(struct i2c_adapter *adapter, 389 unsigned int cmd, unsigned long arg) 390{ 391 return 0; 392} 393 394/* 395 * functionality() 396 */ 397static u32 functionality(struct i2c_adapter *adap) 398{ 399 return I2C_FUNC_SMBUS_EMUL; 400} 401 402 403static int em28xx_set_tuner(int check_eeprom, struct i2c_client *client) 404{ 405 struct em28xx *dev = client->adapter->algo_data; 406 struct tuner_setup tun_setup; 407 408 if (dev->has_tuner) { 409 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 410 tun_setup.type = dev->tuner_type; 411 tun_setup.addr = dev->tuner_addr; 412 em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup); 413 } 414 415 return (0); 416} 417 418/* 419 * attach_inform() 420 * gets called when a device attaches to the i2c bus 421 * does some basic configuration 422 */ 423static int attach_inform(struct i2c_client *client) 424{ 425 struct em28xx *dev = client->adapter->algo_data; 426 427 switch (client->addr << 1) { 428 case 0x43: 429 case 0x4b: 430 { 431 struct tuner_setup tun_setup; 432 433 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 434 tun_setup.type = TUNER_TDA9887; 435 tun_setup.addr = client->addr; 436 437 em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup); 438 em28xx_i2c_call_clients(dev, TDA9887_SET_CONFIG, &dev->tda9887_conf); 439 break; 440 } 441 case 0x42: 442 dprintk1(1,"attach_inform: saa7114 detected.\n"); 443 break; 444 case 0x4a: 445 dprintk1(1,"attach_inform: saa7113 detected.\n"); 446 break; 447 case 0xa0: 448 dprintk1(1,"attach_inform: eeprom detected.\n"); 449 break; 450 case 0x60: 451 case 0x8e: 452 { 453 struct IR_i2c *ir = i2c_get_clientdata(client); 454 dprintk1(1,"attach_inform: IR detected (%s).\n",ir->phys); 455 em28xx_set_ir(dev,ir); 456 break; 457 } 458 case 0x80: 459 case 0x88: 460 dprintk1(1,"attach_inform: msp34xx detected.\n"); 461 break; 462 case 0xb8: 463 case 0xba: 464 dprintk1(1,"attach_inform: tvp5150 detected.\n"); 465 break; 466 467 default: 468 dprintk1(1,"attach inform: detected I2C address %x\n", client->addr << 1); 469 dev->tuner_addr = client->addr; 470 em28xx_set_tuner(-1, client); 471 } 472 473 return 0; 474} 475 476static struct i2c_algorithm em28xx_algo = { 477 .master_xfer = em28xx_i2c_xfer, 478 .algo_control = algo_control, 479 .functionality = functionality, 480}; 481 482static struct i2c_adapter em28xx_adap_template = { 483 .owner = THIS_MODULE, 484 .class = I2C_CLASS_TV_ANALOG, 485 .name = "em28xx", 486 .id = I2C_HW_B_EM28XX, 487 .algo = &em28xx_algo, 488 .client_register = attach_inform, 489}; 490 491static struct i2c_client em28xx_client_template = { 492 .name = "em28xx internal", 493}; 494 495/* ----------------------------------------------------------- */ 496 497/* 498 * i2c_devs 499 * incomplete list of known devices 500 */ 501static char *i2c_devs[128] = { 502 [0x4a >> 1] = "saa7113h", 503 [0x60 >> 1] = "remote IR sensor", 504 [0x8e >> 1] = "remote IR sensor", 505 [0x86 >> 1] = "tda9887", 506 [0x80 >> 1] = "msp34xx", 507 [0x88 >> 1] = "msp34xx", 508 [0xa0 >> 1] = "eeprom", 509 [0xb8 >> 1] = "tvp5150a", 510 [0xba >> 1] = "tvp5150a", 511 [0xc0 >> 1] = "tuner (analog)", 512 [0xc2 >> 1] = "tuner (analog)", 513 [0xc4 >> 1] = "tuner (analog)", 514 [0xc6 >> 1] = "tuner (analog)", 515}; 516 517/* 518 * do_i2c_scan() 519 * check i2c address range for devices 520 */ 521static void do_i2c_scan(char *name, struct i2c_client *c) 522{ 523 unsigned char buf; 524 int i, rc; 525 526 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) { 527 c->addr = i; 528 rc = i2c_master_recv(c, &buf, 0); 529 if (rc < 0) 530 continue; 531 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n", name, 532 i << 1, i2c_devs[i] ? i2c_devs[i] : "???"); 533 } 534} 535 536/* 537 * em28xx_i2c_call_clients() 538 * send commands to all attached i2c devices 539 */ 540void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg) 541{ 542 BUG_ON(NULL == dev->i2c_adap.algo_data); 543 i2c_clients_command(&dev->i2c_adap, cmd, arg); 544} 545 546/* 547 * em28xx_i2c_register() 548 * register i2c bus 549 */ 550int em28xx_i2c_register(struct em28xx *dev) 551{ 552 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg); 553 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req); 554 dev->i2c_adap = em28xx_adap_template; 555 dev->i2c_adap.dev.parent = &dev->udev->dev; 556 strcpy(dev->i2c_adap.name, dev->name); 557 dev->i2c_adap.algo_data = dev; 558 i2c_add_adapter(&dev->i2c_adap); 559 560 dev->i2c_client = em28xx_client_template; 561 dev->i2c_client.adapter = &dev->i2c_adap; 562 563 em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata)); 564 565 if (i2c_scan) 566 do_i2c_scan(dev->name, &dev->i2c_client); 567 return 0; 568} 569 570/* 571 * em28xx_i2c_unregister() 572 * unregister i2c_bus 573 */ 574int em28xx_i2c_unregister(struct em28xx *dev) 575{ 576 i2c_del_adapter(&dev->i2c_adap); 577 return 0; 578} 579