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>
8 Copyright (C) 2013 Frank Schäfer <fschaefer.oss@googlemail.com>
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.
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.
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.
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/usb.h>
28 #include <linux/i2c.h>
29 #include <linux/jiffies.h>
32 #include "tuner-xc2028.h"
33 #include <media/v4l2-common.h>
34 #include <media/tuner.h>
36 /* ----------------------------------------------------------- */
38 static unsigned int i2c_scan;
39 module_param(i2c_scan, int, 0444);
40 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
42 static unsigned int i2c_debug;
43 module_param(i2c_debug, int, 0644);
44 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
47 * em2800_i2c_send_bytes()
48 * send up to 4 bytes to the em2800 i2c device
50 static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
52 unsigned long timeout = jiffies + msecs_to_jiffies(EM28XX_I2C_XFER_TIMEOUT);
56 if (len < 1 || len > 4)
59 BUG_ON(len < 1 || len > 4);
60 b2[5] = 0x80 + len - 1;
71 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
73 em28xx_warn("failed to trigger write to i2c address 0x%x (error=%i)\n",
75 return (ret < 0) ? ret : -EIO;
77 /* wait for completion */
78 while (time_is_after_jiffies(timeout)) {
79 ret = dev->em28xx_read_reg(dev, 0x05);
80 if (ret == 0x80 + len - 1)
82 if (ret == 0x94 + len - 1) {
86 em28xx_warn("failed to get i2c transfer status from bridge register (error=%i)\n",
92 em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
97 * em2800_i2c_recv_bytes()
98 * read up to 4 bytes from the em2800 i2c device
100 static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
102 unsigned long timeout = jiffies + msecs_to_jiffies(EM28XX_I2C_XFER_TIMEOUT);
107 if (len < 1 || len > 4)
111 buf2[1] = 0x84 + len - 1;
113 ret = dev->em28xx_write_regs(dev, 0x04, buf2, 2);
115 em28xx_warn("failed to trigger read from i2c address 0x%x (error=%i)\n",
117 return (ret < 0) ? ret : -EIO;
120 /* wait for completion */
121 while (time_is_after_jiffies(timeout)) {
122 ret = dev->em28xx_read_reg(dev, 0x05);
123 if (ret == 0x84 + len - 1)
125 if (ret == 0x94 + len - 1) {
129 em28xx_warn("failed to get i2c transfer status from bridge register (error=%i)\n",
135 if (ret != 0x84 + len - 1)
136 em28xx_warn("read from i2c device at 0x%x timed out\n", addr);
138 /* get the received message */
139 ret = dev->em28xx_read_reg_req_len(dev, 0x00, 4-len, buf2, len);
141 em28xx_warn("reading from i2c device at 0x%x failed: couldn't get the received message from the bridge (error=%i)\n",
143 return (ret < 0) ? ret : -EIO;
145 for (i = 0; i < len; i++)
146 buf[i] = buf2[len - 1 - i];
152 * em2800_i2c_check_for_device()
153 * check if there is an i2c device at the supplied address
155 static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr)
160 ret = em2800_i2c_recv_bytes(dev, addr, &buf, 1);
163 return (ret < 0) ? ret : -EIO;
167 * em28xx_i2c_send_bytes()
169 static int em28xx_i2c_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
172 unsigned long timeout = jiffies + msecs_to_jiffies(EM28XX_I2C_XFER_TIMEOUT);
175 if (len < 1 || len > 64)
178 * NOTE: limited by the USB ctrl message constraints
179 * Zero length reads always succeed, even if no device is connected
182 /* Write to i2c device */
183 ret = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
186 em28xx_warn("writing to i2c device at 0x%x failed (error=%i)\n",
190 em28xx_warn("%i bytes write to i2c device at 0x%x requested, but %i bytes written\n",
196 /* wait for completion */
197 while (time_is_after_jiffies(timeout)) {
198 ret = dev->em28xx_read_reg(dev, 0x05);
199 if (ret == 0) /* success */
205 em28xx_warn("failed to get i2c transfer status from bridge register (error=%i)\n",
211 * NOTE: do we really have to wait for success ?
212 * Never seen anything else than 0x00 or 0x10
213 * (even with high payload) ...
217 em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
222 * em28xx_i2c_recv_bytes()
223 * read a byte from the i2c device
225 static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len)
229 if (len < 1 || len > 64)
232 * NOTE: limited by the USB ctrl message constraints
233 * Zero length reads always succeed, even if no device is connected
236 /* Read data from i2c device */
237 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
239 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)\n",
244 * NOTE: some devices with two i2c busses have the bad habit to return 0
245 * bytes if we are on bus B AND there was no write attempt to the
246 * specified slave address before AND no device is present at the
247 * requested slave address.
248 * Anyway, the next check will fail with -ENODEV in this case, so avoid
249 * spamming the system log on device probing and do nothing here.
252 /* Check success of the i2c operation */
253 ret = dev->em28xx_read_reg(dev, 0x05);
254 if (ret == 0) /* success */
257 em28xx_warn("failed to get i2c transfer status from bridge register (error=%i)\n",
264 em28xx_warn("unknown i2c error (status=%i)\n", ret);
269 * em28xx_i2c_check_for_device()
270 * check if there is a i2c_device at the supplied address
272 static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
277 ret = em28xx_i2c_recv_bytes(dev, addr, &buf, 1);
280 return (ret < 0) ? ret : -EIO;
284 * em25xx_bus_B_send_bytes
285 * write bytes to the i2c device
287 static int em25xx_bus_B_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
292 if (len < 1 || len > 64)
295 * NOTE: limited by the USB ctrl message constraints
296 * Zero length reads always succeed, even if no device is connected
299 /* Set register and write value */
300 ret = dev->em28xx_write_regs_req(dev, 0x06, addr, buf, len);
303 em28xx_warn("writing to i2c device at 0x%x failed (error=%i)\n",
307 em28xx_warn("%i bytes write to i2c device at 0x%x requested, but %i bytes written\n",
313 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
315 * NOTE: the only error we've seen so far is
316 * 0x01 when the slave device is not present
325 * NOTE: With chip types (other chip IDs) which actually don't support
326 * this operation, it seems to succeed ALWAYS ! (even if there is no
327 * slave device or even no second i2c bus provided)
332 * em25xx_bus_B_recv_bytes
333 * read bytes from the i2c device
335 static int em25xx_bus_B_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf,
340 if (len < 1 || len > 64)
343 * NOTE: limited by the USB ctrl message constraints
344 * Zero length reads always succeed, even if no device is connected
348 ret = dev->em28xx_read_reg_req_len(dev, 0x06, addr, buf, len);
350 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)\n",
355 * NOTE: some devices with two i2c busses have the bad habit to return 0
356 * bytes if we are on bus B AND there was no write attempt to the
357 * specified slave address before AND no device is present at the
358 * requested slave address.
359 * Anyway, the next check will fail with -ENODEV in this case, so avoid
360 * spamming the system log on device probing and do nothing here.
364 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
366 * NOTE: the only error we've seen so far is
367 * 0x01 when the slave device is not present
376 * NOTE: With chip types (other chip IDs) which actually don't support
377 * this operation, it seems to succeed ALWAYS ! (even if there is no
378 * slave device or even no second i2c bus provided)
383 * em25xx_bus_B_check_for_device()
384 * check if there is a i2c device at the supplied address
386 static int em25xx_bus_B_check_for_device(struct em28xx *dev, u16 addr)
391 ret = em25xx_bus_B_recv_bytes(dev, addr, &buf, 1);
397 * NOTE: With chips which do not support this operation,
398 * it seems to succeed ALWAYS ! (even if no device connected)
402 static inline int i2c_check_for_device(struct em28xx_i2c_bus *i2c_bus, u16 addr)
404 struct em28xx *dev = i2c_bus->dev;
405 int rc = -EOPNOTSUPP;
407 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
408 rc = em28xx_i2c_check_for_device(dev, addr);
409 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
410 rc = em2800_i2c_check_for_device(dev, addr);
411 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
412 rc = em25xx_bus_B_check_for_device(dev, addr);
415 printk(" no device\n");
420 static inline int i2c_recv_bytes(struct em28xx_i2c_bus *i2c_bus,
423 struct em28xx *dev = i2c_bus->dev;
424 u16 addr = msg.addr << 1;
425 int byte, rc = -EOPNOTSUPP;
427 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
428 rc = em28xx_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
429 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
430 rc = em2800_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
431 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
432 rc = em25xx_bus_B_recv_bytes(dev, addr, msg.buf, msg.len);
434 for (byte = 0; byte < msg.len; byte++)
435 printk(" %02x", msg.buf[byte]);
440 static inline int i2c_send_bytes(struct em28xx_i2c_bus *i2c_bus,
441 struct i2c_msg msg, int stop)
443 struct em28xx *dev = i2c_bus->dev;
444 u16 addr = msg.addr << 1;
445 int byte, rc = -EOPNOTSUPP;
448 for (byte = 0; byte < msg.len; byte++)
449 printk(" %02x", msg.buf[byte]);
451 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
452 rc = em28xx_i2c_send_bytes(dev, addr, msg.buf, msg.len, stop);
453 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
454 rc = em2800_i2c_send_bytes(dev, addr, msg.buf, msg.len);
455 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
456 rc = em25xx_bus_B_send_bytes(dev, addr, msg.buf, msg.len);
462 * the main i2c transfer function
464 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
465 struct i2c_msg msgs[], int num)
467 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
468 struct em28xx *dev = i2c_bus->dev;
469 unsigned bus = i2c_bus->bus;
473 rc = rt_mutex_trylock(&dev->i2c_bus_lock);
477 /* Switch I2C bus if needed */
478 if (bus != dev->cur_i2c_bus &&
479 i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) {
481 reg = EM2874_I2C_SECONDARY_BUS_SELECT;
484 em28xx_write_reg_bits(dev, EM28XX_R06_I2C_CLK, reg,
485 EM2874_I2C_SECONDARY_BUS_SELECT);
486 dev->cur_i2c_bus = bus;
490 rt_mutex_unlock(&dev->i2c_bus_lock);
493 for (i = 0; i < num; i++) {
494 addr = msgs[i].addr << 1;
496 printk(KERN_DEBUG "%s at %s: %s %s addr=%02x len=%d:",
497 dev->name, __func__ ,
498 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
499 i == num - 1 ? "stop" : "nonstop",
501 if (!msgs[i].len) { /* no len: check only for device presence */
502 rc = i2c_check_for_device(i2c_bus, addr);
504 rt_mutex_unlock(&dev->i2c_bus_lock);
507 } else if (msgs[i].flags & I2C_M_RD) {
509 rc = i2c_recv_bytes(i2c_bus, msgs[i]);
512 rc = i2c_send_bytes(i2c_bus, msgs[i], i == num - 1);
516 printk(" ERROR: %i\n", rc);
517 rt_mutex_unlock(&dev->i2c_bus_lock);
524 rt_mutex_unlock(&dev->i2c_bus_lock);
529 * based on linux/sunrpc/svcauth.h and linux/hash.h
530 * The original hash function returns a different value, if arch is x86_64
533 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
535 unsigned long hash = 0;
547 if ((len & (32 / 8 - 1)) == 0)
548 hash = ((hash^l) * 0x9e370001UL);
551 return (hash >> (32 - bits)) & 0xffffffffUL;
555 * Helper function to read data blocks from i2c clients with 8 or 16 bit
556 * address width, 8 bit register width and auto incrementation been activated
558 static int em28xx_i2c_read_block(struct em28xx *dev, unsigned bus, u16 addr,
559 bool addr_w16, u16 len, u8 *data)
561 int remain = len, rsize, rsize_max, ret;
565 if (addr + remain > (addr_w16 * 0xff00 + 0xff + 1))
569 buf[1] = addr & 0xff;
570 ret = i2c_master_send(&dev->i2c_client[bus], buf + !addr_w16, 1 + addr_w16);
574 if (dev->board.is_em2800)
579 if (remain > rsize_max)
584 ret = i2c_master_recv(&dev->i2c_client[bus], data, rsize);
595 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned bus,
596 u8 **eedata, u16 *eedata_len)
600 * FIXME common length/size for bytes to read, to display, hash
601 * calculation and returned device dataset. Simplifies the code a lot,
602 * but we might have to deal with multiple sizes in the future !
605 struct em28xx_eeprom *dev_config;
611 /* EEPROM is always on i2c bus 0 on all known devices. */
613 dev->i2c_client[bus].addr = 0xa0 >> 1;
615 /* Check if board has eeprom */
616 err = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
618 em28xx_info("board has no eeprom\n");
622 data = kzalloc(len, GFP_KERNEL);
626 /* Read EEPROM content */
627 err = em28xx_i2c_read_block(dev, bus, 0x0000,
628 dev->eeprom_addrwidth_16bit,
631 em28xx_errdev("failed to read eeprom (err=%d)\n", err);
635 /* Display eeprom content */
636 for (i = 0; i < len; i++) {
638 if (dev->eeprom_addrwidth_16bit)
639 em28xx_info("i2c eeprom %04x:", i);
641 em28xx_info("i2c eeprom %02x:", i);
643 printk(" %02x", data[i]);
647 if (dev->eeprom_addrwidth_16bit)
648 em28xx_info("i2c eeprom %04x: ... (skipped)\n", i);
650 if (dev->eeprom_addrwidth_16bit &&
651 data[0] == 0x26 && data[3] == 0x00) {
652 /* new eeprom format; size 4-64kb */
656 dev->hash = em28xx_hash_mem(data, len, 32);
657 mc_start = (data[1] << 8) + 4; /* usually 0x0004 */
659 em28xx_info("EEPROM ID = %02x %02x %02x %02x, EEPROM hash = 0x%08lx\n",
660 data[0], data[1], data[2], data[3], dev->hash);
661 em28xx_info("EEPROM info:\n");
662 em28xx_info("\tmicrocode start address = 0x%04x, boot configuration = 0x%02x\n",
665 * boot configuration (address 0x0002):
666 * [0] microcode download speed: 1 = 400 kHz; 0 = 100 kHz
667 * [1] always selects 12 kb RAM
668 * [2] USB device speed: 1 = force Full Speed; 0 = auto detect
669 * [4] 1 = force fast mode and no suspend for device testing
670 * [5:7] USB PHY tuning registers; determined by device
675 * Read hardware config dataset offset from address
676 * (microcode start + 46)
678 err = em28xx_i2c_read_block(dev, bus, mc_start + 46, 1, 2,
681 em28xx_errdev("failed to read hardware configuration data from eeprom (err=%d)\n",
686 /* Calculate hardware config dataset start address */
687 hwconf_offset = mc_start + data[0] + (data[1] << 8);
689 /* Read hardware config dataset */
691 * NOTE: the microcode copy can be multiple pages long, but
692 * we assume the hardware config dataset is the same as in
693 * the old eeprom and not longer than 256 bytes.
694 * tveeprom is currently also limited to 256 bytes.
696 err = em28xx_i2c_read_block(dev, bus, hwconf_offset, 1, len,
699 em28xx_errdev("failed to read hardware configuration data from eeprom (err=%d)\n",
704 /* Verify hardware config dataset */
705 /* NOTE: not all devices provide this type of dataset */
706 if (data[0] != 0x1a || data[1] != 0xeb ||
707 data[2] != 0x67 || data[3] != 0x95) {
708 em28xx_info("\tno hardware configuration dataset found in eeprom\n");
713 /* TODO: decrypt eeprom data for camera bridges (em25xx, em276x+) */
715 } else if (!dev->eeprom_addrwidth_16bit &&
716 data[0] == 0x1a && data[1] == 0xeb &&
717 data[2] == 0x67 && data[3] == 0x95) {
718 dev->hash = em28xx_hash_mem(data, len, 32);
719 em28xx_info("EEPROM ID = %02x %02x %02x %02x, EEPROM hash = 0x%08lx\n",
720 data[0], data[1], data[2], data[3], dev->hash);
721 em28xx_info("EEPROM info:\n");
723 em28xx_info("unknown eeprom format or eeprom corrupted !\n");
730 dev_config = (void *)*eedata;
732 switch (le16_to_cpu(dev_config->chip_conf) >> 4 & 0x3) {
734 em28xx_info("\tNo audio on board.\n");
737 em28xx_info("\tAC97 audio (5 sample rates)\n");
740 if (dev->chip_id < CHIP_ID_EM2860)
741 em28xx_info("\tI2S audio, sample rate=32k\n");
743 em28xx_info("\tI2S audio, 3 sample rates\n");
746 if (dev->chip_id < CHIP_ID_EM2860)
747 em28xx_info("\tI2S audio, 3 sample rates\n");
749 em28xx_info("\tI2S audio, 5 sample rates\n");
753 if (le16_to_cpu(dev_config->chip_conf) & 1 << 3)
754 em28xx_info("\tUSB Remote wakeup capable\n");
756 if (le16_to_cpu(dev_config->chip_conf) & 1 << 2)
757 em28xx_info("\tUSB Self power capable\n");
759 switch (le16_to_cpu(dev_config->chip_conf) & 0x3) {
761 em28xx_info("\t500mA max power\n");
764 em28xx_info("\t400mA max power\n");
767 em28xx_info("\t300mA max power\n");
770 em28xx_info("\t200mA max power\n");
773 em28xx_info("\tTable at offset 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
774 dev_config->string_idx_table,
775 le16_to_cpu(dev_config->string1),
776 le16_to_cpu(dev_config->string2),
777 le16_to_cpu(dev_config->string3));
786 /* ----------------------------------------------------------- */
791 static u32 functionality(struct i2c_adapter *i2c_adap)
793 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
795 if ((i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) ||
796 (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)) {
797 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
798 } else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800) {
799 return (I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL) &
800 ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA;
803 WARN(1, "Unknown i2c bus algorithm.\n");
807 static struct i2c_algorithm em28xx_algo = {
808 .master_xfer = em28xx_i2c_xfer,
809 .functionality = functionality,
812 static struct i2c_adapter em28xx_adap_template = {
813 .owner = THIS_MODULE,
815 .algo = &em28xx_algo,
818 static struct i2c_client em28xx_client_template = {
819 .name = "em28xx internal",
822 /* ----------------------------------------------------------- */
826 * incomplete list of known devices
828 static char *i2c_devs[128] = {
829 [0x3e >> 1] = "remote IR sensor",
830 [0x4a >> 1] = "saa7113h",
831 [0x52 >> 1] = "drxk",
832 [0x60 >> 1] = "remote IR sensor",
833 [0x8e >> 1] = "remote IR sensor",
834 [0x86 >> 1] = "tda9887",
835 [0x80 >> 1] = "msp34xx",
836 [0x88 >> 1] = "msp34xx",
837 [0xa0 >> 1] = "eeprom",
838 [0xb0 >> 1] = "tda9874",
839 [0xb8 >> 1] = "tvp5150a",
840 [0xba >> 1] = "webcam sensor or tvp5150a",
841 [0xc0 >> 1] = "tuner (analog)",
842 [0xc2 >> 1] = "tuner (analog)",
843 [0xc4 >> 1] = "tuner (analog)",
844 [0xc6 >> 1] = "tuner (analog)",
849 * check i2c address range for devices
851 void em28xx_do_i2c_scan(struct em28xx *dev, unsigned bus)
853 u8 i2c_devicelist[128];
857 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
859 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
860 dev->i2c_client[bus].addr = i;
861 rc = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
864 i2c_devicelist[i] = i;
865 em28xx_info("found i2c device @ 0x%x on bus %d [%s]\n",
866 i << 1, bus, i2c_devs[i] ? i2c_devs[i] : "???");
869 if (bus == dev->def_i2c_bus)
870 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
871 ARRAY_SIZE(i2c_devicelist), 32);
875 * em28xx_i2c_register()
878 int em28xx_i2c_register(struct em28xx *dev, unsigned bus,
879 enum em28xx_i2c_algo_type algo_type)
883 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
884 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
886 if (bus >= NUM_I2C_BUSES)
889 dev->i2c_adap[bus] = em28xx_adap_template;
890 dev->i2c_adap[bus].dev.parent = &dev->udev->dev;
891 strcpy(dev->i2c_adap[bus].name, dev->name);
893 dev->i2c_bus[bus].bus = bus;
894 dev->i2c_bus[bus].algo_type = algo_type;
895 dev->i2c_bus[bus].dev = dev;
896 dev->i2c_adap[bus].algo_data = &dev->i2c_bus[bus];
897 i2c_set_adapdata(&dev->i2c_adap[bus], &dev->v4l2_dev);
899 retval = i2c_add_adapter(&dev->i2c_adap[bus]);
901 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
906 dev->i2c_client[bus] = em28xx_client_template;
907 dev->i2c_client[bus].adapter = &dev->i2c_adap[bus];
909 /* Up to now, all eeproms are at bus 0 */
911 retval = em28xx_i2c_eeprom(dev, bus, &dev->eedata, &dev->eedata_len);
912 if ((retval < 0) && (retval != -ENODEV)) {
913 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
921 em28xx_do_i2c_scan(dev, bus);
927 * em28xx_i2c_unregister()
930 int em28xx_i2c_unregister(struct em28xx *dev, unsigned bus)
932 if (bus >= NUM_I2C_BUSES)
935 i2c_del_adapter(&dev->i2c_adap[bus]);