V4L/DVB (7469): Preparation for supporting new devices, cleanup and saneness
authorPatrick Boettcher <pb@linuxtv.org>
Sat, 29 Mar 2008 23:49:57 +0000 (20:49 -0300)
committerMauro Carvalho Chehab <mchehab@infradead.org>
Thu, 24 Apr 2008 17:07:56 +0000 (14:07 -0300)
To prepare the support for new device to the flexcop-family some preparation and cleanups was done + some saneness:

- created an i2c-adapter for each i2c-port available. Easier usage for devices with several device on different i2c-busses
- initialize i2c before doing the eeprom read
- changed the way to attach the different frontends, easier to read now
- enabled support for i2c-devices having no register address (1-byte access)

Signed-off-by: Patrick Boettcher <pb@linuxtv.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
drivers/media/dvb/b2c2/flexcop-common.h
drivers/media/dvb/b2c2/flexcop-eeprom.c
drivers/media/dvb/b2c2/flexcop-fe-tuner.c
drivers/media/dvb/b2c2/flexcop-i2c.c
drivers/media/dvb/b2c2/flexcop-usb.c
drivers/media/dvb/b2c2/flexcop.c

index 5a6c4fe249e7b5bd190c1a062e4f28320c022534..8ce06336e76f88372b83bc0297915b5c048238ca 100644 (file)
@@ -44,6 +44,14 @@ struct flexcop_dma {
        u32 size; /* size of each address in bytes */
 };
 
+struct flexcop_i2c_adapter {
+       struct flexcop_device *fc;
+       struct i2c_adapter i2c_adap;
+
+       u8 no_base_addr;
+       flexcop_i2c_port_t port;
+};
+
 /* Control structure for data definitions that are common to
  * the B2C2-based PCI and USB devices.
  */
