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>
30 #include "tuner-xc2028.h"
31 #include <media/v4l2-common.h>
32 #include <media/tuner.h>
34 /* ----------------------------------------------------------- */
36 static unsigned int i2c_scan;
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;
41 module_param(i2c_debug, int, 0644);
42 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
44 #define dprintk2(lvl, fmt, args...) \
46 if (i2c_debug >= lvl) { \
47 printk(KERN_DEBUG "%s at %s: " fmt, \
48 dev->name, __func__ , ##args); \
53 * em2800_i2c_send_max4()
54 * send up to 4 bytes to the i2c device
56 static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
62 BUG_ON(len < 1 || len > 4);
63 b2[5] = 0x80 + len - 1;
73 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
75 em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
78 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
80 ret = dev->em28xx_read_reg(dev, 0x05);
81 if (ret == 0x80 + len - 1)
85 em28xx_warn("i2c write timed out\n");
90 * em2800_i2c_send_bytes()
92 static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
100 struct em28xx *dev = (struct em28xx *)data;
102 count = (len > maxLen) ? maxLen : len;
103 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
109 return (ret < 0) ? ret : -EFAULT;
115 * em2800_i2c_check_for_device()
116 * check if there is a i2c_device at the supplied address
118 static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
124 ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
126 em28xx_warn("setting i2c device address failed (error=%i)\n",
131 ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
133 em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
136 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
137 write_timeout -= 5) {
138 unsigned reg = dev->em28xx_read_reg(dev, 0x5);
142 else if (reg == 0x84)
150 * em2800_i2c_recv_bytes()
151 * read from the i2c device
153 static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
157 /* check for the device and set i2c read address */
158 ret = em2800_i2c_check_for_device(dev, addr);
161 ("preparing read at i2c address 0x%x failed (error=%i)\n",
165 ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
167 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
175 * em28xx_i2c_send_bytes()
177 static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
181 struct em28xx *dev = (struct em28xx *)data;
182 int write_timeout, ret;
184 wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
186 /* Seems to be required after a write */
187 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
188 write_timeout -= 5) {
189 ret = dev->em28xx_read_reg(dev, 0x05);
199 * em28xx_i2c_recv_bytes()
200 * read a byte from the i2c device
202 static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
206 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
208 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
211 if (dev->em28xx_read_reg(dev, 0x5) != 0)
217 * em28xx_i2c_check_for_device()
218 * check if there is a i2c_device at the supplied address
220 static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
224 ret = dev->em28xx_read_reg_req(dev, 2, addr);
226 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
229 if (dev->em28xx_read_reg(dev, 0x5) != 0)
236 * the main i2c transfer function
238 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
239 struct i2c_msg msgs[], int num)
241 struct em28xx *dev = i2c_adap->algo_data;
242 int addr, rc, i, byte;
246 for (i = 0; i < num; i++) {
247 addr = msgs[i].addr << 1;
248 dprintk2(2, "%s %s addr=%x len=%d:",
249 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
250 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
251 if (!msgs[i].len) { /* no len: check only for device presence */
252 if (dev->board.is_em2800)
253 rc = em2800_i2c_check_for_device(dev, addr);
255 rc = em28xx_i2c_check_for_device(dev, addr);
257 dprintk2(2, " no device\n");
261 } else if (msgs[i].flags & I2C_M_RD) {
263 if (dev->board.is_em2800)
264 rc = em2800_i2c_recv_bytes(dev, addr,
268 rc = em28xx_i2c_recv_bytes(dev, addr,
271 if (i2c_debug >= 2) {
272 for (byte = 0; byte < msgs[i].len; byte++)
273 printk(" %02x", msgs[i].buf[byte]);
277 if (i2c_debug >= 2) {
278 for (byte = 0; byte < msgs[i].len; byte++)
279 printk(" %02x", msgs[i].buf[byte]);
281 if (dev->board.is_em2800)
282 rc = em2800_i2c_send_bytes(dev, addr,
286 rc = em28xx_i2c_send_bytes(dev, addr,
299 dprintk2(2, " ERROR: %i\n", rc);
303 /* based on linux/sunrpc/svcauth.h and linux/hash.h
304 * The original hash function returns a different value, if arch is x86_64
307 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
309 unsigned long hash = 0;
321 if ((len & (32 / 8 - 1)) == 0)
322 hash = ((hash^l) * 0x9e370001UL);
325 return (hash >> (32 - bits)) & 0xffffffffUL;
328 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
330 unsigned char buf, *p = eedata;
331 struct em28xx_eeprom *em_eeprom = (void *)eedata;
332 int i, err, size = len, block;
334 if (dev->chip_id == CHIP_ID_EM2874 ||
335 dev->chip_id == CHIP_ID_EM28174 ||
336 dev->chip_id == CHIP_ID_EM2884) {
337 /* Empia switched to a 16-bit addressable eeprom in newer
338 devices. While we could certainly write a routine to read
339 the eeprom, there is nothing of use in there that cannot be
340 accessed through registers, and there is the risk that we
341 could corrupt the eeprom (since a 16-bit read call is
342 interpreted as a write call by 8-bit eeproms).
347 dev->i2c_client.addr = 0xa0 >> 1;
349 /* Check if board has eeprom */
350 err = i2c_master_recv(&dev->i2c_client, &buf, 0);
352 em28xx_errdev("board has no eeprom\n");
353 memset(eedata, 0, len);
359 err = i2c_master_send(&dev->i2c_client, &buf, 1);
361 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
372 (err = i2c_master_recv(&dev->i2c_client, p, block))) {
374 "%s: i2c eeprom read error (err=%d)\n",
381 for (i = 0; i < len; i++) {
383 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
384 printk(" %02x", eedata[i]);
389 if (em_eeprom->id == 0x9567eb1a)
390 dev->hash = em28xx_hash_mem(eedata, len, 32);
392 printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
393 dev->name, em_eeprom->id, dev->hash);
395 printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
397 switch (em_eeprom->chip_conf >> 4 & 0x3) {
399 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
402 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
406 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
410 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
415 if (em_eeprom->chip_conf & 1 << 3)
416 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
418 if (em_eeprom->chip_conf & 1 << 2)
419 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
421 switch (em_eeprom->chip_conf & 0x3) {
423 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
426 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
429 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
432 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
435 printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
437 em_eeprom->string_idx_table,
445 /* ----------------------------------------------------------- */
450 static u32 functionality(struct i2c_adapter *adap)
452 return I2C_FUNC_SMBUS_EMUL;
455 static struct i2c_algorithm em28xx_algo = {
456 .master_xfer = em28xx_i2c_xfer,
457 .functionality = functionality,
460 static struct i2c_adapter em28xx_adap_template = {
461 .owner = THIS_MODULE,
463 .algo = &em28xx_algo,
466 static struct i2c_client em28xx_client_template = {
467 .name = "em28xx internal",
470 /* ----------------------------------------------------------- */
474 * incomplete list of known devices
476 static char *i2c_devs[128] = {
477 [0x4a >> 1] = "saa7113h",
478 [0x52 >> 1] = "drxk",
479 [0x60 >> 1] = "remote IR sensor",
480 [0x8e >> 1] = "remote IR sensor",
481 [0x86 >> 1] = "tda9887",
482 [0x80 >> 1] = "msp34xx",
483 [0x88 >> 1] = "msp34xx",
484 [0xa0 >> 1] = "eeprom",
485 [0xb0 >> 1] = "tda9874",
486 [0xb8 >> 1] = "tvp5150a",
487 [0xba >> 1] = "webcam sensor or tvp5150a",
488 [0xc0 >> 1] = "tuner (analog)",
489 [0xc2 >> 1] = "tuner (analog)",
490 [0xc4 >> 1] = "tuner (analog)",
491 [0xc6 >> 1] = "tuner (analog)",
496 * check i2c address range for devices
498 void em28xx_do_i2c_scan(struct em28xx *dev)
500 u8 i2c_devicelist[128];
504 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
506 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
507 dev->i2c_client.addr = i;
508 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
511 i2c_devicelist[i] = i;
512 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
513 dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
516 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
517 ARRAY_SIZE(i2c_devicelist), 32);
521 * em28xx_i2c_register()
524 int em28xx_i2c_register(struct em28xx *dev)
528 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
529 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
530 dev->i2c_adap = em28xx_adap_template;
531 dev->i2c_adap.dev.parent = &dev->udev->dev;
532 strcpy(dev->i2c_adap.name, dev->name);
533 dev->i2c_adap.algo_data = dev;
534 i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
536 retval = i2c_add_adapter(&dev->i2c_adap);
538 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
543 dev->i2c_client = em28xx_client_template;
544 dev->i2c_client.adapter = &dev->i2c_adap;
546 retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
547 if ((retval < 0) && (retval != -ENODEV)) {
548 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
555 em28xx_do_i2c_scan(dev);
561 * em28xx_i2c_unregister()
564 int em28xx_i2c_unregister(struct em28xx *dev)
566 i2c_del_adapter(&dev->i2c_adap);