3 i2c tv tuner chip device driver
4 controls the philips tda8290+75 tuner chip combo.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 This "tda8290" module was split apart from the original "tuner" module.
23 #include <linux/i2c.h>
24 #include <linux/delay.h>
25 #include <linux/videodev.h>
30 static int tuner_debug;
31 module_param_named(debug, tuner_debug, int, 0644);
32 MODULE_PARM_DESC(debug, "enable verbose debug messages");
34 #define PREFIX "tda8290 "
36 /* ---------------------------------------------------------------------- */
39 struct tuner_i2c_props i2c_props;
41 unsigned char tda8290_easy_mode;
43 unsigned char tda827x_addr;
44 unsigned char tda827x_ver;
46 struct tda827x_config cfg;
51 /*---------------------------------------------------------------------*/
53 static void tda8290_i2c_bridge(struct dvb_frontend *fe, int close)
55 struct tda8290_priv *priv = fe->analog_demod_priv;
57 unsigned char enable[2] = { 0x21, 0xC0 };
58 unsigned char disable[2] = { 0x21, 0x00 };
62 tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
63 /* let the bridge stabilize */
67 tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
71 static void tda8295_i2c_bridge(struct dvb_frontend *fe, int close)
73 struct tda8290_priv *priv = fe->analog_demod_priv;
75 unsigned char enable[2] = { 0x45, 0xc1 };
76 unsigned char disable[2] = { 0x46, 0x00 };
77 unsigned char buf[3] = { 0x45, 0x01, 0x00 };
81 tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
82 /* let the bridge stabilize */
86 tuner_i2c_xfer_send(&priv->i2c_props, msg, 1);
87 tuner_i2c_xfer_recv(&priv->i2c_props, &msg[1], 1);
91 tuner_i2c_xfer_send(&priv->i2c_props, buf, 3);
95 tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
99 /*---------------------------------------------------------------------*/
101 static void set_audio(struct dvb_frontend *fe)
103 struct tda8290_priv *priv = fe->analog_demod_priv;
104 struct tuner *t = priv->t;
107 priv->cfg.tda827x_lpsel = 0;
108 if (t->std & V4L2_STD_MN) {
110 priv->tda8290_easy_mode = 0x01;
111 priv->cfg.tda827x_lpsel = 1;
113 } else if (t->std & V4L2_STD_B) {
114 priv->cfg.sgIF = 108;
115 priv->tda8290_easy_mode = 0x02;
117 } else if (t->std & V4L2_STD_GH) {
118 priv->cfg.sgIF = 124;
119 priv->tda8290_easy_mode = 0x04;
121 } else if (t->std & V4L2_STD_PAL_I) {
122 priv->cfg.sgIF = 124;
123 priv->tda8290_easy_mode = 0x08;
125 } else if (t->std & V4L2_STD_DK) {
126 priv->cfg.sgIF = 124;
127 priv->tda8290_easy_mode = 0x10;
129 } else if (t->std & V4L2_STD_SECAM_L) {
130 priv->cfg.sgIF = 124;
131 priv->tda8290_easy_mode = 0x20;
133 } else if (t->std & V4L2_STD_SECAM_LC) {
135 priv->tda8290_easy_mode = 0x40;
138 priv->cfg.sgIF = 124;
139 priv->tda8290_easy_mode = 0x10;
143 if (t->mode == V4L2_TUNER_RADIO)
144 priv->cfg.sgIF = 88; /* if frequency is 5.5 MHz */
146 tuner_dbg("setting tda8290 to system %s\n", mode);
149 static void tda8290_set_freq(struct dvb_frontend *fe, unsigned int freq)
151 struct tda8290_priv *priv = fe->analog_demod_priv;
152 struct tuner *t = priv->t;
154 unsigned char soft_reset[] = { 0x00, 0x00 };
155 unsigned char easy_mode[] = { 0x01, priv->tda8290_easy_mode };
156 unsigned char expert_mode[] = { 0x01, 0x80 };
157 unsigned char agc_out_on[] = { 0x02, 0x00 };
158 unsigned char gainset_off[] = { 0x28, 0x14 };
159 unsigned char if_agc_spd[] = { 0x0f, 0x88 };
160 unsigned char adc_head_6[] = { 0x05, 0x04 };
161 unsigned char adc_head_9[] = { 0x05, 0x02 };
162 unsigned char adc_head_12[] = { 0x05, 0x01 };
163 unsigned char pll_bw_nom[] = { 0x0d, 0x47 };
164 unsigned char pll_bw_low[] = { 0x0d, 0x27 };
165 unsigned char gainset_2[] = { 0x28, 0x64 };
166 unsigned char agc_rst_on[] = { 0x0e, 0x0b };
167 unsigned char agc_rst_off[] = { 0x0e, 0x09 };
168 unsigned char if_agc_set[] = { 0x0f, 0x81 };
169 unsigned char addr_adc_sat = 0x1a;
170 unsigned char addr_agc_stat = 0x1d;
171 unsigned char addr_pll_stat = 0x1b;
172 unsigned char adc_sat, agc_stat,
176 struct analog_parameters params = {
179 .audmode = t->audmode,
185 tuner_dbg("tda827xa config is 0x%02x\n", t->config);
186 tuner_i2c_xfer_send(&priv->i2c_props, easy_mode, 2);
187 tuner_i2c_xfer_send(&priv->i2c_props, agc_out_on, 2);
188 tuner_i2c_xfer_send(&priv->i2c_props, soft_reset, 2);
191 expert_mode[1] = priv->tda8290_easy_mode + 0x80;
192 tuner_i2c_xfer_send(&priv->i2c_props, expert_mode, 2);
193 tuner_i2c_xfer_send(&priv->i2c_props, gainset_off, 2);
194 tuner_i2c_xfer_send(&priv->i2c_props, if_agc_spd, 2);
195 if (priv->tda8290_easy_mode & 0x60)
196 tuner_i2c_xfer_send(&priv->i2c_props, adc_head_9, 2);
198 tuner_i2c_xfer_send(&priv->i2c_props, adc_head_6, 2);
199 tuner_i2c_xfer_send(&priv->i2c_props, pll_bw_nom, 2);
201 tda8290_i2c_bridge(fe, 1);
203 if (fe->ops.tuner_ops.set_analog_params)
204 fe->ops.tuner_ops.set_analog_params(fe, ¶ms);
206 for (i = 0; i < 3; i++) {
207 tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
208 tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
209 if (pll_stat & 0x80) {
210 tuner_i2c_xfer_send(&priv->i2c_props, &addr_adc_sat, 1);
211 tuner_i2c_xfer_recv(&priv->i2c_props, &adc_sat, 1);
212 tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
213 tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
214 tuner_dbg("tda8290 is locked, AGC: %d\n", agc_stat);
217 tuner_dbg("tda8290 not locked, no signal?\n");
221 /* adjust headroom resp. gain */
222 if ((agc_stat > 115) || (!(pll_stat & 0x80) && (adc_sat < 20))) {
223 tuner_dbg("adjust gain, step 1. Agc: %d, ADC stat: %d, lock: %d\n",
224 agc_stat, adc_sat, pll_stat & 0x80);
225 tuner_i2c_xfer_send(&priv->i2c_props, gainset_2, 2);
227 tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
228 tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
229 tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
230 tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
231 if ((agc_stat > 115) || !(pll_stat & 0x80)) {
232 tuner_dbg("adjust gain, step 2. Agc: %d, lock: %d\n",
233 agc_stat, pll_stat & 0x80);
237 tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
238 tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
239 tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
240 tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
241 if((agc_stat > 115) || !(pll_stat & 0x80)) {
242 tuner_dbg("adjust gain, step 3. Agc: %d\n", agc_stat);
243 tuner_i2c_xfer_send(&priv->i2c_props, adc_head_12, 2);
244 tuner_i2c_xfer_send(&priv->i2c_props, pll_bw_low, 2);
250 /* l/ l' deadlock? */
251 if(priv->tda8290_easy_mode & 0x60) {
252 tuner_i2c_xfer_send(&priv->i2c_props, &addr_adc_sat, 1);
253 tuner_i2c_xfer_recv(&priv->i2c_props, &adc_sat, 1);
254 tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
255 tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
256 if ((adc_sat > 20) || !(pll_stat & 0x80)) {
257 tuner_dbg("trying to resolve SECAM L deadlock\n");
258 tuner_i2c_xfer_send(&priv->i2c_props, agc_rst_on, 2);
260 tuner_i2c_xfer_send(&priv->i2c_props, agc_rst_off, 2);
264 tda8290_i2c_bridge(fe, 0);
265 tuner_i2c_xfer_send(&priv->i2c_props, if_agc_set, 2);
268 /*---------------------------------------------------------------------*/
270 static void tda8295_power(struct dvb_frontend *fe, int enable)
272 struct tda8290_priv *priv = fe->analog_demod_priv;
273 unsigned char buf[] = { 0x30, 0x00 }; /* clb_stdbt */
275 tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
276 tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
283 tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
286 static void tda8295_set_easy_mode(struct dvb_frontend *fe, int enable)
288 struct tda8290_priv *priv = fe->analog_demod_priv;
289 unsigned char buf[] = { 0x01, 0x00 };
291 tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
292 tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
295 buf[1] = 0x01; /* rising edge sets regs 0x02 - 0x23 */
297 buf[1] = 0x00; /* reset active bit */
299 tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
302 static void tda8295_set_video_std(struct dvb_frontend *fe)
304 struct tda8290_priv *priv = fe->analog_demod_priv;
305 unsigned char buf[] = { 0x00, priv->tda8290_easy_mode };
307 tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
309 tda8295_set_easy_mode(fe, 1);
311 tda8295_set_easy_mode(fe, 0);
314 /*---------------------------------------------------------------------*/
316 static void tda8295_agc1_out(struct dvb_frontend *fe, int enable)
318 struct tda8290_priv *priv = fe->analog_demod_priv;
319 unsigned char buf[] = { 0x02, 0x00 }; /* DIV_FUNC */
321 tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
322 tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
329 tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
332 static void tda8295_agc2_out(struct dvb_frontend *fe, int enable)
334 struct tda8290_priv *priv = fe->analog_demod_priv;
335 unsigned char set_gpio_cf[] = { 0x44, 0x00 };
336 unsigned char set_gpio_val[] = { 0x46, 0x00 };
338 tuner_i2c_xfer_send(&priv->i2c_props, &set_gpio_cf[0], 1);
339 tuner_i2c_xfer_recv(&priv->i2c_props, &set_gpio_cf[1], 1);
340 tuner_i2c_xfer_send(&priv->i2c_props, &set_gpio_val[0], 1);
341 tuner_i2c_xfer_recv(&priv->i2c_props, &set_gpio_val[1], 1);
343 set_gpio_cf[1] &= 0xf0; /* clear GPIO_0 bits 3-0 */
346 set_gpio_cf[1] |= 0x01; /* config GPIO_0 as Open Drain Out */
347 set_gpio_val[1] &= 0xfe; /* set GPIO_0 pin low */
349 tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_cf, 2);
350 tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_val, 2);
353 static int tda8295_has_signal(struct dvb_frontend *fe)
355 struct tda8290_priv *priv = fe->analog_demod_priv;
357 unsigned char hvpll_stat = 0x26;
360 tuner_i2c_xfer_send(&priv->i2c_props, &hvpll_stat, 1);
361 tuner_i2c_xfer_recv(&priv->i2c_props, &ret, 1);
362 return (ret & 0x01) ? 65535 : 0;
365 /*---------------------------------------------------------------------*/
367 static void tda8295_set_freq(struct dvb_frontend *fe, unsigned int freq)
369 struct tda8290_priv *priv = fe->analog_demod_priv;
370 struct tuner *t = priv->t;
373 unsigned char blanking_mode[] = { 0x1d, 0x00 };
375 struct analog_parameters params = {
378 .audmode = t->audmode,
384 ifc = priv->cfg.sgIF; /* FIXME */
386 tuner_dbg("%s: ifc = %u, freq = %d\n", __FUNCTION__, ifc, freq);
388 tda8295_power(fe, 1);
389 tda8295_agc1_out(fe, 1);
391 tuner_i2c_xfer_send(&priv->i2c_props, &blanking_mode[0], 1);
392 tuner_i2c_xfer_recv(&priv->i2c_props, &blanking_mode[1], 1);
394 tda8295_set_video_std(fe);
396 blanking_mode[1] = 0x03;
397 tuner_i2c_xfer_send(&priv->i2c_props, blanking_mode, 2);
400 tda8295_i2c_bridge(fe, 1);
402 if (fe->ops.tuner_ops.set_analog_params)
403 fe->ops.tuner_ops.set_analog_params(fe, ¶ms);
408 if (tda8295_has_signal(fe))
409 tuner_dbg("tda8295 is locked\n");
411 tuner_dbg("tda8295 not locked, no signal?\n");
413 tda8295_i2c_bridge(fe, 0);
416 /*---------------------------------------------------------------------*/
418 static int tda8290_has_signal(struct dvb_frontend *fe)
420 struct tda8290_priv *priv = fe->analog_demod_priv;
422 unsigned char i2c_get_afc[1] = { 0x1B };
423 unsigned char afc = 0;
425 tuner_i2c_xfer_send(&priv->i2c_props, i2c_get_afc, ARRAY_SIZE(i2c_get_afc));
426 tuner_i2c_xfer_recv(&priv->i2c_props, &afc, 1);
427 return (afc & 0x80)? 65535:0;
430 /*---------------------------------------------------------------------*/
432 static void tda8290_standby(struct dvb_frontend *fe)
434 struct tda8290_priv *priv = fe->analog_demod_priv;
436 unsigned char cb1[] = { 0x30, 0xD0 };
437 unsigned char tda8290_standby[] = { 0x00, 0x02 };
438 unsigned char tda8290_agc_tri[] = { 0x02, 0x20 };
439 struct i2c_msg msg = {.addr = priv->tda827x_addr, .flags=0, .buf=cb1, .len = 2};
441 tda8290_i2c_bridge(fe, 1);
442 if (priv->tda827x_ver != 0)
444 i2c_transfer(priv->i2c_props.adap, &msg, 1);
445 tda8290_i2c_bridge(fe, 0);
446 tuner_i2c_xfer_send(&priv->i2c_props, tda8290_agc_tri, 2);
447 tuner_i2c_xfer_send(&priv->i2c_props, tda8290_standby, 2);
450 static void tda8295_standby(struct dvb_frontend *fe)
452 tda8295_agc1_out(fe, 0); /* Put AGC in tri-state */
454 tda8295_power(fe, 0);
457 static void tda8290_init_if(struct dvb_frontend *fe)
459 struct tda8290_priv *priv = fe->analog_demod_priv;
460 struct tuner *t = priv->t;
462 unsigned char set_VS[] = { 0x30, 0x6F };
463 unsigned char set_GP00_CF[] = { 0x20, 0x01 };
464 unsigned char set_GP01_CF[] = { 0x20, 0x0B };
466 if ((t->config == 1) || (t->config == 2))
467 tuner_i2c_xfer_send(&priv->i2c_props, set_GP00_CF, 2);
469 tuner_i2c_xfer_send(&priv->i2c_props, set_GP01_CF, 2);
470 tuner_i2c_xfer_send(&priv->i2c_props, set_VS, 2);
473 static void tda8295_init_if(struct dvb_frontend *fe)
475 struct tda8290_priv *priv = fe->analog_demod_priv;
477 static unsigned char set_adc_ctl[] = { 0x33, 0x14 };
478 static unsigned char set_adc_ctl2[] = { 0x34, 0x00 };
479 static unsigned char set_pll_reg6[] = { 0x3e, 0x63 };
480 static unsigned char set_pll_reg0[] = { 0x38, 0x23 };
481 static unsigned char set_pll_reg7[] = { 0x3f, 0x01 };
482 static unsigned char set_pll_reg10[] = { 0x42, 0x61 };
483 static unsigned char set_gpio_reg0[] = { 0x44, 0x0b };
485 tda8295_power(fe, 1);
487 tda8295_set_easy_mode(fe, 0);
488 tda8295_set_video_std(fe);
490 tuner_i2c_xfer_send(&priv->i2c_props, set_adc_ctl, 2);
491 tuner_i2c_xfer_send(&priv->i2c_props, set_adc_ctl2, 2);
492 tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg6, 2);
493 tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg0, 2);
494 tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg7, 2);
495 tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg10, 2);
496 tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_reg0, 2);
498 tda8295_agc1_out(fe, 0);
499 tda8295_agc2_out(fe, 0);
502 static void tda8290_init_tuner(struct dvb_frontend *fe)
504 struct tda8290_priv *priv = fe->analog_demod_priv;
505 unsigned char tda8275_init[] = { 0x00, 0x00, 0x00, 0x40, 0xdC, 0x04, 0xAf,
506 0x3F, 0x2A, 0x04, 0xFF, 0x00, 0x00, 0x40 };
507 unsigned char tda8275a_init[] = { 0x00, 0x00, 0x00, 0x00, 0xdC, 0x05, 0x8b,
508 0x0c, 0x04, 0x20, 0xFF, 0x00, 0x00, 0x4b };
509 struct i2c_msg msg = {.addr = priv->tda827x_addr, .flags=0,
510 .buf=tda8275_init, .len = 14};
511 if (priv->tda827x_ver != 0)
512 msg.buf = tda8275a_init;
514 tda8290_i2c_bridge(fe, 1);
515 i2c_transfer(priv->i2c_props.adap, &msg, 1);
516 tda8290_i2c_bridge(fe, 0);
519 /*---------------------------------------------------------------------*/
521 static void tda829x_release(struct dvb_frontend *fe)
523 if (fe->ops.tuner_ops.release)
524 fe->ops.tuner_ops.release(fe);
526 kfree(fe->analog_demod_priv);
527 fe->analog_demod_priv = NULL;
530 static struct analog_tuner_ops tda8290_tuner_ops = {
531 .set_tv_freq = tda8290_set_freq,
532 .set_radio_freq = tda8290_set_freq,
533 .has_signal = tda8290_has_signal,
534 .standby = tda8290_standby,
535 .release = tda829x_release,
538 static struct analog_tuner_ops tda8295_tuner_ops = {
539 .set_tv_freq = tda8295_set_freq,
540 .set_radio_freq = tda8295_set_freq,
541 .has_signal = tda8295_has_signal,
542 .standby = tda8295_standby,
543 .release = tda829x_release,
546 int tda8290_attach(struct tuner *t)
548 struct tda8290_priv *priv = NULL;
550 int i, ret, tuners_found;
552 struct i2c_msg msg = {.flags=I2C_M_RD, .buf=&data, .len = 1};
554 priv = kzalloc(sizeof(struct tda8290_priv), GFP_KERNEL);
557 t->fe.analog_demod_priv = priv;
559 priv->i2c_props.addr = t->i2c.addr;
560 priv->i2c_props.adap = t->i2c.adapter;
561 priv->cfg.config = &t->config;
562 priv->cfg.tuner_callback = t->tuner_callback;
565 tda8290_i2c_bridge(&t->fe, 1);
566 /* probe for tuner chip */
569 for (i=0x60; i<= 0x63; i++) {
571 ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
574 tuner_addrs = (tuner_addrs << 8) + i;
577 /* if there is more than one tuner, we expect the right one is
578 behind the bridge and we choose the highest address that doesn't
581 tda8290_i2c_bridge(&t->fe, 0);
583 for (i = 0; i < tuners_found; i++) {
584 msg.addr = tuner_addrs & 0xff;
585 ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
587 tuner_addrs = tuner_addrs >> 8;
591 if (tuner_addrs == 0) {
593 tuner_info("could not clearly identify tuner address, defaulting to %x\n",
596 tuner_addrs = tuner_addrs & 0xff;
597 tuner_info("setting tuner address to %x\n", tuner_addrs);
599 priv->tda827x_addr = tuner_addrs;
600 msg.addr = tuner_addrs;
602 tda8290_i2c_bridge(&t->fe, 1);
604 ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
606 tuner_warn("TDA827x access failed!\n");
608 if ((data & 0x3c) == 0) {
609 strlcpy(t->i2c.name, "tda8290+75", sizeof(t->i2c.name));
610 priv->tda827x_ver = 0;
612 strlcpy(t->i2c.name, "tda8290+75a", sizeof(t->i2c.name));
613 priv->tda827x_ver = 2;
615 tda827x_attach(&t->fe, priv->tda827x_addr,
616 priv->i2c_props.adap, &priv->cfg);
618 /* FIXME: tda827x module doesn't probe the tuner until
619 * tda827x_initial_sleep is called
621 if (t->fe.ops.tuner_ops.sleep)
622 t->fe.ops.tuner_ops.sleep(&t->fe);
624 t->fe.ops.analog_demod_ops = &tda8290_tuner_ops;
626 tuner_info("type set to %s\n", t->i2c.name);
628 priv->cfg.tda827x_lpsel = 0;
629 t->mode = V4L2_TUNER_ANALOG_TV;
631 tda8290_init_tuner(&t->fe);
632 tda8290_init_if(&t->fe);
635 EXPORT_SYMBOL_GPL(tda8290_attach);
637 int tda8295_attach(struct tuner *t)
639 struct tda8290_priv *priv = NULL;
641 int i, ret, tuners_found;
643 struct i2c_msg msg = { .flags = I2C_M_RD, .buf = &data, .len = 1 };
645 priv = kzalloc(sizeof(struct tda8290_priv), GFP_KERNEL);
648 t->fe.analog_demod_priv = priv;
650 priv->i2c_props.addr = t->i2c.addr;
651 priv->i2c_props.adap = t->i2c.adapter;
654 tda8295_i2c_bridge(&t->fe, 1);
655 /* probe for tuner chip */
658 for (i = 0x60; i <= 0x63; i++) {
660 ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
663 tuner_addrs = (tuner_addrs << 8) + i;
666 /* if there is more than one tuner, we expect the right one is
667 behind the bridge and we choose the highest address that doesn't
670 tda8295_i2c_bridge(&t->fe, 0);
671 if (tuners_found > 1)
672 for (i = 0; i < tuners_found; i++) {
673 msg.addr = tuner_addrs & 0xff;
674 ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
676 tuner_addrs = tuner_addrs >> 8;
680 if (tuner_addrs == 0) {
682 tuner_info("could not clearly identify tuner address, "
683 "defaulting to %x\n", tuner_addrs);
685 tuner_addrs = tuner_addrs & 0xff;
686 tuner_info("setting tuner address to %x\n", tuner_addrs);
688 priv->tda827x_addr = tuner_addrs;
689 msg.addr = tuner_addrs;
691 tda8295_i2c_bridge(&t->fe, 1);
692 ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
693 tda8295_i2c_bridge(&t->fe, 0);
695 tuner_warn("TDA827x access failed!\n");
696 if ((data & 0x3c) == 0) {
697 strlcpy(t->i2c.name, "tda8295+18271", sizeof(t->i2c.name));
698 tda18271_attach(&t->fe, priv->tda827x_addr,
699 priv->i2c_props.adap);
700 priv->tda827x_ver = 4;
702 strlcpy(t->i2c.name, "tda8295+75a", sizeof(t->i2c.name));
703 tda827x_attach(&t->fe, priv->tda827x_addr,
704 priv->i2c_props.adap, &priv->cfg);
706 /* FIXME: tda827x module doesn't probe the tuner until
707 * tda827x_initial_sleep is called
709 if (t->fe.ops.tuner_ops.sleep)
710 t->fe.ops.tuner_ops.sleep(&t->fe);
711 priv->tda827x_ver = 2;
713 priv->tda827x_ver |= 1; /* signifies 8295 vs 8290 */
714 tuner_info("type set to %s\n", t->i2c.name);
716 t->fe.ops.analog_demod_ops = &tda8295_tuner_ops;
718 priv->cfg.tda827x_lpsel = 0;
719 t->mode = V4L2_TUNER_ANALOG_TV;
721 tda8295_init_if(&t->fe);
724 EXPORT_SYMBOL_GPL(tda8295_attach);
726 int tda8290_probe(struct tuner *t)
728 struct tuner_i2c_props i2c_props = {
729 .adap = t->i2c.adapter,
733 unsigned char soft_reset[] = { 0x00, 0x00 };
734 unsigned char easy_mode_b[] = { 0x01, 0x02 };
735 unsigned char easy_mode_g[] = { 0x01, 0x04 };
736 unsigned char restore_9886[] = { 0x00, 0xd6, 0x30 };
737 unsigned char addr_dto_lsb = 0x07;
740 tuner_i2c_xfer_send(&i2c_props, easy_mode_b, 2);
741 tuner_i2c_xfer_send(&i2c_props, soft_reset, 2);
742 tuner_i2c_xfer_send(&i2c_props, &addr_dto_lsb, 1);
743 tuner_i2c_xfer_recv(&i2c_props, &data, 1);
745 tuner_i2c_xfer_send(&i2c_props, easy_mode_g, 2);
746 tuner_i2c_xfer_send(&i2c_props, soft_reset, 2);
747 tuner_i2c_xfer_send(&i2c_props, &addr_dto_lsb, 1);
748 tuner_i2c_xfer_recv(&i2c_props, &data, 1);
753 tuner_i2c_xfer_send(&i2c_props, restore_9886, 3);
756 EXPORT_SYMBOL_GPL(tda8290_probe);
758 MODULE_DESCRIPTION("Philips TDA8290 + TDA8275 / TDA8275a tuner driver");
759 MODULE_AUTHOR("Gerd Knorr, Hartmut Hackmann, Michael Krufky");
760 MODULE_LICENSE("GPL");
763 * Overrides for Emacs so that we follow Linus's tabbing style.
764 * ---------------------------------------------------------------------------