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