static int philips_fmd1216_pll_init(struct dvb_frontend *fe)
{
struct cx8802_dev *dev= fe->dvb->priv;
/* this message is to set up ATC and ALC */
static u8 fmd1216_init[] = { 0x0b, 0xdc, 0x9c, 0xa0 };
struct i2c_msg msg =
{ .addr = dev->core->pll_addr, .flags = 0,
.buf = fmd1216_init, .len = sizeof(fmd1216_init) };
int err;
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 1);
if ((err = i2c_transfer(&dev->core->i2c_adap, &msg, 1)) != 1) {
if (err < 0)
return err;
else
return -EREMOTEIO;
}
return 0;
}
static int dntv_live_dvbt_pro_tuner_set_params(struct dvb_frontend* fe,
struct dvb_frontend_parameters* params)
{
struct cx8802_dev *dev= fe->dvb->priv;
u8 buf[4];
struct i2c_msg msg =
{ .addr = dev->core->pll_addr, .flags = 0,
.buf = buf, .len = 4 };
int err;
/* Switch PLL to DVB mode */
err = philips_fmd1216_pll_init(fe);
if (err)
return err;
/* Tune PLL */
dvb_pll_configure(dev->core->pll_desc, buf,
params->frequency,
params->u.ofdm.bandwidth);
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 1);
if ((err = i2c_transfer(&dev->core->i2c_adap, &msg, 1)) != 1) {
printk(KERN_WARNING "cx88-dvb: %s error "
"(addr %02x <- %02x, err = %i)\n",
__FUNCTION__, dev->core->pll_addr, buf[0], err);
if (err < 0)
return err;
else
return -EREMOTEIO;
}
return 0;
}
static struct mt352_config dntv_live_dvbt_pro_config = {
.demod_address = 0x0f,
.no_tuner = 1,
.demod_init = dntv_live_dvbt_pro_demod_init,
};
#endif
static struct zl10353_config dvico_fusionhdtv_hybrid = {
.demod_address = 0x0f,
.no_tuner = 1,
};
static struct zl10353_config dvico_fusionhdtv_plus_v1_1 = {
.demod_address = 0x0f,
};
static struct cx22702_config connexant_refboard_config = {
.demod_address = 0x43,
.output_mode = CX22702_SERIAL_OUTPUT,
};
static struct cx22702_config hauppauge_hvr_config = {
.demod_address = 0x63,
.output_mode = CX22702_SERIAL_OUTPUT,
};
static int or51132_set_ts_param(struct dvb_frontend* fe, int is_punctured)
{
struct cx8802_dev *dev= fe->dvb->priv;
dev->ts_gen_cntrl = is_punctured ? 0x04 : 0x00;
return 0;
}
static struct or51132_config pchdtv_hd3000 = {
.demod_address = 0x15,
.set_ts_params = or51132_set_ts_param,
};
static int lgdt330x_pll_rf_set(struct dvb_frontend* fe, int index)
{
struct cx8802_dev *dev= fe->dvb->priv;
struct cx88_core *core = dev->core;
dprintk(1, "%s: index = %d\n", __FUNCTION__, index);
if (index == 0)
cx_clear(MO_GP0_IO, 8);
else
cx_set(MO_GP0_IO, 8);
return 0;
}
static int lgdt330x_set_ts_param(struct dvb_frontend* fe, int is_punctured)
{
struct cx8802_dev *dev= fe->dvb->priv;
if (is_punctured)
dev->ts_gen_cntrl |= 0x04;
else
dev->ts_gen_cntrl &= ~0x04;
return 0;
}
static struct lgdt330x_config fusionhdtv_3_gold = {
.demod_address = 0x0e,
.demod_chip = LGDT3302,
.serial_mpeg = 0x04, /* TPSERIAL for 3302 in TOP_CONTROL */
.set_ts_params = lgdt330x_set_ts_param,
};
static struct lgdt330x_config fusionhdtv_5_gold = {
.demod_address = 0x0e,
.demod_chip = LGDT3303,
.serial_mpeg = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
.set_ts_params = lgdt330x_set_ts_param,
};
static struct lgdt330x_config pchdtv_hd5500 = {
.demod_address = 0x59,
.demod_chip = LGDT3303,
.serial_mpeg = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
.set_ts_params = lgdt330x_set_ts_param,
};
static int nxt200x_set_ts_param(struct dvb_frontend* fe, int is_punctured)
{
struct cx8802_dev *dev= fe->dvb->priv;
dev->ts_gen_cntrl = is_punctured ? 0x04 : 0x00;
return 0;
}
static int nxt200x_set_pll_input(u8* buf, int input)
{
if (input)
buf[3] |= 0x08;
else
buf[3] &= ~0x08;
return 0;
}
static struct nxt200x_config ati_hdtvwonder = {
.demod_address = 0x0a,
.set_pll_input = nxt200x_set_pll_input,
.set_ts_params = nxt200x_set_ts_param,
};
static int cx24123_set_ts_param(struct dvb_frontend* fe,
int is_punctured)
{
struct cx8802_dev *dev= fe->dvb->priv;
dev->ts_gen_cntrl = 0x02;
return 0;
}
static int kworld_dvbs_100_set_voltage(struct dvb_frontend* fe,
fe_sec_voltage_t voltage)
{
struct cx8802_dev *dev= fe->dvb->priv;
struct cx88_core *core = dev->core;
if (voltage == SEC_VOLTAGE_OFF)
cx_write(MO_GP0_IO, 0x000006fb);
else
cx_write(MO_GP0_IO, 0x000006f9);
if (core->prev_set_voltage)
return core->prev_set_voltage(fe, voltage);
return 0;
}
static int geniatech_dvbs_set_voltage(struct dvb_frontend *fe,
fe_sec_voltage_t voltage)
{
struct cx8802_dev *dev= fe->dvb->priv;
struct cx88_core *core = dev->core;
if (voltage == SEC_VOLTAGE_OFF) {
dprintk(1,"LNB Voltage OFF\n");
cx_write(MO_GP0_IO, 0x0000efff);
}
if (core->prev_set_voltage)
return core->prev_set_voltage(fe, voltage);
return 0;
}
static struct cx24123_config geniatech_dvbs_config = {
.demod_address = 0x55,
.set_ts_params = cx24123_set_ts_param,
};
static struct cx24123_config hauppauge_novas_config = {
.demod_address = 0x55,
.set_ts_params = cx24123_set_ts_param,
};
static struct cx24123_config kworld_dvbs_100_config = {
.demod_address = 0x15,
.set_ts_params = cx24123_set_ts_param,
.lnb_polarity = 1,
};
static int dvb_register(struct cx8802_dev *dev)
{
/* init struct videobuf_dvb */
dev->dvb.name = dev->core->name;
dev->ts_gen_cntrl = 0x0c;
/* init frontend */
switch (dev->core->board) {
case CX88_BOARD_HAUPPAUGE_DVB_T1:
dev->dvb.frontend = dvb_attach(cx22702_attach,
&connexant_refboard_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap,
&dvb_pll_thomson_dtt759x);
}
break;
case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1:
case CX88_BOARD_CONEXANT_DVB_T1:
case CX88_BOARD_KWORLD_DVB_T_CX22702:
case CX88_BOARD_WINFAST_DTV1000:
dev->dvb.frontend = dvb_attach(cx22702_attach,
&connexant_refboard_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x60,
&dev->core->i2c_adap,
&dvb_pll_thomson_dtt7579);
}
break;
case CX88_BOARD_WINFAST_DTV2000H:
case CX88_BOARD_HAUPPAUGE_HVR1100:
case CX88_BOARD_HAUPPAUGE_HVR1100LP:
dev->dvb.frontend = dvb_attach(cx22702_attach,
&hauppauge_hvr_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap, &dvb_pll_fmd1216me);
}
break;
case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS:
dev->dvb.frontend = dvb_attach(mt352_attach,
&dvico_fusionhdtv,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x60,
NULL, &dvb_pll_thomson_dtt7579);
break;
}
/* ZL10353 replaces MT352 on later cards */
dev->dvb.frontend = dvb_attach(zl10353_attach,
&dvico_fusionhdtv_plus_v1_1,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x60,
NULL, &dvb_pll_thomson_dtt7579);
}
break;
case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL:
/* The tin box says DEE1601, but it seems to be DTT7579
* compatible, with a slightly different MT352 AGC gain. */
dev->dvb.frontend = dvb_attach(mt352_attach,
&dvico_fusionhdtv_dual,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
NULL, &dvb_pll_thomson_dtt7579);
break;
}
/* ZL10353 replaces MT352 on later cards */
dev->dvb.frontend = dvb_attach(zl10353_attach,
&dvico_fusionhdtv_plus_v1_1,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
NULL, &dvb_pll_thomson_dtt7579);
}
break;
case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:
dev->dvb.frontend = dvb_attach(mt352_attach,
&dvico_fusionhdtv,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
NULL, &dvb_pll_lg_z201);
}
break;
case CX88_BOARD_KWORLD_DVB_T:
case CX88_BOARD_DNTV_LIVE_DVB_T:
case CX88_BOARD_ADSTECH_DVB_T_PCI:
dev->dvb.frontend = dvb_attach(mt352_attach,
&dntv_live_dvbt_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
NULL, &dvb_pll_unknown_1);
}
break;
case CX88_BOARD_DNTV_LIVE_DVB_T_PRO:
#ifdef HAVE_VP3054_I2C
dev->core->pll_addr = 0x61;
dev->core->pll_desc = &dvb_pll_fmd1216me;
dev->dvb.frontend = dvb_attach(mt352_attach, &dntv_live_dvbt_pro_config,
&((struct vp3054_i2c_state *)dev->card_priv)->adap);
if (dev->dvb.frontend != NULL) {
dev->dvb.frontend->ops.tuner_ops.set_params = dntv_live_dvbt_pro_tuner_set_params;
}
#else
printk("%s: built without vp3054 support\n", dev->core->name);
#endif
break;
case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID:
dev->dvb.frontend = dvb_attach(zl10353_attach,
&dvico_fusionhdtv_hybrid,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap,
&dvb_pll_thomson_fe6600);
}
break;
case CX88_BOARD_PCHDTV_HD3000:
dev->dvb.frontend = dvb_attach(or51132_attach, &pchdtv_hd3000,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap,
&dvb_pll_thomson_dtt761x);
}
break;
case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_Q:
dev->ts_gen_cntrl = 0x08;
{
/* Do a hardware reset of chip before using it. */
struct cx88_core *core = dev->core;
cx_clear(MO_GP0_IO, 1);
mdelay(100);
cx_set(MO_GP0_IO, 1);
mdelay(200);
/* Select RF connector callback */
fusionhdtv_3_gold.pll_rf_set = lgdt330x_pll_rf_set;
dev->dvb.frontend = dvb_attach(lgdt330x_attach,
&fusionhdtv_3_gold,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap,
&dvb_pll_microtune_4042);
}
}
break;
case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_T:
dev->ts_gen_cntrl = 0x08;
{
/* Do a hardware reset of chip before using it. */
struct cx88_core *core = dev->core;
cx_clear(MO_GP0_IO, 1);
mdelay(100);
cx_set(MO_GP0_IO, 9);
mdelay(200);
dev->dvb.frontend = dvb_attach(lgdt330x_attach,
&fusionhdtv_3_gold,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap,
&dvb_pll_thomson_dtt761x);
}
}
break;
case CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD:
dev->ts_gen_cntrl = 0x08;
{
/* Do a hardware reset of chip before using it. */
struct cx88_core *core = dev->core;
cx_clear(MO_GP0_IO, 1);
mdelay(100);
cx_set(MO_GP0_IO, 1);
mdelay(200);
dev->dvb.frontend = dvb_attach(lgdt330x_attach,
&fusionhdtv_5_gold,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(lgh06xf_attach, dev->dvb.frontend,
&dev->core->i2c_adap);
}
}
break;
case CX88_BOARD_PCHDTV_HD5500:
dev->ts_gen_cntrl = 0x08;
{
/* Do a hardware reset of chip before using it. */
struct cx88_core *core = dev->core;
cx_clear(MO_GP0_IO, 1);
mdelay(100);
cx_set(MO_GP0_IO, 1);
mdelay(200);
dev->dvb.frontend = dvb_attach(lgdt330x_attach,
&pchdtv_hd5500,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(lgh06xf_attach, dev->dvb.frontend,
&dev->core->i2c_adap);
}
}
break;
case CX88_BOARD_ATI_HDTVWONDER:
dev->dvb.frontend = dvb_attach(nxt200x_attach,
&ati_hdtvwonder,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
NULL, &dvb_pll_tuv1236d);
}
break;
case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1:
case CX88_BOARD_HAUPPAUGE_NOVASE2_S1:
dev->dvb.frontend = dvb_attach(cx24123_attach,
&hauppauge_novas_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend) {
dvb_attach(isl6421_attach, dev->dvb.frontend,
&dev->core->i2c_adap, 0x08, 0x00, 0x00);
}
break;
case CX88_BOARD_KWORLD_DVBS_100:
dev->dvb.frontend = dvb_attach(cx24123_attach,
&kworld_dvbs_100_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend) {
dev->core->prev_set_voltage = dev->dvb.frontend->ops.set_voltage;
dev->dvb.frontend->ops.set_voltage = kworld_dvbs_100_set_voltage;
}
break;
case CX88_BOARD_GENIATECH_DVBS:
dev->dvb.frontend = dvb_attach(cx24123_attach,
&geniatech_dvbs_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend) {
dev->core->prev_set_voltage = dev->dvb.frontend->ops.set_voltage;
dev->dvb.frontend->ops.set_voltage = geniatech_dvbs_set_voltage;
}
break;
case CX88_BOARD_HAUPPAUGE_HVR1300:
dev->dvb.frontend = dvb_attach(cx22702_attach,
&hauppauge_hvr_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap, &dvb_pll_fmd1216me);
}
break;
case CX88_BOARD_HAUPPAUGE_HVR3000:
dev->dvb.frontend = dvb_attach(cx22702_attach,
&hauppauge_hvr_config,
&dev->core->i2c_adap);
if (dev->dvb.frontend != NULL) {
dvb_attach(dvb_pll_attach, dev->dvb.frontend, 0x61,
&dev->core->i2c_adap, &dvb_pll_fmd1216me);
}
break;
default:
printk("%s: The frontend of your DVB/ATSC card isn't supported yet\n",
dev->core->name);
break;
}
if (NULL == dev->dvb.frontend) {
printk("%s: frontend initialization failed\n",dev->core->name);
return -1;
}
if (dev->core->pll_desc) {
dev->dvb.frontend->ops.info.frequency_min = dev->core->pll_desc->min;
dev->dvb.frontend->ops.info.frequency_max = dev->core->pll_desc->max;
}
/* Ensure all frontends negotiate bus access */
dev->dvb.frontend->ops.ts_bus_ctrl = cx88_dvb_bus_ctrl;
/* Put the analog decoder in standby to keep it quiet */
cx88_call_i2c_clients (dev->core, TUNER_SET_STANDBY, NULL);
/* register everything */
return videobuf_dvb_register(&dev->dvb, THIS_MODULE, dev, &dev->pci->dev);
}
/* ----------------------------------------------------------- */
/* CX8802 MPEG -> mini driver - We have been given the hardware */
static int cx8802_dvb_advise_acquire(struct cx8802_driver *drv)
{
struct cx88_core *core = drv->core;
int err = 0;
dprintk( 1, "%s\n", __FUNCTION__);
switch (core->board) {
case CX88_BOARD_HAUPPAUGE_HVR1300:
/* We arrive here with either the cx23416 or the cx22702
* on the bus. Take the bus from the cx23416 and enable the
* cx22702 demod
*/
cx_set(MO_GP0_IO, 0x00000080); /* cx22702 out of reset and enable */
cx_clear(MO_GP0_IO, 0x00000004);
udelay(1000);
break;
default:
err = -ENODEV;
}
return err;
}
/* CX8802 MPEG -> mini driver - We no longer have the hardware */
static int cx8802_dvb_advise_release(struct cx8802_driver *drv)
{
struct cx88_core *core = drv->core;
int err = 0;
dprintk( 1, "%s\n", __FUNCTION__);
switch (core->board) {
case CX88_BOARD_HAUPPAUGE_HVR1300:
/* Do Nothing, leave the cx22702 on the bus. */
break;
default:
err = -ENODEV;
}
return err;
}
static int cx8802_dvb_probe(struct cx8802_driver *drv)
{
struct cx88_core *core = drv->core;
struct cx8802_dev *dev = drv->core->dvbdev;
int err;
dprintk( 1, "%s\n", __FUNCTION__);
dprintk( 1, " ->being probed by Card=%d Name=%s, PCI %02x:%02x\n",
core->board,
core->name,
core->pci_bus,
core->pci_slot);
err = -ENODEV;
if (!(cx88_boards[core->board].mpeg & CX88_MPEG_DVB))
goto fail_core;
#ifdef HAVE_VP3054_I2C
err = vp3054_i2c_probe(dev);
if (0 != err)
goto fail_core;
#endif
/* dvb stuff */
printk("%s/2: cx2388x based dvb card\n", core->name);
videobuf_queue_init(&dev->dvb.dvbq, &dvb_qops,
dev->pci, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_TOP,
sizeof(struct cx88_buffer),
dev);
err = dvb_register(dev);
if (err != 0)
printk("%s dvb_register failed err = %d\n", __FUNCTION__, err);
fail_core:
return err;
}
static int cx8802_dvb_remove(struct cx8802_driver *drv)
{
struct cx8802_dev *dev = drv->core->dvbdev;
/* dvb */
videobuf_dvb_unregister(&dev->dvb);
#ifdef HAVE_VP3054_I2C
vp3054_i2c_remove(dev);
#endif
return 0;
}
static struct cx8802_driver cx8802_dvb_driver = {
.type_id = CX88_MPEG_DVB,
.hw_access = CX8802_DRVCTL_SHARED,
.probe = cx8802_dvb_probe,
.remove = cx8802_dvb_remove,
.advise_acquire = cx8802_dvb_advise_acquire,
.advise_release = cx8802_dvb_advise_release,
};
static int dvb_init(void)
{
printk(KERN_INFO "cx2388x dvb driver version %d.%d.%d loaded\n",
(CX88_VERSION_CODE >> 16) & 0xff,
(CX88_VERSION_CODE >> 8) & 0xff,
CX88_VERSION_CODE & 0xff);
#ifdef SNAPSHOT
printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
#endif
return cx8802_register_driver(&cx8802_dvb_driver);
}
static void dvb_fini(void)
{
cx8802_unregister_driver(&cx8802_dvb_driver);
}
module_init(dvb_init);
module_exit(dvb_fini);
static int atbm8830_write_reg(struct atbm_state *priv, u16 reg, u8 data)
{
int ret = 0;
u8 dev_addr;
u8 buf1[] = { reg >> 8, reg & 0xFF };
u8 buf2[] = { data };
struct i2c_msg msg1 = { .flags = 0, .buf = buf1, .len = 2 };
struct i2c_msg msg2 = { .flags = 0, .buf = buf2, .len = 1 };
dev_addr = priv->config->demod_address;
msg1.addr = dev_addr;
msg2.addr = dev_addr;
if (debug >= 2)
dprintk("%s: reg=0x%04X, data=0x%02X\n", __func__, reg, data);
ret = i2c_transfer(priv->i2c, &msg1, 1);
if (ret != 1)
return -EIO;
ret = i2c_transfer(priv->i2c, &msg2, 1);
return (ret != 1) ? -EIO : 0;
}
static int atbm8830_read_reg(struct atbm_state *priv, u16 reg, u8 *p_data)
{
int ret;
u8 dev_addr;
u8 buf1[] = { reg >> 8, reg & 0xFF };
u8 buf2[] = { 0 };
struct i2c_msg msg1 = { .flags = 0, .buf = buf1, .len = 2 };
struct i2c_msg msg2 = { .flags = I2C_M_RD, .buf = buf2, .len = 1 };
dev_addr = priv->config->demod_address;
msg1.addr = dev_addr;
msg2.addr = dev_addr;
ret = i2c_transfer(priv->i2c, &msg1, 1);
if (ret != 1) {
dprintk("%s: error reg=0x%04x, ret=%i\n", __func__, reg, ret);
return -EIO;
}
ret = i2c_transfer(priv->i2c, &msg2, 1);
if (ret != 1)
return -EIO;
*p_data = buf2[0];
if (debug >= 2)
dprintk("%s: reg=0x%04X, data=0x%02X\n",
__func__, reg, buf2[0]);
return 0;
}
/* Lock register latch so that multi-register read is atomic */
static inline int atbm8830_reglatch_lock(struct atbm_state *priv, int lock)
{
return atbm8830_write_reg(priv, REG_READ_LATCH, lock ? 1 : 0);
}
static int set_osc_freq(struct atbm_state *priv, u32 freq /*in kHz*/)
{
u32 val;
u64 t;
/* 0x100000 * freq / 30.4MHz */
t = (u64)0x100000 * freq;
do_div(t, 30400);
val = t;
atbm8830_write_reg(priv, REG_OSC_CLK, val);
atbm8830_write_reg(priv, REG_OSC_CLK + 1, val >> 8);
atbm8830_write_reg(priv, REG_OSC_CLK + 2, val >> 16);
return 0;
}
static int set_if_freq(struct atbm_state *priv, u32 freq /*in kHz*/)
{
u32 fs = priv->config->osc_clk_freq;
u64 t;
u32 val;
u8 dat;
if (freq != 0) {
/* 2 * PI * (freq - fs) / fs * (2 ^ 22) */
t = (u64) 2 * 31416 * (freq - fs);
t <<= 22;
do_div(t, fs);
do_div(t, 1000);
val = t;
atbm8830_write_reg(priv, REG_TUNER_BASEBAND, 1);
atbm8830_write_reg(priv, REG_IF_FREQ, val);
atbm8830_write_reg(priv, REG_IF_FREQ+1, val >> 8);
atbm8830_write_reg(priv, REG_IF_FREQ+2, val >> 16);
atbm8830_read_reg(priv, REG_ADC_CONFIG, &dat);
dat &= 0xFC;
atbm8830_write_reg(priv, REG_ADC_CONFIG, dat);
} else {
/**
* Do a twsi read from a 7 bit device address using an (optional) internal address.
* Up to 8 bytes can be read at a time.
*
* @param twsi_id which Octeon TWSI bus to use
* @param dev_addr Device address (7 bit)
* @param internal_addr
* Internal address. Can be 0, 1 or 2 bytes in width
* @param num_bytes Number of data bytes to read
* @param ia_width_bytes
* Internal address size in bytes (0, 1, or 2)
* @param data Pointer argument where the read data is returned.
*
* @return read data returned in 'data' argument
* Number of bytes read on success
* -1 on failure
*/
int cvmx_twsix_read_ia(int twsi_id, uint8_t dev_addr, uint16_t internal_addr, int num_bytes, int ia_width_bytes, uint64_t *data)
{
#ifdef CVMX_BUILD_FOR_LINUX_KERNEL
# if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
struct i2c_adapter *adapter;
u8 data_buf[8];
u8 addr_buf[8];
struct i2c_msg msg[2];
uint64_t r;
int i, j;
if (ia_width_bytes == 0)
return cvmx_twsix_read(twsi_id, dev_addr, num_bytes, data);
BUG_ON(ia_width_bytes > 2);
BUG_ON(num_bytes > 8 || num_bytes < 1);
adapter = __cvmx_twsix_get_adapter(twsi_id);
if (adapter == NULL)
return -1;
for (j = 0, i = ia_width_bytes - 1; i >= 0; i--, j++)
addr_buf[j] = (u8)(internal_addr >> (i * 8));
msg[0].addr = dev_addr;
msg[0].flags = 0;
msg[0].len = ia_width_bytes;
msg[0].buf = addr_buf;
msg[1].addr = dev_addr;
msg[1].flags = I2C_M_RD;
msg[1].len = num_bytes;
msg[1].buf = data_buf;
i = i2c_transfer(adapter, msg, 2);
i2c_put_adapter(adapter);
if (i == 2) {
r = 0;
for (i = 0; i < num_bytes; i++)
r = (r << 8) | data_buf[i];
*data = r;
return num_bytes;
} else {
return -1;
}
# else
BUG(); /* The I2C driver is not compiled in */
# endif
#else
cvmx_mio_twsx_sw_twsi_t sw_twsi_val;
cvmx_mio_twsx_sw_twsi_ext_t twsi_ext;
if (num_bytes < 1 || num_bytes > 8 || !data || ia_width_bytes < 0 || ia_width_bytes > 2)
return -1;
twsi_ext.u64 = 0;
sw_twsi_val.u64 = 0;
sw_twsi_val.s.v = 1;
sw_twsi_val.s.r = 1;
sw_twsi_val.s.sovr = 1;
sw_twsi_val.s.size = num_bytes - 1;
sw_twsi_val.s.a = dev_addr;
if (ia_width_bytes > 0) {
sw_twsi_val.s.op = 1;
sw_twsi_val.s.ia = (internal_addr >> 3) & 0x1f;
sw_twsi_val.s.eop_ia = internal_addr & 0x7;
}
{
int ret;
u8 buf[len+1];
struct i2c_msg msg[1] = {
{
.addr = priv->cfg.i2c_address,
.flags = 0,
.len = sizeof(buf),
.buf = buf,
}
};
buf[0] = reg;
memcpy(&buf[1], val, len);
ret = i2c_transfer(priv->i2c, msg, 1);
if (ret == 1) {
ret = 0;
} else {
dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%02x " \
"len=%d\n", KBUILD_MODNAME, ret, reg, len);
ret = -EREMOTEIO;
}
return ret;
}
/* read multiple registers */
static int tda10071_rd_regs(struct tda10071_priv *priv, u8 reg, u8 *val,
int len)
{
int ret;
struct i2c_msg msgs[] = {
{
.addr = client->addr,
.flags = 0,
.len = addr_len,
.buf = buf,
},
{
.addr = client->addr,
.flags = I2C_M_RD,
.len = data_len,
.buf = buf,
}
};
i2c_flag = i2c_transfer(client->adapter, msgs, 2);
return i2c_flag;
}
static int camera_write_buff(struct i2c_client *client,char *buf, int len)
{
struct i2c_msg msg[] = {
{
.addr = client->addr,
.flags = 0, //|I2C_M_TEN,
.len = len,
.buf = buf,
}
};
return be32_to_cpu(resp);
}
int escore_i2c_read(struct escore_priv *escore, void *buf, int len)
{
struct i2c_msg msg[] = {
{
.addr = escore_i2c->addr,
.flags = I2C_M_RD,
.len = len,
.buf = buf,
},
};
int rc = 0;
rc = i2c_transfer(escore_i2c->adapter, msg, 1);
/*
* i2c_transfer returns number of messages executed. Since we
* are always sending only 1 msg, return value should be 1 for
* success case
*/
if (rc != 1) {
pr_err("%s(): i2c_transfer() failed, rc = %d, msg_len = %d\n",
__func__, rc, len);
return -EIO;
} else {
return 0;
}
}
int escore_i2c_write(struct escore_priv *escore, const void *buf, int len)
.len = 2,
.buf = tmp_buf,
},
{
.addr = saddr,
.flags = I2C_M_RD,
.len = length,
.buf = rxdata,
},
};
tmp_buf[0] = (unsigned char)((S5K4E1_EEPROM_START_ADDR & 0xFF00) >> 8);
tmp_buf[1] = (unsigned char)(S5K4E1_EEPROM_START_ADDR & 0xFF);
//printk("msgs[0].buf = 0x%x, msgs[0].buf[1]=0x%x\n", msgs[0].buf[0], msgs[0].buf[1] );
//printk(" tmp_buf[0] = 0x%x, tmp_buf[1]=0x%x\n", tmp_buf[0], tmp_buf[1] );
rc = i2c_transfer(s5k4e1_s_ctrl.sensor_i2c_client->client->adapter, msgs, 2);
if (rc < 0)
pr_err("s5k4e1_i2c_read_eeprom_burst failed 0x%x\n", saddr);
return rc;
}
static int s5k4e1_read_eeprom_data(struct msm_sensor_ctrl_t *s_ctrl, struct sensor_cfg_data *cfg)
{
int32_t rc = 0;
uint8_t eepromdata[S5K4E1_EEPROM_DATA_SIZE];
printk("s5k4e1_read_eeprom_data==============================>start\n");
#ifdef LSC_CALIBRATION
uint32_t crc_red= 0, crc_gr= 0, crc_gb= 0, crc_blue=0;
int i;
printk("s5k4e1_read_eeprom_data==============================>start\n");
memset(eepromdata, 0, sizeof(eepromdata));
int siinfo_get_boxid(void)
{
return detected_boxid;
}
EXPORT_SYMBOL(siinfo_get_boxid);
static int i2c_autodetect (struct i2c_adapter *adapter, unsigned char i2c_addr, unsigned char dev_addr)
{
unsigned char buf[2] = { 0, 0 };
struct i2c_msg msg[] = {
{ .addr = i2c_addr, .flags = 0, .buf = &dev_addr, .len = 1 },
{ .addr = i2c_addr, .flags = I2C_M_RD, .buf = &buf[0], .len = 1 }
};
int b;
b = i2c_transfer(adapter,msg,1);
b |= i2c_transfer(adapter,msg+1,1);
if (b != 1)
return -1;
return buf[0];
}
static int detect_boxid(void)
{
struct i2c_adapter *adap;
// model detection:
// 1, cicam check? ok => 9900hd
if((adap = i2c_get_adapter(CICAM_I2C_BUS)) == NULL) {
}
static int sn3193_write(struct sn3193_driver_data* dd, u8 *cmd,
int length)
{
int ret;
struct i2c_msg msgs[] = {
[0] = {
.addr = dd->client->addr,
.flags = 0,
.buf = (void *)cmd,
.len = length
},
};
ret = i2c_transfer(dd->client->adapter, msgs, 1);
return (ret < 0) ? -1 : 0;
}
static int sn3193_pins_config(struct sn3193_driver_data* dd)
{
int rc = 0;
u8 cmd[2] = {0, 0};
if (dd->chg_led_ctrl_pin != 255){
rc = gpio_request(dd->chg_led_ctrl_pin, "CHG LED CTRL");
if (rc < 0) {
dev_err(&dd->client->dev, "failed to request %d GPIO\n",
dd->chg_led_ctrl_pin);
return rc;
}
static int ltc3577_i2c_commit( struct i2c_client *client,
ltc3577_msg_t *write_buf,
ltc3577_msg_t *read_buf,
uint8_t lock )
{
struct ltc3577_i2c_driver *driver = (struct ltc3577_i2c_driver *) container_of(client, struct ltc3577_i2c_driver, client);
struct i2c_msg msgs[LTC3577_ADDR_MAX];
uint8_t count = 0;
uint8_t i;
int rc;
/* Get the lock. This before someone else modifies something. */
if (lock)
down( <c3577_register_cache_lock );
if (atomic_read(&driver->suspended)) {
printk( KERN_ERR "LTC3577: Cannot commit transaction. LTC3577 driver suspended or not initialized\n" );
if (lock)
up( <c3577_register_cache_lock );
return -1;
}
/* Prepare one transfer */
for (i = 0; i < LTC3577_ADDR_MAX; i++) {
if (write_buf[i].commit) {
msgs[count].addr = client->addr;
msgs[count].flags = client->flags & I2C_M_TEN;
msgs[count].len = LTC3577_WRITE_SIZE;
msgs[count].buf = write_buf[i].data;
write_buf[i].commit = FALSE;
count++;
}
}
/* Send all messages at once */
rc = i2c_transfer(client->adapter, msgs, count);
if( rc < 0 ) {
if (lock)
up( <c3577_register_cache_lock );
return rc;
}
/* Check whether we need to read sth */
if (NULL == read_buf) {
if (lock)
up( <c3577_register_cache_lock );
return 0;
}
/* Read LTC3577 status register */
if (read_buf->commit) {
uint8_t data;
read_buf->commit = FALSE;
rc = i2c_master_recv( client, &data, sizeof(data));
if( rc < 0 ) {
if (lock)
up( <c3577_register_cache_lock );
return rc;
}
read_buf->data[LTC3577_DATA] = data;
}
if (lock)
up( <c3577_register_cache_lock );
return 0;
}
static inline int s5k6aafx_write(struct i2c_client *client,
unsigned long packet)
{
unsigned char buf[4];
int err = 0;
int retry_count = 5;
struct i2c_msg msg =
{
.addr = client->addr,
.flags = 0,
.buf = buf,
.len = 4,
};
if (!client->adapter)
{
dev_err(&client->dev, "%s: can't search i2c client adapter\n", __func__);
return -EIO;
}
while(retry_count--)
{
*(unsigned long *)buf = cpu_to_be32(packet);
err = i2c_transfer(client->adapter, &msg, 1);
if (likely(err == 1))
break;
mdelay(10);
}
if (unlikely(err < 0))
{
dev_err(&client->dev, "%s: 0x%08x write failed err = %d\n", __func__, (unsigned int)packet, err);
return err;
}
return (err != 1) ? -1 : 0;
}
#ifdef CONFIG_LOAD_FILE
static int s5k6aafx_write_regs_from_sd(struct v4l2_subdev *sd, char s_name[])
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct test *tempData;
int ret = -EAGAIN;
unsigned long temp;
char delay = 0;
char data[11];
int searched = 0;
int size = strlen(s_name);
int i;
FUNC_ENTR();
printk("size = %d, string = %s\n", size, s_name);
tempData = &testBuf[0];
while(!searched)
{
searched = 1;
for (i = 0; i < size; i++)
{
if (tempData->data != s_name[i])
{
searched = 0;
break;
}
tempData = tempData->nextBuf;
}
tempData = tempData->nextBuf;
}
//structure is get..
while(1)
{
if (tempData->data == '{')
{
break;
}
else
{
tempData = tempData->nextBuf;
}
}
while (1)
{
searched = 0;
while (1)
{
if (tempData->data == 'x')
{
//get 10 strings
data[0] = '0';
for (i = 1; i < 11; i++)
{
data[i] = tempData->data;
tempData = tempData->nextBuf;
}
//printk("%s\n", data);
temp = simple_strtoul(data, NULL, 16);
break;
}
else if (tempData->data == '}')
{
searched = 1;
break;
}
else
{
tempData = tempData->nextBuf;
}
if (tempData->nextBuf == NULL)
{
return -1;
}
}
if (searched)
{
break;
}
//let search...
if ((temp & S5K6AAFX_DELAY) == S5K6AAFX_DELAY)
{
delay = temp & 0xFFFF;
printk("[kidggang]:func(%s):line(%d):delay(0x%x):delay(%d)\n",__func__,__LINE__,delay,delay);
msleep(delay);
continue;
}
ret = s5k6aafx_write(client, temp);
/* In error circumstances */
/* Give second shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry one more time\n");
ret = s5k6aafx_write(client, temp);
/* Give it one more shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry twice\n");
ret = s5k6aafx_write(client, temp);
}
}
}
return ret;
}
#endif
/* program multiple registers */
static int s5k6aafx_write_regs(struct v4l2_subdev *sd,
unsigned long *packet, unsigned int num)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
int ret = -EAGAIN; /* FIXME */
unsigned long temp;
char delay = 0;
while (num--)
{
temp = *packet++;
/*
if ((temp & S5K6AAFX_DELAY) == S5K6AAFX_DELAY)
{
if (temp & 0x1)
{
dev_info(&client->dev, "delay for 100msec\n");
msleep(100);
continue;
}
else
{
dev_info(&client->dev, "delay for 10msec\n");
msleep(10);
continue;
}
}
*/
#if 1
if ((temp & S5K6AAFX_DELAY) == S5K6AAFX_DELAY)
{
delay = temp & 0xFFFF;
printk("[kidggang]:func(%s):line(%d):delay(0x%x):delay(%d)\n",__func__,__LINE__,delay,delay);
msleep(delay);
continue;
}
#endif
ret = s5k6aafx_write(client, temp);
/* In error circumstances */
/* Give second shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry one more time\n");
ret = s5k6aafx_write(client, temp);
/* Give it one more shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry twice\n");
ret = s5k6aafx_write(client, temp);
break;
}
}
}
dev_info(&client->dev, "S5K6AAFX register programming ends up\n");
if( ret < 0)
return -EIO;
return ret; /* FIXME */
}
static int s5k6aafx_set_capture_start(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
int err = -EINVAL;
unsigned short lvalue = 0;
FUNC_ENTR();
s5k6aafx_write(client, 0x002C7000);
s5k6aafx_write(client, 0x002E1AAA); //read light value
s5k6aafx_read(client, 0x0F12, &lvalue);
printk("%s : light value is %x\n", __func__, lvalue);
/* set initial regster value */
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_capture");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_capture,
sizeof(s5k6aafx_capture) / sizeof(s5k6aafx_capture[0]));
#endif
if (lvalue < 0x40)
{
printk("\n----- low light -----\n\n");
mdelay(100);//add 100 ms delay for capture sequence
}
else
{
printk("\n----- normal light -----\n\n");
mdelay(50);
}
if (unlikely(err))
{
printk("%s: failed to make capture\n", __func__);
return err;
}
return err;
}
static int s5k6aafx_set_preview_start(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = -EINVAL;
FUNC_ENTR();
dev_info(&client->dev, "%s: set_Preview_start\n", __func__);
if(state->check_dataline) // Output Test Pattern from VGA sensor
{
printk(" pattern on setting~~~~~~~~~~~\n");
err = s5k6aafx_write_regs(sd, s5k6aafx_pattern_on, sizeof(s5k6aafx_pattern_on) / sizeof(s5k6aafx_pattern_on[0]));
// mdelay(200);
}
else
{
/* set initial regster value */
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_preview");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_preview,
sizeof(s5k6aafx_preview) / sizeof(s5k6aafx_preview[0]));
#endif
if (unlikely(err)) {
printk("%s: failed to make preview\n", __func__);
return err;
}
}
// mdelay(200); // add 200 ms for displaying preview
return err;
}
static int s5k6aafx_set_preview_stop(struct v4l2_subdev *sd)
{
int err = 0;
return err;
}
TIMM_OSAL_ERRORTYPE CComponentDispatcherI2CReadHandle::Process(void* pMessage)
{
//unsigned int nPayloadSize = ((systemMessage_t *)pMessage)->nPayloadSize;
struct i2c_msg msg;
TIMM_OSAL_U8* data = NULL;
I2CMessage_t* pI2CMessage = (I2CMessage_t*)((systemMessage_t *)pMessage)->pPayload;
if (dispatcher->I2C_device <= 0 )
{
MMS_IL_PRINT("Device is closed!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
I2CData_t* pI2CData = (I2CData_t*)(pI2CMessage->pData);
if (pI2CData == NULL)
{
MMS_IL_PRINT("pI2CMessage is NULL\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
int SubAddr = pI2CData->nSubAddr;
if (TIMM_OSAL_ERR_NONE != set_slave_addr(dispatcher->I2C_device, pI2CMessage->nSlaveAddr,SubAddr ))
{
MMS_IL_PRINT("Slave address not set!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
MMS_IL_PRINT("Reading from slave addres 0x%04X\n", pI2CMessage->nSlaveAddr);
int pldSz = pI2CData->nPayloadSize;
data = (TIMM_OSAL_U8*)malloc(pldSz * sizeof(TIMM_OSAL_U8));
if (data == NULL)
{
MMS_IL_PRINT("Error allocating memory!\n");
return TIMM_OSAL_ERR_ALLOC;
}
memset(data, 0, pldSz);
MMS_IL_PRINT("Reading from Subaddres 0x%04X, %d bytes\n", SubAddr, pldSz);
msg.addr = pI2CMessage->nSlaveAddr;
msg.flags = I2C_M_RD;
msg.len = pldSz;
msg.buf = data;
if (TIMM_OSAL_ERR_NONE != i2c_transfer(dispatcher->I2C_device, &msg))
{
MMS_IL_PRINT("i2c_smbus_read Failed\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
for(int i = pldSz - 1, j = 0; i >= 0; i--, j++)
{
pI2CData->pPayloadData[i] = (TIMM_OSAL_U8)msg.buf[j];
//MMS_IL_PRINT("msg.buf 0x%08X\n", msg.buf[j]);
//MMS_IL_PRINT("pI2CData->pPayloadData 0x%08X\n", pI2CData->pPayloadData[i]);
}
free(data);
MMS_IL_PRINT("0\n")
return TIMM_OSAL_ERR_NONE;
}
static int stb6000_sleep(struct dvb_frontend *fe)
{
struct stb6000_priv *priv = fe->tuner_priv;
int ret;
u8 buf[] = { 10, 0 };
struct i2c_msg msg = {
.addr = priv->i2c_address,
.flags = 0,
.buf = buf,
.len = 2
};
dprintk("%s:\n", __func__);
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 1);
ret = i2c_transfer(priv->i2c, &msg, 1);
if (ret != 1)
dprintk("%s: i2c error\n", __func__);
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 0);
return (ret == 1) ? 0 : ret;
}
static int stb6000_set_params(struct dvb_frontend *fe)
{
struct dtv_frontend_properties *p = &fe->dtv_property_cache;
struct stb6000_priv *priv = fe->tuner_priv;
unsigned int n, m;
int ret;
u32 freq_mhz;
int bandwidth;
u8 buf[12];
struct i2c_msg msg = {
.addr = priv->i2c_address,
.flags = 0,
.buf = buf,
.len = 12
};
dprintk("%s:\n", __func__);
freq_mhz = p->frequency / 1000;
bandwidth = p->symbol_rate / 1000000;
if (bandwidth > 31)
bandwidth = 31;
if ((freq_mhz > 949) && (freq_mhz < 2151)) {
buf[0] = 0x01;
buf[1] = 0xac;
if (freq_mhz < 1950)
buf[1] = 0xaa;
if (freq_mhz < 1800)
buf[1] = 0xa8;
if (freq_mhz < 1650)
buf[1] = 0xa6;
if (freq_mhz < 1530)
buf[1] = 0xa5;
if (freq_mhz < 1470)
buf[1] = 0xa4;
if (freq_mhz < 1370)
buf[1] = 0xa2;
if (freq_mhz < 1300)
buf[1] = 0xa1;
if (freq_mhz < 1200)
buf[1] = 0xa0;
if (freq_mhz < 1075)
buf[1] = 0xbc;
if (freq_mhz < 1000)
buf[1] = 0xba;
if (freq_mhz < 1075) {
n = freq_mhz / 8; /* */
m = 2;
} else {
n = freq_mhz / 16; /* */
m = 1;
}
buf[2] = n >> 1;
buf[3] = (unsigned char)(((n & 1) << 7) |
(m * freq_mhz - n * 16) | 0x60);
buf[4] = 0x04;
buf[5] = 0x0e;
buf[6] = (unsigned char)(bandwidth);
buf[7] = 0xd8;
buf[8] = 0xd0;
buf[9] = 0x50;
buf[10] = 0xeb;
buf[11] = 0x4f;
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 1);
ret = i2c_transfer(priv->i2c, &msg, 1);
if (ret != 1)
dprintk("%s: i2c error\n", __func__);
udelay(10);
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 0);
buf[0] = 0x07;
buf[1] = 0xdf;
buf[2] = 0xd0;
buf[3] = 0x50;
buf[4] = 0xfb;
msg.len = 5;
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 1);
ret = i2c_transfer(priv->i2c, &msg, 1);
if (ret != 1)
dprintk("%s: i2c error\n", __func__);
udelay(10);
if (fe->ops.i2c_gate_ctrl)
fe->ops.i2c_gate_ctrl(fe, 0);
priv->frequency = freq_mhz * 1000;
return (ret == 1) ? 0 : ret;
}
return -1;
}
static int stb6000_get_frequency(struct dvb_frontend *fe, u32 *frequency)
{
struct stb6000_priv *priv = fe->tuner_priv;
*frequency = priv->frequency;
return 0;
}
static struct dvb_tuner_ops stb6000_tuner_ops = {
.info = {
.name = "ST STB6000",
.frequency_min = 950000,
.frequency_max = 2150000
},
.release = stb6000_release,
.sleep = stb6000_sleep,
.set_params = stb6000_set_params,
.get_frequency = stb6000_get_frequency,
};
{
.addr = i2c->addr,
.flags = 0,
.len = 1,
.buf = rxData,
},
{
.addr = i2c->addr,
.flags = I2C_M_RD,
.len = length,
.buf = rxData,
},
};
uint8_t addr = rxData[0];
ret = i2c_transfer(i2c->adapter, msgs, ARRAY_SIZE(msgs));
if (ret < 0) {
dev_err(&i2c->dev, "%s: transfer failed.", __func__);
return ret;
} else if (ret != ARRAY_SIZE(msgs)) {
dev_err(&i2c->dev, "%s: transfer failed(size error).\n",
__func__);
return -ENXIO;
}
dev_vdbg(&i2c->dev, "RxData: len=%02x, addr=%02x, data=%02x",
length, addr, rxData[0]);
return 0;
}
static int mxb_init_done(struct saa7146_dev* dev)
{
struct mxb* mxb = (struct mxb*)dev->ext_priv;
struct i2c_msg msg;
struct tuner_setup tun_setup;
v4l2_std_id std = V4L2_STD_PAL_BG;
int i = 0, err = 0;
saa7111a_call(mxb, core, s_std, std);
i = 0;
saa7111a_call(mxb, video, s_routing, SAA7115_COMPOSITE0,
SAA7111_FMT_CCIR, 0);
tun_setup.mode_mask = T_ANALOG_TV;
tun_setup.addr = ADDR_UNSET;
tun_setup.type = TUNER_PHILIPS_PAL;
tuner_call(mxb, tuner, s_type_addr, &tun_setup);
mxb->cur_freq.tuner = 0;
mxb->cur_freq.type = V4L2_TUNER_ANALOG_TV;
mxb->cur_freq.frequency = freq;
tuner_call(mxb, tuner, s_frequency, &mxb->cur_freq);
tuner_call(mxb, core, s_std, std);
tea6420_route_line(mxb, 6);
tea6420_route_cd(mxb, 6);
tea6415c_call(mxb, video, s_routing, 3, 17, 0);
tea6415c_call(mxb, video, s_routing, 3, 13, 0);
mxb->cur_input = 0;
mxb->cur_mute = 1;
mxb->cur_mode = V4L2_TUNER_MODE_STEREO;
msg.addr = 0x1b;
msg.flags = 0;
msg.len = mxb_saa7740_init[0].length;
msg.buf = &mxb_saa7740_init[0].data[0];
err = i2c_transfer(&mxb->i2c_adapter, &msg, 1);
if (err == 1) {
extension.flags &= ~SAA7146_USE_I2C_IRQ;
for (i = 1; ; i++) {
if (-1 == mxb_saa7740_init[i].length)
break;
msg.len = mxb_saa7740_init[i].length;
msg.buf = &mxb_saa7740_init[i].data[0];
err = i2c_transfer(&mxb->i2c_adapter, &msg, 1);
if (err != 1) {
DEB_D("failed to initialize 'sound arena module'\n");
goto err;
}
}
pr_info("'sound arena module' detected\n");
}
err:
saa7146_set_hps_source_and_sync(dev, input_port_selection[mxb->cur_input].hps_source,
input_port_selection[mxb->cur_input].hps_sync);
saa7146_write(dev, DD1_STREAM_B, 0x00000000);
saa7146_write(dev, DD1_INIT, 0x02000200);
saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
return 0;
}
};
#endif
static int fm34_i2c_read(char *rxData, int length)
{
int rc;
struct i2c_msg msgs[] = {
{
.addr = this_client->addr,
.flags = I2C_M_RD,
.len = length,
.buf = rxData,
},
};
rc = i2c_transfer(this_client->adapter, msgs, 1);
if (rc < 0) {
pr_err("%s: transfer error %d\n", __func__, rc);
return rc;
}
return 0;
}
static int fm34_i2c_write(char *txData, int length)
{
int rc;
struct i2c_msg msg[] = {
{
.addr = this_client->addr,
.flags = 0,
.len = length,
reg & 0xff,
value & 0xff,
(value >> 8) & 0xff,
(value >> 16) & 0xff,
(value >> 24) & 0xff,
};
struct i2c_msg msgs[] = {
{
.addr = client->addr,
.flags = 0,
.buf = tx_data,
.len = ARRAY_SIZE(tx_data),
},
};
r = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
if (r < 0) {
dev_err(&client->dev, "%s: reg 0x%04x val 0x%08x error %d\n",
__func__, reg, value, r);
return r;
}
if (r < ARRAY_SIZE(msgs)) {
dev_err(&client->dev, "%s: reg 0x%04x val 0x%08x msgs %d\n",
__func__, reg, value, r);
return -EAGAIN;
}
return 0;
}
static
}
int s5ka3dfx_i2c_tx_data(char* txData, int length)
{
int rc;
struct i2c_msg msg[] = {
{
.addr = s5ka3dfx_client->addr,
.flags = 0,
.len = length,
.buf = txData,
},
};
rc = i2c_transfer(s5ka3dfx_client->adapter, msg, 1);
if (rc < 0) {
printk(KERN_ERR "[CAMDRV/S5KA3DFX] s5ka3dfx_i2c_tx_data error %d\n", rc);
return rc;
}
return 0;
}
static int s5ka3dfx_i2c_read(unsigned short page, unsigned short subaddr, unsigned short *data)
{
int ret;
unsigned char buf[1] = {0};
struct i2c_msg msg = { s5ka3dfx_client->addr, 0, 2, buf };
/* page select */
for (retries = 3; retries > 0; retries--) {
struct i2c_msg msgs[] = {
{
.addr = DDC_ADDR,
.flags = 0,
.len = 1,
.buf = &offset,
}, {
.addr = DDC_ADDR,
.flags = I2C_M_RD,
.len = count,
.buf = buf,
}
};
r = i2c_transfer(adapter, msgs, 2);
if (r == 2)
return 0;
if (r != -EAGAIN)
break;
}
return r < 0 ? r : -EIO;
}
static int dvic_read_edid(struct omap_dss_device *dssdev,
u8 *edid, int len)
{
struct panel_drv_data *ddata = to_panel_data(dssdev);
int r, l, bytes_read;
#include "stv6110x_priv.h"
static unsigned int verbose = 16;
static int stv6110x_read_reg(struct stv6110x_state *stv6110x, u8 reg, u8 *data)
{
int ret;
const struct stv6110x_config *config = stv6110x->config;
u8 b0[] = { reg };
u8 b1[] = { 0 };
struct i2c_msg msg[] =
{
{ .addr = config->addr, .flags = 0, .buf = b0, .len = 1 },
{ .addr = config->addr, .flags = I2C_M_RD, .buf = b1, .len = 1 }
};
ret = i2c_transfer(stv6110x->i2c, msg, 2);
if (ret != 2)
{
dprintk(FE_ERROR, 1, "[STV6110X] I/O Error");
return -EREMOTEIO;
}
*data = b1[0];
return 0;
}
static int stv6110x_write_regs(struct stv6110x_state *stv6110x, int start, u8 data[], int len)
{
int ret;
const struct stv6110x_config *config = stv6110x->config;
u8 buf[len + 1];
struct i2c_msg msg =
{
.addr = client->addr,
.flags= 0,
.len = 1,
.buf = buf,
},
{
.addr = client->addr,
.flags= I2C_M_RD,
.len = size,
.buf = data,
}
};
buf[0] = reg;
rc = i2c_transfer(client->adapter, msg, 2);
if(rc != 2){
dev_err(&client->dev,
"shspamp_i2c_read FAILED: read of register %d\n", reg);
rc = -1;
goto i2c_rd_exit;
}
i2c_rd_exit:
return rc;
}
static int shspamp_i2c_write(struct i2c_client *client,
int reg, u8 data)
{
int rc;
#define LCD_EXTERN_NAME "lcd_anx6345"
static int aml_i2c_write(struct i2c_client *i2client,unsigned char *buff, unsigned len)
{
int res = 0;
struct i2c_msg msg[] = {
{
.addr = i2client->addr,
.flags = 0,
.len = len,
.buf = buff,
}
};
res = i2c_transfer(i2client->adapter, msg, 1);
if (res < 0) {
printk("%s: i2c transfer failed [addr 0x%02x]\n", __FUNCTION__, i2client->addr);
}
return res;
}
static int aml_i2c_read(struct i2c_client *i2client,unsigned char *buff, unsigned len)
{
int res = 0;
struct i2c_msg msgs[] = {
{
.addr = i2client->addr,
.flags = 0,
.len = 1,
{
wake_unlock(&s5k3e2fx_wake_lock);
}
int s5k3e2fx_i2c_lens_tx_data(unsigned char slave_addr, char* txData, int length)
{
int rc;
struct i2c_msg msg[] = {
{
.addr = slave_addr,
.flags = 0,
.len = length,
.buf = txData,
},
};
rc = i2c_transfer(pclient->adapter, msg, 1);
if (rc < 0) {
printk(KERN_ERR "s5k3e2fx_i2c_lens_tx_data: i2c_transfer error %d\n", rc);
return rc;
}
return 0;
}
/* Remove unused function */
static int s5k3e2fx_i2c_lens_write(unsigned char slave_addr, unsigned char u_addr, unsigned char u_data)
{
unsigned char buf[2] = { u_addr, u_data };
return s5k3e2fx_i2c_lens_tx_data(slave_addr, buf, sizeof(buf));
}
uint16_t saddr = dev_client->client->addr >> 1;
struct i2c_msg msgs[] = {
{
.addr = saddr,
.flags = 0,
.len = dev_client->addr_type,
.buf = rxdata,
},
{
.addr = saddr,
.flags = I2C_M_RD,
.len = data_length,
.buf = rxdata,
},
};
rc = i2c_transfer(dev_client->client->adapter, msgs, 2);
if (rc < 0)
S_I2C_DBG("msm_camera_qup_i2c_rxdata failed 0x%x\n", saddr);
return rc;
}
static int32_t msm_camera_qup_i2c_txdata(
struct msm_camera_i2c_client *dev_client, unsigned char *txdata,
int length)
{
int32_t rc = 0;
uint16_t saddr = dev_client->client->addr >> 1;
struct i2c_msg msg[] = {
{
.addr = saddr,
.flags = 0,
// Write a config register on an I2C device
// Tailored for the HMC5833L device only i.e. 1 byte of TX
void i2c_write_register(uint8_t reg_offset, uint8_t write_data)
{
cmd_array[0] = reg_offset;
data_array[0] = write_data;
i2c_transfer(HMC_ADDRESS, cmd_array, data_array, 1, 1, I2C_FLAG_WRITE_WRITE);
}
struct i2c_msg msg[] = {
{
.addr = state->config->demod_address,
.flags = 0,
.buf = b0,
.len = 2
},{
.addr = state->config->demod_address,
.flags = I2C_M_RD,
.buf = &buf,
.len = 1
}
};
ret = i2c_transfer(state->i2c, msg, 2);
if (ret != 2) {
if (ret != -ERESTARTSYS)
dprintk(state->verbose, FE_ERROR, 1,
"Read error, Reg=[0x%02x], Status=%d",
reg, ret);
return ret < 0 ? ret : -EREMOTEIO;
}
if (unlikely(*state->verbose >= FE_DEBUGREG))
dprintk(state->verbose, FE_ERROR, 1, "Reg=[0x%02x], data=%02x",
reg, buf);
return (unsigned int)buf;
}
// Read a config register on an I2C device
// Tailored for the HMC5833L device only i.e. 1 byte of TX
uint8_t i2c_read_register(uint8_t reg_offset)
{
cmd_array[0] = reg_offset;
i2c_transfer(HMC_ADDRESS, cmd_array, data_array, 1, 1, I2C_FLAG_WRITE_READ);
return data_array[0];
}
void led_ctrl(uint8_t dyn, uint8_t en13, uint8_t en24) {
uint8_t txd[2];
txd[0] = 0x00; //control word
txd[1] = dyn | (en13 << 1) | (en24 << 2) | 0x50; //control byte to write.
i2c_transfer(txd, 2, NULL, 0, LED_ADDR);
}
/* i2c bus IO */
static int write_fw(struct drx397xD_state *s, enum blob_ix ix)
{
const u8 *data;
int len, rc = 0, i = 0;
struct i2c_msg msg = {
.addr = s->config.demod_address,
.flags = 0
};
if (ix < 0 || ix >= ARRAY_SIZE(blob_name)) {
pr_debug("%s drx_fw_ix_t out of range\n", __func__);
return -EINVAL;
}
pr_debug("%s %s\n", __func__, blob_name[ix]);
read_lock(&fw[s->chip_rev].lock);
data = fw[s->chip_rev].data[ix];
if (!data) {
rc = -EINVAL;
goto exit_rc;
}
for (;;) {
switch (data[i++]) {
case 0: /* bytecode */
len = data[i++];
msg.len = len;
msg.buf = (__u8 *) &data[i];
if (i2c_transfer(s->i2c, &msg, 1) != 1) {
rc = -EIO;
goto exit_rc;
}
i += len;
break;
case 1: /* reset */
case 2: /* sleep */
i++;
break;
default:
goto exit_rc;
}
}
exit_rc:
read_unlock(&fw[s->chip_rev].lock);
return 0;
}
/* Function is not endian safe, use the RD16 wrapper below */
static int _read16(struct drx397xD_state *s, __le32 i2c_adr)
{
int rc;
u8 a[4];
__le16 v;
struct i2c_msg msg[2] = {
{
.addr = s->config.demod_address,
.flags = 0,
.buf = a,
.len = sizeof(a)
}, {
.addr = s->config.demod_address,