@@ -72,7 +80,7 @@ struct flexcop_device {
        struct dmx_frontend mem_frontend;
        int (*fe_sleep) (struct dvb_frontend *);
 
-       struct i2c_adapter i2c_adap;
+       struct flexcop_i2c_adapter fc_i2c_adap[3];
        struct mutex i2c_mutex;
        struct module *owner;
 
@@ -87,7 +95,8 @@ struct flexcop_device {
        int               (*write_ibi_reg) (struct flexcop_device *, flexcop_ibi_register, flexcop_ibi_value);
 
 
-       int (*i2c_request) (struct flexcop_device*, flexcop_access_op_t, flexcop_i2c_port_t, u8 chipaddr, u8 addr, u8 *buf, u16 len);
+       int (*i2c_request) (struct flexcop_i2c_adapter*,
+               flexcop_access_op_t, u8 chipaddr, u8 addr, u8 *buf, u16 len);
        int (*stream_control) (struct flexcop_device*, int);
 
        int (*get_mac_addr) (struct flexcop_device *fc, int extended);
@@ -128,8 +137,8 @@ int flexcop_eeprom_check_mac_addr(struct flexcop_device *fc, int extended);
  * one. We have it in flexcop-i2c.c, because it is going via the actual
  * I2C-channel of the flexcop.
  */
-int flexcop_i2c_request(struct flexcop_device*, flexcop_access_op_t,
-                       flexcop_i2c_port_t, u8 chipaddr, u8 addr, u8 *buf, u16 len);
+int flexcop_i2c_request(struct flexcop_i2c_adapter*, flexcop_access_op_t,
+       u8 chipaddr, u8 addr, u8 *buf, u16 len);
 
 /* from flexcop-sram.c */
 int flexcop_sram_set_dest(struct flexcop_device *fc, flexcop_sram_dest_t dest, flexcop_sram_dest_target_t target);
index bbcf070a178ddd95ef0e33f8024c6a80958010ee..8a8ae8a3e6ba6954717739ef59487d8804698297 100644 (file)
@@ -114,15 +114,18 @@ static int flexcop_eeprom_request(struct flexcop_device *fc, flexcop_access_op_t
 {
        int i,ret = 0;
        u8 chipaddr =  0x50 | ((addr >> 8) & 3);
-       for (i = 0; i < retries; i++)
-               if ((ret = fc->i2c_request(fc,op,FC_I2C_PORT_EEPROM,chipaddr,addr & 0xff,buf,len)) == 0)
+       for (i = 0; i < retries; i++) {
+               ret = fc->i2c_request(&fc->fc_i2c_adap[1], op, chipaddr,
+                       addr & 0xff, buf, len);
+               if (ret == 0)
                        break;
+       }
        return ret;
 }
 
 static int flexcop_eeprom_lrc_read(struct flexcop_device *fc, u16 addr, u8 *buf, u16 len, int retries)
 {
-       int ret = flexcop_eeprom_request(fc,FC_READ,addr,buf,len,retries);
+       int ret = flexcop_eeprom_request(fc, FC_READ, addr, buf, len, retries);
        if (ret == 0)
                if (calc_lrc(buf, len - 1) != buf[len - 1])
                        ret = -EINVAL;
index 441ffdf0d9c9f330a89cbfd5b8475a0c6ab65658..46d6f5d8cd1c78dabdacf5a6e9cfa61c8e2e0588 100644 (file)
@@ -183,13 +183,13 @@ static int samsung_tbmu24112_tuner_set_params(struct dvb_frontend* fe, struct dv
        buf[2] = 0x84;  /* 0xC4 */
        buf[3] = 0x08;
 
-       if (params->frequency < 1500000) buf[3] |= 0x10;
+       if (params->frequency < 1500000)
+               buf[3] |= 0x10;
 
        if (fe->ops.i2c_gate_ctrl)
                fe->ops.i2c_gate_ctrl(fe, 1);
-       if (i2c_transfer(&fc->i2c_adap, &msg, 1) != 1) {
+       if (i2c_transfer(&fc->fc_i2c_adap[0].i2c_adap, &msg, 1) != 1)
                return -EIO;
-       }
        return 0;
 }
 
@@ -340,7 +340,7 @@ static int skystar23_samsung_tbdu18132_tuner_set_params(struct dvb_frontend* fe,
 
        if (fe->ops.i2c_gate_ctrl)
                fe->ops.i2c_gate_ctrl(fe, 1);
-       if (i2c_transfer(&fc->i2c_adap, &msg, 1) != 1)
+       if (i2c_transfer(&fc->fc_i2c_adap[0].i2c_adap, &msg, 1) != 1)
                return -EIO;
        return 0;
 }
@@ -389,10 +389,11 @@ static int alps_tdee4_stv0297_tuner_set_params(struct dvb_frontend* fe,
        if (fe->ops.i2c_gate_ctrl)
                fe->ops.i2c_gate_ctrl(fe, 0);
        deb_tuner("tuner buffer for %d Hz: %x %x %x %x\n",fep->frequency, buf[0],buf[1],buf[2],buf[3]);
-       ret = fc->i2c_request(fc, FC_WRITE, FC_I2C_PORT_TUNER, 0x61, buf[0], &buf[1], 3);
+       ret = fc->i2c_request(&fc->fc_i2c_adap[2],
+               FC_WRITE, 0x61, buf[0], &buf[1], 3);
        deb_tuner("tuner write returned: %d\n",ret);
 
-       return 0;
+       return ret;
 }
 
 static u8 alps_tdee4_stv0297_inittab[] = {
@@ -479,53 +480,67 @@ static struct stv0297_config alps_tdee4_stv0297_config = {
 int flexcop_frontend_init(struct flexcop_device *fc)
 {
        struct dvb_frontend_ops *ops;
+       struct i2c_adapter *i2c = &fc->fc_i2c_adap[0].i2c_adap;
 
        /* try the sky v2.6 (stv0299/Samsung tbmu24112(sl1935)) */
-       if ((fc->fe = dvb_attach(stv0299_attach, &samsung_tbmu24112_config, &fc->i2c_adap)) != NULL) {
+       fc->fe = dvb_attach(stv0299_attach, &samsung_tbmu24112_config, i2c);
+       if (fc->fe != NULL) {
                ops = &fc->fe->ops;
 
                ops->tuner_ops.set_params = samsung_tbmu24112_tuner_set_params;
 
                ops->set_voltage = flexcop_set_voltage;
 
-               fc->fe_sleep             = ops->sleep;
-               ops->sleep               = flexcop_sleep;
+               fc->fe_sleep = ops->sleep;
+               ops->sleep = flexcop_sleep;
+
+               fc->dev_type = FC_SKY;
+               goto fe_found;
+       }
 
-               fc->dev_type          = FC_SKY;
-               info("found the stv0299 at i2c address: 0x%02x",samsung_tbmu24112_config.demod_address);
-       } else
        /* try the air dvb-t (mt352/Samsung tdtc9251dh0(??)) */
-       if ((fc->fe = dvb_attach(mt352_attach, &samsung_tdtc9251dh0_config, &fc->i2c_adap)) != NULL ) {
-               fc->dev_type          = FC_AIR_DVB;
+       fc->fe = dvb_attach(mt352_attach, &samsung_tdtc9251dh0_config, i2c);
+       if (fc->fe != NULL) {
+               fc->dev_type = FC_AIR_DVB;
                fc->fe->ops.tuner_ops.calc_regs = samsung_tdtc9251dh0_calc_regs;
-               info("found the mt352 at i2c address: 0x%02x",samsung_tdtc9251dh0_config.demod_address);
-       } else
+               goto fe_found;
+       }
+
        /* try the air atsc 2nd generation (nxt2002) */
-       if ((fc->fe = dvb_attach(nxt200x_attach, &samsung_tbmv_config, &fc->i2c_adap)) != NULL) {
-               fc->dev_type          = FC_AIR_ATSC2;
+       fc->fe = dvb_attach(nxt200x_attach, &samsung_tbmv_config, i2c);
+       if (fc->fe != NULL) {
+               fc->dev_type = FC_AIR_ATSC2;
                dvb_attach(dvb_pll_attach, fc->fe, 0x61, NULL, DVB_PLL_SAMSUNG_TBMV);
-               info("found the nxt2002 at i2c address: 0x%02x",samsung_tbmv_config.demod_address);
-       } else
-       /* try the air atsc 3nd generation (lgdt3303) */
-       if ((fc->fe = dvb_attach(lgdt330x_attach, &air2pc_atsc_hd5000_config, &fc->i2c_adap)) != NULL) {
-               fc->dev_type          = FC_AIR_ATSC3;
-               dvb_attach(simple_tuner_attach, fc->fe,
-                          &fc->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
-               info("found the lgdt3303 at i2c address: 0x%02x",air2pc_atsc_hd5000_config.demod_address);
-       } else
+               goto fe_found;
+       }
+
+       fc->fe = dvb_attach(lgdt330x_attach, &air2pc_atsc_hd5000_config, i2c);
+       if (fc->fe != NULL) {
+               fc->dev_type = FC_AIR_ATSC3;
+               dvb_attach(simple_tuner_attach, fc->fe, i2c, 0x61,
+                               TUNER_LG_TDVS_H06XF);
+               goto fe_found;
+       }
+
        /* try the air atsc 1nd generation (bcm3510)/panasonic ct10s */
-       if ((fc->fe = dvb_attach(bcm3510_attach, &air2pc_atsc_first_gen_config, &fc->i2c_adap)) != NULL) {
-               fc->dev_type          = FC_AIR_ATSC1;
-               info("found the bcm3510 at i2c address: 0x%02x",air2pc_atsc_first_gen_config.demod_address);
-       } else
+       fc->fe = dvb_attach(bcm3510_attach, &air2pc_atsc_first_gen_config, i2c);
+       if (fc->fe != NULL) {
+               fc->dev_type = FC_AIR_ATSC1;
+               goto fe_found;
+       }
+
        /* try the cable dvb (stv0297) */
-       if ((fc->fe = dvb_attach(stv0297_attach, &alps_tdee4_stv0297_config, &fc->i2c_adap)) != NULL) {
-               fc->dev_type                        = FC_CABLE;
+       fc->fe = dvb_attach(stv0297_attach, &alps_tdee4_stv0297_config, i2c);
+       if (fc->fe != NULL) {
+               fc->dev_type = FC_CABLE;
                fc->fe->ops.tuner_ops.set_params = alps_tdee4_stv0297_tuner_set_params;
-               info("found the stv0297 at i2c address: 0x%02x",alps_tdee4_stv0297_config.demod_address);
-       } else
+               goto fe_found;
+       }
+
        /* try the sky v2.3 (vp310/Samsung tbdu18132(tsa5059)) */
-       if ((fc->fe = dvb_attach(vp310_mt312_attach, &skystar23_samsung_tbdu18132_config, &fc->i2c_adap)) != NULL) {
+       fc->fe = dvb_attach(vp310_mt312_attach,
+               &skystar23_samsung_tbdu18132_config, i2c);
+       if (fc->fe != NULL) {
                ops = &fc->fe->ops;
 
                ops->tuner_ops.set_params = skystar23_samsung_tbdu18132_tuner_set_params;
@@ -539,19 +554,21 @@ int flexcop_frontend_init(struct flexcop_device *fc)
                ops->sleep                  = flexcop_sleep;
 
                fc->dev_type                = FC_SKY_OLD;
-               info("found the vp310 (aka mt312) at i2c address: 0x%02x",skystar23_samsung_tbdu18132_config.demod_address);
+               goto fe_found;
        }
 
-       if (fc->fe == NULL) {
-               err("no frontend driver found for this B2C2/FlexCop adapter");
-               return -ENODEV;
-       } else {
-               if (dvb_register_frontend(&fc->dvb_adapter, fc->fe)) {
-                       err("frontend registration failed!");
-                       dvb_frontend_detach(fc->fe);
-                       fc->fe = NULL;
-                       return -EINVAL;
-               }
+       err("no frontend driver found for this B2C2/FlexCop adapter");
+       return -ENODEV;
+
+fe_found:
+       info("found '%s' .", fc->fe->ops.info.name);
+       if (dvb_register_frontend(&fc->dvb_adapter, fc->fe)) {
+               err("frontend registration failed!");
+               ops = &fc->fe->ops;
+               if (ops->release != NULL)
+                       ops->release(fc->fe);
+               fc->fe = NULL;
+               return -EINVAL;
        }
        fc->init_state |= FC_STATE_FE_INIT;
        return 0;
index 6bf858a436c98048653f1a6a0ef9eb9305709584..55973eaf371180d90534bced637142582e5373bc 100644 (file)
@@ -9,6 +9,8 @@
 
 #define FC_MAX_I2C_RETRIES 100000
 
+/* #define DUMP_I2C_MESSAGES */
+
 static int flexcop_i2c_operation(struct flexcop_device *fc, flexcop_ibi_value *r100)
 {
        int i;
@@ -38,30 +40,25 @@ static int flexcop_i2c_operation(struct flexcop_device *fc, flexcop_ibi_value *r
        return -EREMOTEIO;
 }
 
-static int flexcop_i2c_read4(struct flexcop_device *fc, flexcop_ibi_value r100, u8 *buf)
+static int flexcop_i2c_read4(struct flexcop_i2c_adapter *i2c,
+       flexcop_ibi_value r100, u8 *buf)
 {
        flexcop_ibi_value r104;
        int len = r100.tw_sm_c_100.total_bytes, /* remember total_bytes is buflen-1 */
                ret;
 
-       if ((ret = flexcop_i2c_operation(fc,&r100)) != 0) {
-               /* The Cablestar needs a different kind of i2c-transfer (does not
-                * support "Repeat Start"):
-                * wait for the ACK failure,
-                * and do a subsequent read with the Bit 30 enabled
-                */
-               r100.tw_sm_c_100.no_base_addr_ack_error = 1;
-               if ((ret = flexcop_i2c_operation(fc,&r100)) != 0) {
-                       deb_i2c("no_base_addr read failed. %d\n",ret);
-                       return ret;
-               }
+       r100.tw_sm_c_100.no_base_addr_ack_error = i2c->no_base_addr;
+       ret = flexcop_i2c_operation(i2c->fc, &r100);
+       if (ret != 0) {
+               deb_i2c("read failed. %d\n", ret);
+               return ret;
        }
 
        buf[0] = r100.tw_sm_c_100.data1_reg;
 
        if (len > 0) {
-               r104 = fc->read_ibi_reg(fc,tw_sm_c_104);
-               deb_i2c("read: r100: %08x, r104: %08x\n",r100.raw,r104.raw);
+               r104 = i2c->fc->read_ibi_reg(i2c->fc, tw_sm_c_104);
+               deb_i2c("read: r100: %08x, r104: %08x\n", r100.raw, r104.raw);
 
                /* there is at least one more byte, otherwise we wouldn't be here */
                buf[1] = r104.tw_sm_c_104.data2_reg;
@@ -85,17 +82,22 @@ static int flexcop_i2c_write4(struct flexcop_device *fc, flexcop_ibi_value r100,
        r104.tw_sm_c_104.data3_reg = len > 1 ? buf[2] : 0;
        r104.tw_sm_c_104.data4_reg = len > 2 ? buf[3] : 0;
 
-       deb_i2c("write: r100: %08x, r104: %08x\n",r100.raw,r104.raw);
+       deb_i2c("write: r100: %08x, r104: %08x\n", r100.raw, r104.raw);
 
        /* write the additional i2c data before doing the actual i2c operation */
-       fc->write_ibi_reg(fc,tw_sm_c_104,r104);
-       return flexcop_i2c_operation(fc,&r100);
+       fc->write_ibi_reg(fc, tw_sm_c_104, r104);
+       return flexcop_i2c_operation(fc, &r100);
 }
 
-int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
-               flexcop_i2c_port_t port, u8 chipaddr, u8 addr, u8 *buf, u16 len)
+int flexcop_i2c_request(struct flexcop_i2c_adapter *i2c,
+       flexcop_access_op_t op, u8 chipaddr, u8 addr, u8 *buf, u16 len)
 {
        int ret;
+
+#ifdef DUMP_I2C_MESSAGES
+       int i;
+#endif
+
        u16 bytes_to_transfer;
        flexcop_ibi_value r100;
 
@@ -103,7 +105,25 @@ int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
        r100.raw = 0;
        r100.tw_sm_c_100.chipaddr = chipaddr;
        r100.tw_sm_c_100.twoWS_rw = op;
-       r100.tw_sm_c_100.twoWS_port_reg = port;
+       r100.tw_sm_c_100.twoWS_port_reg = i2c->port;
+
+#ifdef DUMP_I2C_MESSAGES
+       printk(KERN_DEBUG "%d ", i2c->port);
+       if (op == FC_READ)
+               printk("rd(");
+       else
+               printk("wr(");
+
+       printk("%02x): %02x ", chipaddr, addr);
+#endif
+
+       /* in that case addr is the only value ->
+        * we write it twice as baseaddr and val0
+        * BBTI is doing it like that for ISL6421 at least */
+       if (i2c->no_base_addr && len == 0 && op == FC_WRITE) {
+               buf = &addr;
+               len = 1;
+       }
 
        while (len != 0) {
                bytes_to_transfer = len > 4 ? 4 : len;
@@ -112,9 +132,14 @@ int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
                r100.tw_sm_c_100.baseaddr = addr;
 
                if (op == FC_READ)
-                       ret = flexcop_i2c_read4(fc, r100, buf);
+                       ret = flexcop_i2c_read4(i2c, r100, buf);
                else
-                       ret = flexcop_i2c_write4(fc,r100, buf);
+                       ret = flexcop_i2c_write4(i2c->fc, r100, buf);
+
+#ifdef DUMP_I2C_MESSAGES
+               for (i = 0; i < bytes_to_transfer; i++)
+                       printk("%02x ", buf[i]);
+#endif
 
                if (ret < 0)
                        return ret;
@@ -122,7 +147,11 @@ int flexcop_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
                buf  += bytes_to_transfer;
                addr += bytes_to_transfer;
                len  -= bytes_to_transfer;
-       };
+       }
+
+#ifdef DUMP_I2C_MESSAGES
+       printk("\n");
+#endif
 
        return 0;
 }
@@ -132,7 +161,7 @@ EXPORT_SYMBOL(flexcop_i2c_request);
 /* master xfer callback for demodulator */
 static int flexcop_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
 {
-       struct flexcop_device *fc = i2c_get_adapdata(i2c_adap);
+       struct flexcop_i2c_adapter *i2c = i2c_get_adapdata(i2c_adap);
        int i, ret = 0;
 
        /* Some drivers use 1 byte or 0 byte reads as probes, which this
@@ -142,34 +171,29 @@ static int flexcop_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs
        if (num == 1 && msgs[0].flags == I2C_M_RD && msgs[0].len <= 1)
                return 1;
 
-       if (mutex_lock_interruptible(&fc->i2c_mutex))
+       if (mutex_lock_interruptible(&i2c->fc->i2c_mutex))
                return -ERESTARTSYS;
 
-       /* reading */
-       if (num == 2 &&
-               msgs[0].flags == 0 &&
-               msgs[1].flags == I2C_M_RD &&
-               msgs[0].buf != NULL &&
-               msgs[1].buf != NULL) {
-
-               ret = fc->i2c_request(fc, FC_READ, FC_I2C_PORT_DEMOD, msgs[0].addr, msgs[0].buf[0], msgs[1].buf, msgs[1].len);
-
-       } else for (i = 0; i < num; i++) { /* writing command */
-               if (msgs[i].flags != 0 || msgs[i].buf == NULL || msgs[i].len < 2) {
-                       ret = -EINVAL;
+       for (i = 0; i < num; i++) {
+               /* reading */
+               if (i+1 < num && (msgs[i+1].flags == I2C_M_RD)) {
+                       ret = i2c->fc->i2c_request(i2c, FC_READ, msgs[i].addr,
+                               msgs[i].buf[0], msgs[i+1].buf, msgs[i+1].len);
+                       i++; /* skip the following message */
+               } else /* writing */
+                       ret = i2c->fc->i2c_request(i2c, FC_WRITE, msgs[i].addr,
+                               msgs[i].buf[0], &msgs[i].buf[1],
+                               msgs[i].len - 1);
+               if (ret < 0) {
+                       err("i2c master_xfer failed");
                        break;
                }
-
-               ret = fc->i2c_request(fc, FC_WRITE, FC_I2C_PORT_DEMOD, msgs[i].addr, msgs[i].buf[0], &msgs[i].buf[1], msgs[i].len - 1);
        }
 
-       if (ret < 0)
-               err("i2c master_xfer failed");
-       else
-               ret = num;
-
-       mutex_unlock(&fc->i2c_mutex);
+       mutex_unlock(&i2c->fc->i2c_mutex);
 
+       if (ret == 0)
+               ret = num;
        return ret;
 }
 
@@ -189,28 +213,68 @@ int flexcop_i2c_init(struct flexcop_device *fc)
 
        mutex_init(&fc->i2c_mutex);
 
-       memset(&fc->i2c_adap, 0, sizeof(struct i2c_adapter));
-       strncpy(fc->i2c_adap.name, "B2C2 FlexCop device",
-               sizeof(fc->i2c_adap.name));
-
-       i2c_set_adapdata(&fc->i2c_adap,fc);
+       fc->fc_i2c_adap[0].fc = fc;
+       fc->fc_i2c_adap[1].fc = fc;
+       fc->fc_i2c_adap[2].fc = fc;
+
+       fc->fc_i2c_adap[0].port = FC_I2C_PORT_DEMOD;
+       fc->fc_i2c_adap[1].port = FC_I2C_PORT_EEPROM;
+       fc->fc_i2c_adap[2].port = FC_I2C_PORT_TUNER;
+
+       strncpy(fc->fc_i2c_adap[0].i2c_adap.name,
+               "B2C2 FlexCop I2C to demod", I2C_NAME_SIZE);
+       strncpy(fc->fc_i2c_adap[1].i2c_adap.name,
+               "B2C2 FlexCop I2C to eeprom", I2C_NAME_SIZE);
+       strncpy(fc->fc_i2c_adap[2].i2c_adap.name,
+               "B2C2 FlexCop I2C to tuner", I2C_NAME_SIZE);
+
+       i2c_set_adapdata(&fc->fc_i2c_adap[0].i2c_adap, &fc->fc_i2c_adap[0]);
+       i2c_set_adapdata(&fc->fc_i2c_adap[1].i2c_adap, &fc->fc_i2c_adap[1]);
+       i2c_set_adapdata(&fc->fc_i2c_adap[2].i2c_adap, &fc->fc_i2c_adap[2]);
+
+       fc->fc_i2c_adap[0].i2c_adap.class =
+               fc->fc_i2c_adap[1].i2c_adap.class =
+               fc->fc_i2c_adap[2].i2c_adap.class = I2C_CLASS_TV_DIGITAL;
+       fc->fc_i2c_adap[0].i2c_adap.algo =
+               fc->fc_i2c_adap[1].i2c_adap.algo =
+               fc->fc_i2c_adap[2].i2c_adap.algo = &flexcop_algo;
+       fc->fc_i2c_adap[0].i2c_adap.algo_data =
+               fc->fc_i2c_adap[1].i2c_adap.algo_data =
+               fc->fc_i2c_adap[2].i2c_adap.algo_data = NULL;
+       fc->fc_i2c_adap[0].i2c_adap.dev.parent =
+               fc->fc_i2c_adap[1].i2c_adap.dev.parent =
+               fc->fc_i2c_adap[2].i2c_adap.dev.parent = fc->dev;
+
+       ret = i2c_add_adapter(&fc->fc_i2c_adap[0].i2c_adap);
+       if (ret < 0)
+               return ret;
 
-       fc->i2c_adap.class          = I2C_CLASS_TV_DIGITAL;
-       fc->i2c_adap.algo       = &flexcop_algo;
-       fc->i2c_adap.algo_data  = NULL;
-       fc->i2c_adap.dev.parent = fc->dev;
+       ret = i2c_add_adapter(&fc->fc_i2c_adap[1].i2c_adap);
+       if (ret < 0)
+               goto adap_1_failed;
 
-       if ((ret = i2c_add_adapter(&fc->i2c_adap)) < 0)
-               return ret;
+       ret = i2c_add_adapter(&fc->fc_i2c_adap[2].i2c_adap);
+       if (ret < 0)
+               goto adap_2_failed;
 
        fc->init_state |= FC_STATE_I2C_INIT;
        return 0;
+
+adap_2_failed:
+       i2c_del_adapter(&fc->fc_i2c_adap[1].i2c_adap);
+adap_1_failed:
+       i2c_del_adapter(&fc->fc_i2c_adap[0].i2c_adap);
+
+       return ret;
 }
 
 void flexcop_i2c_exit(struct flexcop_device *fc)
 {
-       if (fc->init_state & FC_STATE_I2C_INIT)
-               i2c_del_adapter(&fc->i2c_adap);
+       if (fc->init_state & FC_STATE_I2C_INIT) {
+               i2c_del_adapter(&fc->fc_i2c_adap[2].i2c_adap);
+               i2c_del_adapter(&fc->fc_i2c_adap[1].i2c_adap);
+               i2c_del_adapter(&fc->fc_i2c_adap[0].i2c_adap);
+       }
 
        fc->init_state &= ~FC_STATE_I2C_INIT;
 }
index 87fb75f0d1cf0b88eb6e16706d8dfe3ffc3b7ebc..449fb5c3d0b1ed31f078ff9b8eb2c244ae4c10bf 100644 (file)
@@ -211,10 +211,11 @@ static int flexcop_usb_utility_req(struct flexcop_usb *fc_usb, int set,
 #endif
 
 /* usb i2c stuff */
-static int flexcop_usb_i2c_req(struct flexcop_usb *fc_usb,
+static int flexcop_usb_i2c_req(struct flexcop_i2c_adapter *i2c,
                flexcop_usb_request_t req, flexcop_usb_i2c_function_t func,
-               flexcop_i2c_port_t port, u8 chipaddr, u8 addr, u8 *buf, u8 buflen)
+               u8 chipaddr, u8 addr, u8 *buf, u8 buflen)
 {
+       struct flexcop_usb *fc_usb = i2c->fc->bus_specific;
        u16 wValue, wIndex;
        int nWaitTime,pipe,len;
 //     u8 dwRequestType;
@@ -242,7 +243,7 @@ static int flexcop_usb_i2c_req(struct flexcop_usb *fc_usb,
                        deb_info("unsupported function for i2c_req %x\n",func);
                        return -EINVAL;
        }
-       wValue = (func << 8 ) | (port << 4);
+       wValue = (func << 8) | (i2c->port << 4);
        wIndex = (chipaddr << 8 ) | addr;
 
        deb_i2c("i2c %2d: %02x %02x %02x %02x %02x %02x\n",func,request_type,req,
@@ -274,13 +275,15 @@ static int flexcop_usb_write_ibi_reg(struct flexcop_device *fc, flexcop_ibi_regi
        return flexcop_usb_readwrite_dw(fc,reg, &val.raw, 0);
 }
 
-static int flexcop_usb_i2c_request(struct flexcop_device *fc, flexcop_access_op_t op,
-               flexcop_i2c_port_t port, u8 chipaddr, u8 addr, u8 *buf, u16 len)
+static int flexcop_usb_i2c_request(struct flexcop_i2c_adapter *i2c,
+       flexcop_access_op_t op, u8 chipaddr, u8 addr, u8 *buf, u16 len)
 {
        if (op == FC_READ)
-               return flexcop_usb_i2c_req(fc->bus_specific,B2C2_USB_I2C_REQUEST,USB_FUNC_I2C_READ,port,chipaddr,addr,buf,len);
+               return flexcop_usb_i2c_req(i2c, B2C2_USB_I2C_REQUEST,
+                       USB_FUNC_I2C_READ, chipaddr, addr, buf, len);
        else
-               return flexcop_usb_i2c_req(fc->bus_specific,B2C2_USB_I2C_REQUEST,USB_FUNC_I2C_WRITE,port,chipaddr,addr,buf,len);
+               return flexcop_usb_i2c_req(i2c, B2C2_USB_I2C_REQUEST,
+                       USB_FUNC_I2C_WRITE, chipaddr, addr, buf, len);
 }
 
 static void flexcop_usb_process_frame(struct flexcop_usb *fc_usb, u8 *buffer, int buffer_length)
index 2ddafd071c9776ddf02946f6ce018f86504e1fa0..205146c241293cde5df6505cc3b09e62fad29d0b 100644 (file)
@@ -257,6 +257,12 @@ int flexcop_device_initialize(struct flexcop_device *fc)
        if ((ret = flexcop_dvb_init(fc)))
                goto error;
 
+       /* i2c has to be done before doing EEProm stuff -
+        * because the EEProm is accessed via i2c */
+       ret = flexcop_i2c_init(fc);
+       if (ret)
+               goto error;
+
        /* do the MAC address reading after initializing the dvb_adapter */
        if (fc->get_mac_addr(fc, 0) == 0) {
                u8 *b = fc->dvb_adapter.proposed_mac;
@@ -266,10 +272,6 @@ int flexcop_device_initialize(struct flexcop_device *fc)
        } else
                warn("reading of MAC address failed.\n");
 
-
-       if ((ret = flexcop_i2c_init(fc)))
-               goto error;
-
        if ((ret = flexcop_frontend_init(fc)))
                goto error;