em28xx-i2c.c revision da45a2a5b96afd7188c058a55eb2917d6524c0cf
1/* 2 em2820-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices 3 4 Copyright (C) 2005 Markus Rechberger <mrechberger@gmail.com> 5 Ludovico Cavedon <cavedon@sssup.it> 6 Mauro Carvalho Chehab <mchehab@brturbo.com.br> 7 8 Based on the em2800 driver from Sascha Sommer <saschasommer@freenet.de> 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 <media/tuner.h> 30#include <linux/video_decoder.h> 31 32#include "em2820.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 dprintk(fmt, args...) if (i2c_debug) do {\ 45 printk(KERN_DEBUG "%s: %s: " fmt "\n",\ 46 dev->name, __FUNCTION__ , ##args); } while (0) 47#define dprintk1(fmt, args...) if (i2c_debug) do{ \ 48 printk(KERN_DEBUG "%s: %s: " fmt, \ 49 dev->name, __FUNCTION__ , ##args); } while (0) 50#define dprintk2(fmt, args...) if (i2c_debug) do {\ 51 printk(fmt , ##args); } while (0) 52 53/* 54 * em2800_i2c_send_max4() 55 * send up to 4 bytes to the i2c device 56 */ 57static int em2800_i2c_send_max4(struct em2820 *dev, unsigned char addr, 58 char *buf, int len) 59{ 60 int ret; 61 int write_timeout; 62 unsigned char b2[6]; 63 BUG_ON(len < 1 || len > 4); 64 b2[5] = 0x80 + len - 1; 65 b2[4] = addr; 66 b2[3] = buf[0]; 67 if (len > 1) 68 b2[2] = buf[1]; 69 if (len > 2) 70 b2[1] = buf[2]; 71 if (len > 3) 72 b2[0] = buf[3]; 73 74 ret = dev->em2820_write_regs(dev, 4 - len, &b2[4 - len], 2 + len); 75 if (ret != 2 + len) { 76 em2820_warn("writting to i2c device failed (error=%i)\n", ret); 77 return -EIO; 78 } 79 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0; 80 write_timeout -= 5) { 81 ret = dev->em2820_read_reg(dev, 0x05); 82 if (ret == 0x80 + len - 1) 83 return len; 84 mdelay(5); 85 } 86 em2820_warn("i2c write timed out\n"); 87 return -EIO; 88} 89 90/* 91 * em2800_i2c_send_bytes() 92 */ 93static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf, 94 short len) 95{ 96 char *bufPtr = buf; 97 int ret; 98 int wrcount = 0; 99 int count; 100 int maxLen = 4; 101 struct em2820 *dev = (struct em2820 *)data; 102 while (len > 0) { 103 count = (len > maxLen) ? maxLen : len; 104 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count); 105 if (ret > 0) { 106 len -= count; 107 bufPtr += count; 108 wrcount += count; 109 } else 110 return (ret < 0) ? ret : -EFAULT; 111 } 112 return wrcount; 113} 114 115/* 116 * em2800_i2c_check_for_device() 117 * check if there is a i2c_device at the supplied address 118 */ 119static int em2800_i2c_check_for_device(struct em2820 *dev, unsigned char addr) 120{ 121 char msg; 122 int ret; 123 int write_timeout; 124 msg = addr; 125 ret = dev->em2820_write_regs(dev, 0x04, &msg, 1); 126 if (ret < 0) { 127 em2820_warn("setting i2c device address failed (error=%i)\n", 128 ret); 129 return ret; 130 } 131 msg = 0x84; 132 ret = dev->em2820_write_regs(dev, 0x05, &msg, 1); 133 if (ret < 0) { 134 em2820_warn("preparing i2c read failed (error=%i)\n", ret); 135 return ret; 136 } 137 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0; 138 write_timeout -= 5) { 139 unsigned msg = dev->em2820_read_reg(dev, 0x5); 140 if (msg == 0x94) 141 return -ENODEV; 142 else if (msg == 0x84) 143 return 0; 144 mdelay(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 em2820 *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 em2820_warn 161 ("preparing read at i2c address 0x%x failed (error=%i)\n", 162 addr, ret); 163 return ret; 164 } 165 ret = dev->em2820_read_reg_req_len(dev, 0x0, 0x3, buf, len); 166 if (ret < 0) { 167 em2820_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 * em2820_i2c_send_bytes() 176 * untested for more than 4 bytes 177 */ 178static int em2820_i2c_send_bytes(void *data, unsigned char addr, char *buf, 179 short len, int stop) 180{ 181 int wrcount = 0; 182 struct em2820 *dev = (struct em2820 *)data; 183 184 wrcount = dev->em2820_write_regs_req(dev, stop ? 2 : 3, addr, buf, len); 185 186 return wrcount; 187} 188 189/* 190 * em2820_i2c_recv_bytes() 191 * read a byte from the i2c device 192 */ 193static int em2820_i2c_recv_bytes(struct em2820 *dev, unsigned char addr, 194 char *buf, int len) 195{ 196 int ret; 197 ret = dev->em2820_read_reg_req_len(dev, 2, addr, buf, len); 198 if (ret < 0) { 199 em2820_warn("reading i2c device failed (error=%i)\n", ret); 200 return ret; 201 } 202 if (dev->em2820_read_reg(dev, 0x5) != 0) 203 return -ENODEV; 204 return ret; 205} 206 207/* 208 * em2820_i2c_check_for_device() 209 * check if there is a i2c_device at the supplied address 210 */ 211static int em2820_i2c_check_for_device(struct em2820 *dev, unsigned char addr) 212{ 213 char msg; 214 int ret; 215 msg = addr; 216 217 ret = dev->em2820_read_reg_req(dev, 2, addr); 218 if (ret < 0) { 219 em2820_warn("reading from i2c device failed (error=%i)\n", ret); 220 return ret; 221 } 222 if (dev->em2820_read_reg(dev, 0x5) != 0) 223 return -ENODEV; 224 return 0; 225} 226 227/* 228 * em2820_i2c_xfer() 229 * the main i2c transfer function 230 */ 231static int em2820_i2c_xfer(struct i2c_adapter *i2c_adap, 232 struct i2c_msg msgs[], int num) 233{ 234 struct em2820 *dev = i2c_adap->algo_data; 235 int addr, rc, i, byte; 236 237 if (num <= 0) 238 return 0; 239 for (i = 0; i < num; i++) { 240 addr = msgs[i].addr << 1; 241 dprintk1("%s %s addr=%x len=%d:", 242 (msgs[i].flags & I2C_M_RD) ? "read" : "write", 243 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len); 244 if (!msgs[i].len) { /* no len: check only for device presence */ 245 if (dev->is_em2800) 246 rc = em2800_i2c_check_for_device(dev, addr); 247 else 248 rc = em2820_i2c_check_for_device(dev, addr); 249 if (rc < 0) { 250 dprintk2(" no device\n"); 251 return rc; 252 } 253 254 } else if (msgs[i].flags & I2C_M_RD) { 255 /* read bytes */ 256 if (dev->is_em2800) 257 rc = em2800_i2c_recv_bytes(dev, addr, 258 msgs[i].buf, 259 msgs[i].len); 260 else 261 rc = em2820_i2c_recv_bytes(dev, addr, 262 msgs[i].buf, 263 msgs[i].len); 264 if (i2c_debug) { 265 for (byte = 0; byte < msgs[i].len; byte++) { 266 printk(" %02x", msgs[i].buf[byte]); 267 } 268 } 269 } else { 270 /* write bytes */ 271 if (i2c_debug) { 272 for (byte = 0; byte < msgs[i].len; byte++) 273 printk(" %02x", msgs[i].buf[byte]); 274 } 275 if (dev->is_em2800) 276 rc = em2800_i2c_send_bytes(dev, addr, 277 msgs[i].buf, 278 msgs[i].len); 279 else 280 rc = em2820_i2c_send_bytes(dev, addr, 281 msgs[i].buf, 282 msgs[i].len, 283 i == num - 1); 284 if (rc < 0) 285 goto err; 286 } 287 if (i2c_debug) 288 printk("\n"); 289 } 290 291 return num; 292 err: 293 dprintk2(" ERROR: %i\n", rc); 294 return rc; 295} 296 297static int em2820_i2c_eeprom(struct em2820 *dev, unsigned char *eedata, int len) 298{ 299 unsigned char buf, *p = eedata; 300 struct em2820_eeprom *em_eeprom = (void *)eedata; 301 int i, err, size = len, block; 302 303 dev->i2c_client.addr = 0xa0 >> 1; 304 305 /* Check if board has eeprom */ 306 err = i2c_master_recv(&dev->i2c_client, &buf, 0); 307 if (err < 0) 308 return -1; 309 310 buf = 0; 311 if (1 != (err = i2c_master_send(&dev->i2c_client, &buf, 1))) { 312 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n", 313 dev->name, err); 314 return -1; 315 } 316 while (size > 0) { 317 if (size > 16) 318 block = 16; 319 else 320 block = size; 321 322 if (block != 323 (err = i2c_master_recv(&dev->i2c_client, p, block))) { 324 printk(KERN_WARNING 325 "%s: i2c eeprom read error (err=%d)\n", 326 dev->name, err); 327 return -1; 328 } 329 size -= block; 330 p += block; 331 } 332 for (i = 0; i < len; i++) { 333 if (0 == (i % 16)) 334 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i); 335 printk(" %02x", eedata[i]); 336 if (15 == (i % 16)) 337 printk("\n"); 338 } 339 340 printk(KERN_INFO "EEPROM ID= 0x%08x\n", em_eeprom->id); 341 printk(KERN_INFO "Vendor/Product ID= %04x:%04x\n", em_eeprom->vendor_ID, 342 em_eeprom->product_ID); 343 344 switch (em_eeprom->chip_conf >> 4 & 0x3) { 345 case 0: 346 printk(KERN_INFO "No audio on board.\n"); 347 break; 348 case 1: 349 printk(KERN_INFO "AC97 audio (5 sample rates)\n"); 350 break; 351 case 2: 352 printk(KERN_INFO "I2S audio, sample rate=32k\n"); 353 break; 354 case 3: 355 printk(KERN_INFO "I2S audio, 3 sample rates\n"); 356 break; 357 } 358 359 if (em_eeprom->chip_conf & 1 << 3) 360 printk(KERN_INFO "USB Remote wakeup capable\n"); 361 362 if (em_eeprom->chip_conf & 1 << 2) 363 printk(KERN_INFO "USB Self power capable\n"); 364 365 switch (em_eeprom->chip_conf & 0x3) { 366 case 0: 367 printk(KERN_INFO "500mA max power\n"); 368 break; 369 case 1: 370 printk(KERN_INFO "400mA max power\n"); 371 break; 372 case 2: 373 printk(KERN_INFO "300mA max power\n"); 374 break; 375 case 3: 376 printk(KERN_INFO "200mA max power\n"); 377 break; 378 } 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#ifndef I2C_PEC 403static void inc_use(struct i2c_adapter *adap) 404{ 405 MOD_INC_USE_COUNT; 406} 407 408static void dec_use(struct i2c_adapter *adap) 409{ 410 MOD_DEC_USE_COUNT; 411} 412#endif 413 414static int em2820_set_tuner(int check_eeprom, struct i2c_client *client) 415{ 416 struct em2820 *dev = client->adapter->algo_data; 417 struct tuner_setup tun_setup; 418 419 if (dev->has_tuner) { 420 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 421 tun_setup.type = dev->tuner_type; 422 tun_setup.addr = dev->tuner_addr; 423 424 em2820_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup); 425 } 426 427 return (0); 428} 429 430/* 431 * attach_inform() 432 * gets called when a device attaches to the i2c bus 433 * does some basic configuration 434 */ 435static int attach_inform(struct i2c_client *client) 436{ 437 struct em2820 *dev = client->adapter->algo_data; 438 439 dprintk("address %x", client->addr << 1); 440 switch (client->addr << 1) { 441 case 0x86: 442 em2820_i2c_call_clients(dev, TDA9887_SET_CONFIG, &dev->tda9887_conf); 443 break; 444 case 0x4a: 445 dprintk1("attach_inform: saa7113 detected.\n"); 446 break; 447 case 0xa0: 448 dprintk1("attach_inform: eeprom detected.\n"); 449 break; 450 case 0x80: 451 case 0x88: 452 dprintk1("attach_inform: msp34xx detected.\n"); 453 break; 454 case 0xb8: 455 case 0xba: 456 dprintk1("attach_inform: tvp5150 detected.\n"); 457 break; 458 default: 459 dev->tuner_addr = client->addr; 460 em2820_set_tuner(-1, client); 461 } 462 463 return 0; 464} 465 466static struct i2c_algorithm em2820_algo = { 467 .master_xfer = em2820_i2c_xfer, 468 .algo_control = algo_control, 469 .functionality = functionality, 470}; 471 472static struct i2c_adapter em2820_adap_template = { 473#ifdef I2C_PEC 474 .owner = THIS_MODULE, 475#else 476 .inc_use = inc_use, 477 .dec_use = dec_use, 478#endif 479#ifdef I2C_CLASS_TV_ANALOG 480 .class = I2C_CLASS_TV_ANALOG, 481#endif 482 .name = "em2820", 483 .id = I2C_HW_B_EM2820, 484 .algo = &em2820_algo, 485 .client_register = attach_inform, 486}; 487 488static struct i2c_client em2820_client_template = { 489 .name = "em2820 internal", 490 .flags = I2C_CLIENT_ALLOW_USE, 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 < 128; 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 * em2820_i2c_call_clients() 536 * send commands to all attached i2c devices 537 */ 538void em2820_i2c_call_clients(struct em2820 *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 * em2820_i2c_register() 546 * register i2c bus 547 */ 548int em2820_i2c_register(struct em2820 *dev) 549{ 550 BUG_ON(!dev->em2820_write_regs || !dev->em2820_read_reg); 551 BUG_ON(!dev->em2820_write_regs_req || !dev->em2820_read_reg_req); 552 dev->i2c_adap = em2820_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 = em2820_client_template; 559 dev->i2c_client.adapter = &dev->i2c_adap; 560 561 em2820_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 * em2820_i2c_unregister() 570 * unregister i2c_bus 571 */ 572int em2820_i2c_unregister(struct em2820 *dev) 573{ 574 i2c_del_adapter(&dev->i2c_adap); 575 return 0; 576} 577