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]");
45 * em2800_i2c_send_bytes()
46 * send up to 4 bytes to the em2800 i2c device
48 static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
54 if (len < 1 || len > 4)
57 BUG_ON(len < 1 || len > 4);
58 b2[5] = 0x80 + len - 1;
69 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
71 em28xx_warn("failed to trigger write to i2c address 0x%x "
72 "(error=%i)\n", addr, ret);
73 return (ret < 0) ? ret : -EIO;
75 /* wait for completion */
76 for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
78 ret = dev->em28xx_read_reg(dev, 0x05);
79 if (ret == 0x80 + len - 1) {
81 } else if (ret == 0x94 + len - 1) {
84 em28xx_warn("failed to get i2c transfer status from "
85 "bridge register (error=%i)\n", ret);
90 em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
95 * em2800_i2c_recv_bytes()
96 * read up to 4 bytes from the em2800 i2c device
98 static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
105 if (len < 1 || len > 4)
109 buf2[1] = 0x84 + len - 1;
111 ret = dev->em28xx_write_regs(dev, 0x04, buf2, 2);
113 em28xx_warn("failed to trigger read from i2c address 0x%x "
114 "(error=%i)\n", addr, ret);
115 return (ret < 0) ? ret : -EIO;
118 /* wait for completion */
119 for (read_timeout = EM2800_I2C_XFER_TIMEOUT; read_timeout > 0;
121 ret = dev->em28xx_read_reg(dev, 0x05);
122 if (ret == 0x84 + len - 1) {
124 } else if (ret == 0x94 + len - 1) {
126 } else if (ret < 0) {
127 em28xx_warn("failed to get i2c transfer status from "
128 "bridge register (error=%i)\n", ret);
133 if (ret != 0x84 + len - 1)
134 em28xx_warn("read from i2c device at 0x%x timed out\n", addr);
136 /* get the received message */
137 ret = dev->em28xx_read_reg_req_len(dev, 0x00, 4-len, buf2, len);
139 em28xx_warn("reading from i2c device at 0x%x failed: "
140 "couldn't get the received message from the bridge "
141 "(error=%i)\n", addr, ret);
142 return (ret < 0) ? ret : -EIO;
144 for (i = 0; i < len; i++)
145 buf[i] = buf2[len - 1 - i];
151 * em2800_i2c_check_for_device()
152 * check if there is an i2c device at the supplied address
154 static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr)
159 ret = em2800_i2c_recv_bytes(dev, addr, &buf, 1);
162 return (ret < 0) ? ret : -EIO;
166 * em28xx_i2c_send_bytes()
168 static int em28xx_i2c_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
171 int write_timeout, ret;
173 if (len < 1 || len > 64)
175 /* NOTE: limited by the USB ctrl message constraints
176 * Zero length reads always succeed, even if no device is connected */
178 /* Write to i2c device */
179 ret = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
182 em28xx_warn("writing to i2c device at 0x%x failed "
183 "(error=%i)\n", addr, ret);
186 em28xx_warn("%i bytes write to i2c device at 0x%x "
187 "requested, but %i bytes written\n",
193 /* Check success of the i2c operation */
194 for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
195 write_timeout -= 5) {
196 ret = dev->em28xx_read_reg(dev, 0x05);
197 if (ret == 0) { /* success */
199 } else if (ret == 0x10) {
201 } else if (ret < 0) {
202 em28xx_warn("failed to read i2c transfer status from "
203 "bridge (error=%i)\n", ret);
207 /* NOTE: do we really have to wait for success ?
208 Never seen anything else than 0x00 or 0x10
209 (even with high payload) ... */
211 em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
216 * em28xx_i2c_recv_bytes()
217 * read a byte from the i2c device
219 static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len)
223 if (len < 1 || len > 64)
225 /* NOTE: limited by the USB ctrl message constraints
226 * Zero length reads always succeed, even if no device is connected */
228 /* Read data from i2c device */
229 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
231 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)\n",
235 /* NOTE: some devices with two i2c busses have the bad habit to return 0
236 * bytes if we are on bus B AND there was no write attempt to the
237 * specified slave address before AND no device is present at the
238 * requested slave address.
239 * Anyway, the next check will fail with -ENODEV in this case, so avoid
240 * spamming the system log on device probing and do nothing here.
243 /* Check success of the i2c operation */
244 ret = dev->em28xx_read_reg(dev, 0x05);
246 em28xx_warn("failed to read i2c transfer status from "
247 "bridge (error=%i)\n", ret);
254 em28xx_warn("unknown i2c error (status=%i)\n", ret);
262 * em28xx_i2c_check_for_device()
263 * check if there is a i2c_device at the supplied address
265 static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
270 ret = em28xx_i2c_recv_bytes(dev, addr, &buf, 1);
273 return (ret < 0) ? ret : -EIO;
278 * the main i2c transfer function
280 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
281 struct i2c_msg msgs[], int num)
283 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
284 struct em28xx *dev = i2c_bus->dev;
285 unsigned bus = i2c_bus->bus;
286 int addr, rc, i, byte;
288 rc = rt_mutex_trylock(&dev->i2c_bus_lock);
292 /* Switch I2C bus if needed */
293 if (bus != dev->cur_i2c_bus) {
295 dev->cur_i2c_bus |= EM2874_I2C_SECONDARY_BUS_SELECT;
297 dev->cur_i2c_bus &= ~EM2874_I2C_SECONDARY_BUS_SELECT;
298 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->cur_i2c_bus);
299 dev->cur_i2c_bus = bus;
303 rt_mutex_unlock(&dev->i2c_bus_lock);
306 for (i = 0; i < num; i++) {
307 addr = msgs[i].addr << 1;
309 printk(KERN_DEBUG "%s at %s: %s %s addr=%02x len=%d:",
310 dev->name, __func__ ,
311 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
312 i == num - 1 ? "stop" : "nonstop",
314 if (!msgs[i].len) { /* no len: check only for device presence */
315 if (dev->board.is_em2800)
316 rc = em2800_i2c_check_for_device(dev, addr);
318 rc = em28xx_i2c_check_for_device(dev, addr);
321 printk(" no device\n");
322 rt_mutex_unlock(&dev->i2c_bus_lock);
325 } else if (msgs[i].flags & I2C_M_RD) {
327 if (dev->board.is_em2800)
328 rc = em2800_i2c_recv_bytes(dev, addr,
332 rc = em28xx_i2c_recv_bytes(dev, addr,
336 for (byte = 0; byte < msgs[i].len; byte++)
337 printk(" %02x", msgs[i].buf[byte]);
342 for (byte = 0; byte < msgs[i].len; byte++)
343 printk(" %02x", msgs[i].buf[byte]);
345 if (dev->board.is_em2800)
346 rc = em2800_i2c_send_bytes(dev, addr,
350 rc = em28xx_i2c_send_bytes(dev, addr,
357 printk(" ERROR: %i\n", rc);
358 rt_mutex_unlock(&dev->i2c_bus_lock);
365 rt_mutex_unlock(&dev->i2c_bus_lock);
369 /* based on linux/sunrpc/svcauth.h and linux/hash.h
370 * The original hash function returns a different value, if arch is x86_64
373 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
375 unsigned long hash = 0;
387 if ((len & (32 / 8 - 1)) == 0)
388 hash = ((hash^l) * 0x9e370001UL);
391 return (hash >> (32 - bits)) & 0xffffffffUL;
394 /* Helper function to read data blocks from i2c clients with 8 or 16 bit
395 * address width, 8 bit register width and auto incrementation been activated */
396 static int em28xx_i2c_read_block(struct em28xx *dev, unsigned bus, u16 addr,
397 bool addr_w16, u16 len, u8 *data)
399 int remain = len, rsize, rsize_max, ret;
403 if (addr + remain > (addr_w16 * 0xff00 + 0xff + 1))
407 buf[1] = addr & 0xff;
408 ret = i2c_master_send(&dev->i2c_client[bus], buf + !addr_w16, 1 + addr_w16);
412 if (dev->board.is_em2800)
417 if (remain > rsize_max)
422 ret = i2c_master_recv(&dev->i2c_client[bus], data, rsize);
433 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned bus,
434 u8 **eedata, u16 *eedata_len)
437 /* FIXME common length/size for bytes to read, to display, hash
438 * calculation and returned device dataset. Simplifies the code a lot,
439 * but we might have to deal with multiple sizes in the future ! */
441 struct em28xx_eeprom *dev_config;
447 /* EEPROM is always on i2c bus 0 on all known devices. */
449 dev->i2c_client[bus].addr = 0xa0 >> 1;
451 /* Check if board has eeprom */
452 err = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
454 em28xx_info("board has no eeprom\n");
458 data = kzalloc(len, GFP_KERNEL);
462 /* Read EEPROM content */
463 err = em28xx_i2c_read_block(dev, bus, 0x0000,
464 dev->eeprom_addrwidth_16bit,
467 em28xx_errdev("failed to read eeprom (err=%d)\n", err);
471 /* Display eeprom content */
472 for (i = 0; i < len; i++) {
474 if (dev->eeprom_addrwidth_16bit)
475 em28xx_info("i2c eeprom %04x:", i);
477 em28xx_info("i2c eeprom %02x:", i);
479 printk(" %02x", data[i]);
483 if (dev->eeprom_addrwidth_16bit)
484 em28xx_info("i2c eeprom %04x: ... (skipped)\n", i);
486 if (dev->eeprom_addrwidth_16bit &&
487 data[0] == 0x26 && data[3] == 0x00) {
488 /* new eeprom format; size 4-64kb */
492 dev->hash = em28xx_hash_mem(data, len, 32);
493 mc_start = (data[1] << 8) + 4; /* usually 0x0004 */
495 em28xx_info("EEPROM ID = %02x %02x %02x %02x, "
496 "EEPROM hash = 0x%08lx\n",
497 data[0], data[1], data[2], data[3], dev->hash);
498 em28xx_info("EEPROM info:\n");
499 em28xx_info("\tmicrocode start address = 0x%04x, "
500 "boot configuration = 0x%02x\n",
502 /* boot configuration (address 0x0002):
503 * [0] microcode download speed: 1 = 400 kHz; 0 = 100 kHz
504 * [1] always selects 12 kb RAM
505 * [2] USB device speed: 1 = force Full Speed; 0 = auto detect
506 * [4] 1 = force fast mode and no suspend for device testing
507 * [5:7] USB PHY tuning registers; determined by device
511 /* Read hardware config dataset offset from address
512 * (microcode start + 46) */
513 err = em28xx_i2c_read_block(dev, bus, mc_start + 46, 1, 2,
516 em28xx_errdev("failed to read hardware configuration data from eeprom (err=%d)\n",
521 /* Calculate hardware config dataset start address */
522 hwconf_offset = mc_start + data[0] + (data[1] << 8);
524 /* Read hardware config dataset */
525 /* NOTE: the microcode copy can be multiple pages long, but
526 * we assume the hardware config dataset is the same as in
527 * the old eeprom and not longer than 256 bytes.
528 * tveeprom is currently also limited to 256 bytes.
530 err = em28xx_i2c_read_block(dev, bus, hwconf_offset, 1, len,
533 em28xx_errdev("failed to read hardware configuration data from eeprom (err=%d)\n",
538 /* Verify hardware config dataset */
539 /* NOTE: not all devices provide this type of dataset */
540 if (data[0] != 0x1a || data[1] != 0xeb ||
541 data[2] != 0x67 || data[3] != 0x95) {
542 em28xx_info("\tno hardware configuration dataset found in eeprom\n");
547 /* TODO: decrypt eeprom data for camera bridges (em25xx, em276x+) */
549 } else if (!dev->eeprom_addrwidth_16bit &&
550 data[0] == 0x1a && data[1] == 0xeb &&
551 data[2] == 0x67 && data[3] == 0x95) {
552 dev->hash = em28xx_hash_mem(data, len, 32);
553 em28xx_info("EEPROM ID = %02x %02x %02x %02x, "
554 "EEPROM hash = 0x%08lx\n",
555 data[0], data[1], data[2], data[3], dev->hash);
556 em28xx_info("EEPROM info:\n");
558 em28xx_info("unknown eeprom format or eeprom corrupted !\n");
565 dev_config = (void *)eedata;
567 switch (le16_to_cpu(dev_config->chip_conf) >> 4 & 0x3) {
569 em28xx_info("\tNo audio on board.\n");
572 em28xx_info("\tAC97 audio (5 sample rates)\n");
575 em28xx_info("\tI2S audio, sample rate=32k\n");
578 em28xx_info("\tI2S audio, 3 sample rates\n");
582 if (le16_to_cpu(dev_config->chip_conf) & 1 << 3)
583 em28xx_info("\tUSB Remote wakeup capable\n");
585 if (le16_to_cpu(dev_config->chip_conf) & 1 << 2)
586 em28xx_info("\tUSB Self power capable\n");
588 switch (le16_to_cpu(dev_config->chip_conf) & 0x3) {
590 em28xx_info("\t500mA max power\n");
593 em28xx_info("\t400mA max power\n");
596 em28xx_info("\t300mA max power\n");
599 em28xx_info("\t200mA max power\n");
602 em28xx_info("\tTable at offset 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
603 dev_config->string_idx_table,
604 le16_to_cpu(dev_config->string1),
605 le16_to_cpu(dev_config->string2),
606 le16_to_cpu(dev_config->string3));
615 /* ----------------------------------------------------------- */
620 static u32 functionality(struct i2c_adapter *i2c_adap)
622 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
623 struct em28xx *dev = i2c_bus->dev;
625 u32 func_flags = I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
626 if (dev->board.is_em2800)
627 func_flags &= ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA;
631 static struct i2c_algorithm em28xx_algo = {
632 .master_xfer = em28xx_i2c_xfer,
633 .functionality = functionality,
636 static struct i2c_adapter em28xx_adap_template = {
637 .owner = THIS_MODULE,
639 .algo = &em28xx_algo,
642 static struct i2c_client em28xx_client_template = {
643 .name = "em28xx internal",
646 /* ----------------------------------------------------------- */
650 * incomplete list of known devices
652 static char *i2c_devs[128] = {
653 [0x3e >> 1] = "remote IR sensor",
654 [0x4a >> 1] = "saa7113h",
655 [0x52 >> 1] = "drxk",
656 [0x60 >> 1] = "remote IR sensor",
657 [0x8e >> 1] = "remote IR sensor",
658 [0x86 >> 1] = "tda9887",
659 [0x80 >> 1] = "msp34xx",
660 [0x88 >> 1] = "msp34xx",
661 [0xa0 >> 1] = "eeprom",
662 [0xb0 >> 1] = "tda9874",
663 [0xb8 >> 1] = "tvp5150a",
664 [0xba >> 1] = "webcam sensor or tvp5150a",
665 [0xc0 >> 1] = "tuner (analog)",
666 [0xc2 >> 1] = "tuner (analog)",
667 [0xc4 >> 1] = "tuner (analog)",
668 [0xc6 >> 1] = "tuner (analog)",
673 * check i2c address range for devices
675 void em28xx_do_i2c_scan(struct em28xx *dev, unsigned bus)
677 u8 i2c_devicelist[128];
681 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
683 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
684 dev->i2c_client[bus].addr = i;
685 rc = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
688 i2c_devicelist[i] = i;
689 em28xx_info("found i2c device @ 0x%x on bus %d [%s]\n",
690 i << 1, bus, i2c_devs[i] ? i2c_devs[i] : "???");
693 if (bus == dev->def_i2c_bus)
694 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
695 ARRAY_SIZE(i2c_devicelist), 32);
699 * em28xx_i2c_register()
702 int em28xx_i2c_register(struct em28xx *dev, unsigned bus)
706 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
707 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
709 if (bus >= NUM_I2C_BUSES)
712 dev->i2c_adap[bus] = em28xx_adap_template;
713 dev->i2c_adap[bus].dev.parent = &dev->udev->dev;
714 strcpy(dev->i2c_adap[bus].name, dev->name);
716 dev->i2c_bus[bus].bus = bus;
717 dev->i2c_bus[bus].dev = dev;
718 dev->i2c_adap[bus].algo_data = &dev->i2c_bus[bus];
719 i2c_set_adapdata(&dev->i2c_adap[bus], &dev->v4l2_dev);
721 retval = i2c_add_adapter(&dev->i2c_adap[bus]);
723 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
728 dev->i2c_client[bus] = em28xx_client_template;
729 dev->i2c_client[bus].adapter = &dev->i2c_adap[bus];
731 /* Up to now, all eeproms are at bus 0 */
733 retval = em28xx_i2c_eeprom(dev, bus, &dev->eedata, &dev->eedata_len);
734 if ((retval < 0) && (retval != -ENODEV)) {
735 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
743 em28xx_do_i2c_scan(dev, bus);
749 * em28xx_i2c_unregister()
752 int em28xx_i2c_unregister(struct em28xx *dev, unsigned bus)
754 if (bus >= NUM_I2C_BUSES)
757 i2c_del_adapter(&dev->i2c_adap[bus]);