2 em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
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>
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.
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.
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.
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>
31 #include <media/v4l2-common.h>
32 #include <media/tuner.h>
34 /* ----------------------------------------------------------- */
36 static unsigned int i2c_scan = 0;
37 module_param(i2c_scan, int, 0444);
38 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
40 static unsigned int i2c_debug = 0;
41 module_param(i2c_debug, int, 0644);
42 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
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)
51 * em2800_i2c_send_max4()
52 * send up to 4 bytes to the i2c device
54 static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
60 BUG_ON(len < 1 || len > 4);
61 b2[5] = 0x80 + len - 1;
71 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
73 em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
76 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
78 ret = dev->em28xx_read_reg(dev, 0x05);
79 if (ret == 0x80 + len - 1)
83 em28xx_warn("i2c write timed out\n");
88 * em2800_i2c_send_bytes()
90 static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
98 struct em28xx *dev = (struct em28xx *)data;
100 count = (len > maxLen) ? maxLen : len;
101 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
107 return (ret < 0) ? ret : -EFAULT;
113 * em2800_i2c_check_for_device()
114 * check if there is a i2c_device at the supplied address
116 static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
122 ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
124 em28xx_warn("setting i2c device address failed (error=%i)\n",
129 ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
131 em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
134 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
135 write_timeout -= 5) {
136 unsigned msg = dev->em28xx_read_reg(dev, 0x5);
139 else if (msg == 0x84)
147 * em2800_i2c_recv_bytes()
148 * read from the i2c device
150 static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
154 /* check for the device and set i2c read address */
155 ret = em2800_i2c_check_for_device(dev, addr);
158 ("preparing read at i2c address 0x%x failed (error=%i)\n",
162 ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
164 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
172 * em28xx_i2c_send_bytes()
173 * untested for more than 4 bytes
175 static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
179 struct em28xx *dev = (struct em28xx *)data;
181 wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
187 * em28xx_i2c_recv_bytes()
188 * read a byte from the i2c device
190 static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
194 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
196 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
199 if (dev->em28xx_read_reg(dev, 0x5) != 0)
205 * em28xx_i2c_check_for_device()
206 * check if there is a i2c_device at the supplied address
208 static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
214 ret = dev->em28xx_read_reg_req(dev, 2, addr);
216 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
219 if (dev->em28xx_read_reg(dev, 0x5) != 0)
226 * the main i2c transfer function
228 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
229 struct i2c_msg msgs[], int num)
231 struct em28xx *dev = i2c_adap->algo_data;
232 int addr, rc, i, byte;
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 */
243 rc = em2800_i2c_check_for_device(dev, addr);
245 rc = em28xx_i2c_check_for_device(dev, addr);
247 dprintk2(2," no device\n");
251 } else if (msgs[i].flags & I2C_M_RD) {
254 rc = em2800_i2c_recv_bytes(dev, addr,
258 rc = em28xx_i2c_recv_bytes(dev, addr,
262 for (byte = 0; byte < msgs[i].len; byte++) {
263 printk(" %02x", msgs[i].buf[byte]);
269 for (byte = 0; byte < msgs[i].len; byte++)
270 printk(" %02x", msgs[i].buf[byte]);
273 rc = em2800_i2c_send_bytes(dev, addr,
277 rc = em28xx_i2c_send_bytes(dev, addr,
290 dprintk2(2," ERROR: %i\n", rc);
294 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
296 unsigned char buf, *p = eedata;
297 struct em28xx_eeprom *em_eeprom = (void *)eedata;
298 int i, err, size = len, block;
300 dev->i2c_client.addr = 0xa0 >> 1;
302 /* Check if board has eeprom */
303 err = i2c_master_recv(&dev->i2c_client, &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",
320 (err = i2c_master_recv(&dev->i2c_client, p, block))) {
322 "%s: i2c eeprom read error (err=%d)\n",
329 for (i = 0; i < len; i++) {
331 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
332 printk(" %02x", eedata[i]);
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);
341 switch (em_eeprom->chip_conf >> 4 & 0x3) {
343 printk(KERN_INFO "No audio on board.\n");
346 printk(KERN_INFO "AC97 audio (5 sample rates)\n");
349 printk(KERN_INFO "I2S audio, sample rate=32k\n");
352 printk(KERN_INFO "I2S audio, 3 sample rates\n");
356 if (em_eeprom->chip_conf & 1 << 3)
357 printk(KERN_INFO "USB Remote wakeup capable\n");
359 if (em_eeprom->chip_conf & 1 << 2)
360 printk(KERN_INFO "USB Self power capable\n");
362 switch (em_eeprom->chip_conf & 0x3) {
364 printk(KERN_INFO "500mA max power\n");
367 printk(KERN_INFO "400mA max power\n");
370 printk(KERN_INFO "300mA max power\n");
373 printk(KERN_INFO "200mA max power\n");
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);
383 /* ----------------------------------------------------------- */
388 static u32 functionality(struct i2c_adapter *adap)
390 return I2C_FUNC_SMBUS_EMUL;
394 static int em28xx_set_tuner(int check_eeprom, struct i2c_client *client)
396 struct em28xx *dev = client->adapter->algo_data;
397 struct tuner_setup tun_setup;
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);
411 * gets called when a device attaches to the i2c bus
412 * does some basic configuration
414 static int attach_inform(struct i2c_client *client)
416 struct em28xx *dev = client->adapter->algo_data;
418 switch (client->addr << 1) {
424 struct v4l2_priv_tun_config tda9887_cfg;
426 struct tuner_setup tun_setup;
428 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
429 tun_setup.type = TUNER_TDA9887;
430 tun_setup.addr = client->addr;
432 em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
434 tda9887_cfg.tuner = TUNER_TDA9887;
435 tda9887_cfg.priv = &dev->tda9887_conf;
436 em28xx_i2c_call_clients(dev, TUNER_SET_CONFIG,
441 dprintk1(1,"attach_inform: saa7114 detected.\n");
444 dprintk1(1,"attach_inform: saa7113 detected.\n");
447 dprintk1(1,"attach_inform: eeprom detected.\n");
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);
459 dprintk1(1,"attach_inform: msp34xx detected.\n");
463 dprintk1(1,"attach_inform: tvp5150 detected.\n");
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);
475 static struct i2c_algorithm em28xx_algo = {
476 .master_xfer = em28xx_i2c_xfer,
477 .functionality = functionality,
480 static struct i2c_adapter em28xx_adap_template = {
481 .owner = THIS_MODULE,
482 .class = I2C_CLASS_TV_ANALOG,
484 .id = I2C_HW_B_EM28XX,
485 .algo = &em28xx_algo,
486 .client_register = attach_inform,
489 static struct i2c_client em28xx_client_template = {
490 .name = "em28xx internal",
493 /* ----------------------------------------------------------- */
497 * incomplete list of known devices
499 static 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)",
517 * check i2c address range for devices
519 static void do_i2c_scan(char *name, struct i2c_client *c)
524 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
526 rc = i2c_master_recv(c, &buf, 0);
529 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n", name,
530 i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
535 * em28xx_i2c_call_clients()
536 * send commands to all attached i2c devices
538 void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg)
540 BUG_ON(NULL == dev->i2c_adap.algo_data);
541 i2c_clients_command(&dev->i2c_adap, cmd, arg);
545 * em28xx_i2c_register()
548 int em28xx_i2c_register(struct em28xx *dev)
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);
558 dev->i2c_client = em28xx_client_template;
559 dev->i2c_client.adapter = &dev->i2c_adap;
561 em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
564 do_i2c_scan(dev->name, &dev->i2c_client);
569 * em28xx_i2c_unregister()
572 int em28xx_i2c_unregister(struct em28xx *dev)
574 i2c_del_adapter(&dev->i2c_adap);