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
;
52 struct tda827x_config cfg
;
57 /*---------------------------------------------------------------------*/
59 static int tda8290_i2c_bridge(struct dvb_frontend
*fe
, int close
)
61 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
63 unsigned char enable
[2] = { 0x21, 0xC0 };
64 unsigned char disable
[2] = { 0x21, 0x00 };
69 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
70 /* let the bridge stabilize */
74 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
80 static int tda8295_i2c_bridge(struct dvb_frontend
*fe
, int close
)
82 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
84 unsigned char enable
[2] = { 0x45, 0xc1 };
85 unsigned char disable
[2] = { 0x46, 0x00 };
86 unsigned char buf
[3] = { 0x45, 0x01, 0x00 };
91 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
92 /* let the bridge stabilize */
96 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 1);
97 tuner_i2c_xfer_recv(&priv
->i2c_props
, &msg
[1], 1);
101 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 3);
105 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
111 /*---------------------------------------------------------------------*/
113 static void set_audio(struct dvb_frontend
*fe
)
115 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
116 struct tuner
*t
= priv
->t
;
119 if (t
->std
& V4L2_STD_MN
) {
120 priv
->tda8290_easy_mode
= 0x01;
122 } else if (t
->std
& V4L2_STD_B
) {
123 priv
->tda8290_easy_mode
= 0x02;
125 } else if (t
->std
& V4L2_STD_GH
) {
126 priv
->tda8290_easy_mode
= 0x04;
128 } else if (t
->std
& V4L2_STD_PAL_I
) {
129 priv
->tda8290_easy_mode
= 0x08;
131 } else if (t
->std
& V4L2_STD_DK
) {
132 priv
->tda8290_easy_mode
= 0x10;
134 } else if (t
->std
& V4L2_STD_SECAM_L
) {
135 priv
->tda8290_easy_mode
= 0x20;
137 } else if (t
->std
& V4L2_STD_SECAM_LC
) {
138 priv
->tda8290_easy_mode
= 0x40;
141 priv
->tda8290_easy_mode
= 0x10;
145 tuner_dbg("setting tda829x to system %s\n", mode
);
148 static void tda8290_set_freq(struct dvb_frontend
*fe
, unsigned int freq
)
150 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
151 struct tuner
*t
= priv
->t
;
153 unsigned char soft_reset
[] = { 0x00, 0x00 };
154 unsigned char easy_mode
[] = { 0x01, priv
->tda8290_easy_mode
};
155 unsigned char expert_mode
[] = { 0x01, 0x80 };
156 unsigned char agc_out_on
[] = { 0x02, 0x00 };
157 unsigned char gainset_off
[] = { 0x28, 0x14 };
158 unsigned char if_agc_spd
[] = { 0x0f, 0x88 };
159 unsigned char adc_head_6
[] = { 0x05, 0x04 };
160 unsigned char adc_head_9
[] = { 0x05, 0x02 };
161 unsigned char adc_head_12
[] = { 0x05, 0x01 };
162 unsigned char pll_bw_nom
[] = { 0x0d, 0x47 };
163 unsigned char pll_bw_low
[] = { 0x0d, 0x27 };
164 unsigned char gainset_2
[] = { 0x28, 0x64 };
165 unsigned char agc_rst_on
[] = { 0x0e, 0x0b };
166 unsigned char agc_rst_off
[] = { 0x0e, 0x09 };
167 unsigned char if_agc_set
[] = { 0x0f, 0x81 };
168 unsigned char addr_adc_sat
= 0x1a;
169 unsigned char addr_agc_stat
= 0x1d;
170 unsigned char addr_pll_stat
= 0x1b;
171 unsigned char adc_sat
, agc_stat
,
175 struct analog_parameters params
= {
178 .audmode
= t
->audmode
,
184 tuner_dbg("tda827xa config is 0x%02x\n", t
->config
);
185 tuner_i2c_xfer_send(&priv
->i2c_props
, easy_mode
, 2);
186 tuner_i2c_xfer_send(&priv
->i2c_props
, agc_out_on
, 2);
187 tuner_i2c_xfer_send(&priv
->i2c_props
, soft_reset
, 2);
190 expert_mode
[1] = priv
->tda8290_easy_mode
+ 0x80;
191 tuner_i2c_xfer_send(&priv
->i2c_props
, expert_mode
, 2);
192 tuner_i2c_xfer_send(&priv
->i2c_props
, gainset_off
, 2);
193 tuner_i2c_xfer_send(&priv
->i2c_props
, if_agc_spd
, 2);
194 if (priv
->tda8290_easy_mode
& 0x60)
195 tuner_i2c_xfer_send(&priv
->i2c_props
, adc_head_9
, 2);
197 tuner_i2c_xfer_send(&priv
->i2c_props
, adc_head_6
, 2);
198 tuner_i2c_xfer_send(&priv
->i2c_props
, pll_bw_nom
, 2);
200 tda8290_i2c_bridge(fe
, 1);
202 if (fe
->ops
.tuner_ops
.set_analog_params
)
203 fe
->ops
.tuner_ops
.set_analog_params(fe
, ¶ms
);
205 for (i
= 0; i
< 3; i
++) {
206 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
207 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
208 if (pll_stat
& 0x80) {
209 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_adc_sat
, 1);
210 tuner_i2c_xfer_recv(&priv
->i2c_props
, &adc_sat
, 1);
211 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_agc_stat
, 1);
212 tuner_i2c_xfer_recv(&priv
->i2c_props
, &agc_stat
, 1);
213 tuner_dbg("tda8290 is locked, AGC: %d\n", agc_stat
);
216 tuner_dbg("tda8290 not locked, no signal?\n");
220 /* adjust headroom resp. gain */
221 if ((agc_stat
> 115) || (!(pll_stat
& 0x80) && (adc_sat
< 20))) {
222 tuner_dbg("adjust gain, step 1. Agc: %d, ADC stat: %d, lock: %d\n",
223 agc_stat
, adc_sat
, pll_stat
& 0x80);
224 tuner_i2c_xfer_send(&priv
->i2c_props
, gainset_2
, 2);
226 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_agc_stat
, 1);
227 tuner_i2c_xfer_recv(&priv
->i2c_props
, &agc_stat
, 1);
228 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
229 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
230 if ((agc_stat
> 115) || !(pll_stat
& 0x80)) {
231 tuner_dbg("adjust gain, step 2. Agc: %d, lock: %d\n",
232 agc_stat
, pll_stat
& 0x80);
236 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_agc_stat
, 1);
237 tuner_i2c_xfer_recv(&priv
->i2c_props
, &agc_stat
, 1);
238 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
239 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
240 if((agc_stat
> 115) || !(pll_stat
& 0x80)) {
241 tuner_dbg("adjust gain, step 3. Agc: %d\n", agc_stat
);
242 tuner_i2c_xfer_send(&priv
->i2c_props
, adc_head_12
, 2);
243 tuner_i2c_xfer_send(&priv
->i2c_props
, pll_bw_low
, 2);
249 /* l/ l' deadlock? */
250 if(priv
->tda8290_easy_mode
& 0x60) {
251 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_adc_sat
, 1);
252 tuner_i2c_xfer_recv(&priv
->i2c_props
, &adc_sat
, 1);
253 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
254 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
255 if ((adc_sat
> 20) || !(pll_stat
& 0x80)) {
256 tuner_dbg("trying to resolve SECAM L deadlock\n");
257 tuner_i2c_xfer_send(&priv
->i2c_props
, agc_rst_on
, 2);
259 tuner_i2c_xfer_send(&priv
->i2c_props
, agc_rst_off
, 2);
263 tda8290_i2c_bridge(fe
, 0);
264 tuner_i2c_xfer_send(&priv
->i2c_props
, if_agc_set
, 2);
267 /*---------------------------------------------------------------------*/
269 static void tda8295_power(struct dvb_frontend
*fe
, int enable
)
271 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
272 unsigned char buf
[] = { 0x30, 0x00 }; /* clb_stdbt */
274 tuner_i2c_xfer_send(&priv
->i2c_props
, &buf
[0], 1);
275 tuner_i2c_xfer_recv(&priv
->i2c_props
, &buf
[1], 1);
282 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
285 static void tda8295_set_easy_mode(struct dvb_frontend
*fe
, int enable
)
287 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
288 unsigned char buf
[] = { 0x01, 0x00 };
290 tuner_i2c_xfer_send(&priv
->i2c_props
, &buf
[0], 1);
291 tuner_i2c_xfer_recv(&priv
->i2c_props
, &buf
[1], 1);
294 buf
[1] = 0x01; /* rising edge sets regs 0x02 - 0x23 */
296 buf
[1] = 0x00; /* reset active bit */
298 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
301 static void tda8295_set_video_std(struct dvb_frontend
*fe
)
303 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
304 unsigned char buf
[] = { 0x00, priv
->tda8290_easy_mode
};
306 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
308 tda8295_set_easy_mode(fe
, 1);
310 tda8295_set_easy_mode(fe
, 0);
313 /*---------------------------------------------------------------------*/
315 static void tda8295_agc1_out(struct dvb_frontend
*fe
, int enable
)
317 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
318 unsigned char buf
[] = { 0x02, 0x00 }; /* DIV_FUNC */
320 tuner_i2c_xfer_send(&priv
->i2c_props
, &buf
[0], 1);
321 tuner_i2c_xfer_recv(&priv
->i2c_props
, &buf
[1], 1);
328 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
331 static void tda8295_agc2_out(struct dvb_frontend
*fe
, int enable
)
333 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
334 unsigned char set_gpio_cf
[] = { 0x44, 0x00 };
335 unsigned char set_gpio_val
[] = { 0x46, 0x00 };
337 tuner_i2c_xfer_send(&priv
->i2c_props
, &set_gpio_cf
[0], 1);
338 tuner_i2c_xfer_recv(&priv
->i2c_props
, &set_gpio_cf
[1], 1);
339 tuner_i2c_xfer_send(&priv
->i2c_props
, &set_gpio_val
[0], 1);
340 tuner_i2c_xfer_recv(&priv
->i2c_props
, &set_gpio_val
[1], 1);
342 set_gpio_cf
[1] &= 0xf0; /* clear GPIO_0 bits 3-0 */
345 set_gpio_cf
[1] |= 0x01; /* config GPIO_0 as Open Drain Out */
346 set_gpio_val
[1] &= 0xfe; /* set GPIO_0 pin low */
348 tuner_i2c_xfer_send(&priv
->i2c_props
, set_gpio_cf
, 2);
349 tuner_i2c_xfer_send(&priv
->i2c_props
, set_gpio_val
, 2);
352 static int tda8295_has_signal(struct dvb_frontend
*fe
)
354 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
356 unsigned char hvpll_stat
= 0x26;
359 tuner_i2c_xfer_send(&priv
->i2c_props
, &hvpll_stat
, 1);
360 tuner_i2c_xfer_recv(&priv
->i2c_props
, &ret
, 1);
361 return (ret
& 0x01) ? 65535 : 0;
364 /*---------------------------------------------------------------------*/
366 static void tda8295_set_freq(struct dvb_frontend
*fe
, unsigned int freq
)
368 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
369 struct tuner
*t
= priv
->t
;
371 unsigned char blanking_mode
[] = { 0x1d, 0x00 };
373 struct analog_parameters params
= {
376 .audmode
= t
->audmode
,
382 tuner_dbg("%s: freq = %d\n", __FUNCTION__
, freq
);
384 tda8295_power(fe
, 1);
385 tda8295_agc1_out(fe
, 1);
387 tuner_i2c_xfer_send(&priv
->i2c_props
, &blanking_mode
[0], 1);
388 tuner_i2c_xfer_recv(&priv
->i2c_props
, &blanking_mode
[1], 1);
390 tda8295_set_video_std(fe
);
392 blanking_mode
[1] = 0x03;
393 tuner_i2c_xfer_send(&priv
->i2c_props
, blanking_mode
, 2);
396 tda8295_i2c_bridge(fe
, 1);
398 if (fe
->ops
.tuner_ops
.set_analog_params
)
399 fe
->ops
.tuner_ops
.set_analog_params(fe
, ¶ms
);
404 if (tda8295_has_signal(fe
))
405 tuner_dbg("tda8295 is locked\n");
407 tuner_dbg("tda8295 not locked, no signal?\n");
409 tda8295_i2c_bridge(fe
, 0);
412 /*---------------------------------------------------------------------*/
414 static int tda8290_has_signal(struct dvb_frontend
*fe
)
416 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
418 unsigned char i2c_get_afc
[1] = { 0x1B };
419 unsigned char afc
= 0;
421 tuner_i2c_xfer_send(&priv
->i2c_props
, i2c_get_afc
, ARRAY_SIZE(i2c_get_afc
));
422 tuner_i2c_xfer_recv(&priv
->i2c_props
, &afc
, 1);
423 return (afc
& 0x80)? 65535:0;
426 /*---------------------------------------------------------------------*/
428 static void tda8290_standby(struct dvb_frontend
*fe
)
430 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
432 unsigned char cb1
[] = { 0x30, 0xD0 };
433 unsigned char tda8290_standby
[] = { 0x00, 0x02 };
434 unsigned char tda8290_agc_tri
[] = { 0x02, 0x20 };
435 struct i2c_msg msg
= {.addr
= priv
->tda827x_addr
, .flags
=0, .buf
=cb1
, .len
= 2};
437 tda8290_i2c_bridge(fe
, 1);
438 if (priv
->ver
& TDA8275A
)
440 i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
441 tda8290_i2c_bridge(fe
, 0);
442 tuner_i2c_xfer_send(&priv
->i2c_props
, tda8290_agc_tri
, 2);
443 tuner_i2c_xfer_send(&priv
->i2c_props
, tda8290_standby
, 2);
446 static void tda8295_standby(struct dvb_frontend
*fe
)
448 tda8295_agc1_out(fe
, 0); /* Put AGC in tri-state */
450 tda8295_power(fe
, 0);
453 static void tda8290_init_if(struct dvb_frontend
*fe
)
455 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
456 struct tuner
*t
= priv
->t
;
458 unsigned char set_VS
[] = { 0x30, 0x6F };
459 unsigned char set_GP00_CF
[] = { 0x20, 0x01 };
460 unsigned char set_GP01_CF
[] = { 0x20, 0x0B };
462 if ((t
->config
== 1) || (t
->config
== 2))
463 tuner_i2c_xfer_send(&priv
->i2c_props
, set_GP00_CF
, 2);
465 tuner_i2c_xfer_send(&priv
->i2c_props
, set_GP01_CF
, 2);
466 tuner_i2c_xfer_send(&priv
->i2c_props
, set_VS
, 2);
469 static void tda8295_init_if(struct dvb_frontend
*fe
)
471 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
473 static unsigned char set_adc_ctl
[] = { 0x33, 0x14 };
474 static unsigned char set_adc_ctl2
[] = { 0x34, 0x00 };
475 static unsigned char set_pll_reg6
[] = { 0x3e, 0x63 };
476 static unsigned char set_pll_reg0
[] = { 0x38, 0x23 };
477 static unsigned char set_pll_reg7
[] = { 0x3f, 0x01 };
478 static unsigned char set_pll_reg10
[] = { 0x42, 0x61 };
479 static unsigned char set_gpio_reg0
[] = { 0x44, 0x0b };
481 tda8295_power(fe
, 1);
483 tda8295_set_easy_mode(fe
, 0);
484 tda8295_set_video_std(fe
);
486 tuner_i2c_xfer_send(&priv
->i2c_props
, set_adc_ctl
, 2);
487 tuner_i2c_xfer_send(&priv
->i2c_props
, set_adc_ctl2
, 2);
488 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg6
, 2);
489 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg0
, 2);
490 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg7
, 2);
491 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg10
, 2);
492 tuner_i2c_xfer_send(&priv
->i2c_props
, set_gpio_reg0
, 2);
494 tda8295_agc1_out(fe
, 0);
495 tda8295_agc2_out(fe
, 0);
498 static void tda8290_init_tuner(struct dvb_frontend
*fe
)
500 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
501 unsigned char tda8275_init
[] = { 0x00, 0x00, 0x00, 0x40, 0xdC, 0x04, 0xAf,
502 0x3F, 0x2A, 0x04, 0xFF, 0x00, 0x00, 0x40 };
503 unsigned char tda8275a_init
[] = { 0x00, 0x00, 0x00, 0x00, 0xdC, 0x05, 0x8b,
504 0x0c, 0x04, 0x20, 0xFF, 0x00, 0x00, 0x4b };
505 struct i2c_msg msg
= {.addr
= priv
->tda827x_addr
, .flags
=0,
506 .buf
=tda8275_init
, .len
= 14};
507 if (priv
->ver
& TDA8275A
)
508 msg
.buf
= tda8275a_init
;
510 tda8290_i2c_bridge(fe
, 1);
511 i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
512 tda8290_i2c_bridge(fe
, 0);
515 /*---------------------------------------------------------------------*/
517 static void tda829x_release(struct dvb_frontend
*fe
)
519 if (fe
->ops
.tuner_ops
.release
)
520 fe
->ops
.tuner_ops
.release(fe
);
522 kfree(fe
->analog_demod_priv
);
523 fe
->analog_demod_priv
= NULL
;
526 static int tda829x_find_tuner(struct dvb_frontend
*fe
)
528 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
529 struct analog_tuner_ops
*ops
= fe
->ops
.analog_demod_ops
;
530 struct tuner
*t
= priv
->t
;
531 int i
, ret
, tuners_found
;
534 struct i2c_msg msg
= { .flags
= I2C_M_RD
, .buf
= &data
, .len
= 1 };
539 ops
->i2c_gate_ctrl(fe
, 1);
541 /* probe for tuner chip */
544 for (i
= 0x60; i
<= 0x63; i
++) {
546 ret
= i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
549 tuner_addrs
= (tuner_addrs
<< 8) + i
;
552 /* if there is more than one tuner, we expect the right one is
553 behind the bridge and we choose the highest address that doesn't
557 ops
->i2c_gate_ctrl(fe
, 0);
559 if (tuners_found
> 1)
560 for (i
= 0; i
< tuners_found
; i
++) {
561 msg
.addr
= tuner_addrs
& 0xff;
562 ret
= i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
564 tuner_addrs
= tuner_addrs
>> 8;
569 if (tuner_addrs
== 0) {
571 tuner_info("could not clearly identify tuner address, "
572 "defaulting to %x\n", tuner_addrs
);
574 tuner_addrs
= tuner_addrs
& 0xff;
575 tuner_info("setting tuner address to %x\n", tuner_addrs
);
577 priv
->tda827x_addr
= tuner_addrs
;
578 msg
.addr
= tuner_addrs
;
580 ops
->i2c_gate_ctrl(fe
, 1);
581 ret
= i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
584 tuner_warn("tuner access failed!\n");
589 priv
->ver
|= TDA18271
;
590 tda18271_attach(&t
->fe
, priv
->tda827x_addr
,
591 priv
->i2c_props
.adap
);
593 if ((data
& 0x3c) == 0)
594 priv
->ver
|= TDA8275
;
596 priv
->ver
|= TDA8275A
;
598 tda827x_attach(&t
->fe
, priv
->tda827x_addr
,
599 priv
->i2c_props
.adap
, &priv
->cfg
);
601 if (t
->fe
.ops
.tuner_ops
.init
)
602 t
->fe
.ops
.tuner_ops
.init(&t
->fe
);
604 if (t
->fe
.ops
.tuner_ops
.sleep
)
605 t
->fe
.ops
.tuner_ops
.sleep(&t
->fe
);
607 ops
->i2c_gate_ctrl(fe
, 0);
610 case TDA8290
| TDA8275
:
611 strlcpy(t
->i2c
->name
, "tda8290+75", sizeof(t
->i2c
->name
));
613 case TDA8295
| TDA8275
:
614 strlcpy(t
->i2c
->name
, "tda8295+75", sizeof(t
->i2c
->name
));
616 case TDA8290
| TDA8275A
:
617 strlcpy(t
->i2c
->name
, "tda8290+75a", sizeof(t
->i2c
->name
));
619 case TDA8295
| TDA8275A
:
620 strlcpy(t
->i2c
->name
, "tda8295+75a", sizeof(t
->i2c
->name
));
622 case TDA8290
| TDA18271
:
623 strlcpy(t
->i2c
->name
, "tda8290+18271", sizeof(t
->i2c
->name
));
625 case TDA8295
| TDA18271
:
626 strlcpy(t
->i2c
->name
, "tda8295+18271", sizeof(t
->i2c
->name
));
635 static int tda8290_probe(struct tuner_i2c_props
*i2c_props
)
637 #define TDA8290_ID 0x89
638 unsigned char tda8290_id
[] = { 0x1f, 0x00 };
641 tuner_i2c_xfer_send(i2c_props
, &tda8290_id
[0], 1);
642 tuner_i2c_xfer_recv(i2c_props
, &tda8290_id
[1], 1);
644 if (tda8290_id
[1] == TDA8290_ID
) {
646 printk(KERN_DEBUG
"%s: tda8290 detected @ %d-%04x\n",
647 __FUNCTION__
, i2c_adapter_id(i2c_props
->adap
),
655 static int tda8295_probe(struct tuner_i2c_props
*i2c_props
)
657 #define TDA8295_ID 0x8a
658 unsigned char tda8295_id
[] = { 0x2f, 0x00 };
661 tuner_i2c_xfer_send(i2c_props
, &tda8295_id
[0], 1);
662 tuner_i2c_xfer_recv(i2c_props
, &tda8295_id
[1], 1);
664 if (tda8295_id
[1] == TDA8295_ID
) {
666 printk(KERN_DEBUG
"%s: tda8295 detected @ %d-%04x\n",
667 __FUNCTION__
, i2c_adapter_id(i2c_props
->adap
),
675 static struct analog_tuner_ops tda8290_tuner_ops
= {
676 .set_tv_freq
= tda8290_set_freq
,
677 .set_radio_freq
= tda8290_set_freq
,
678 .has_signal
= tda8290_has_signal
,
679 .standby
= tda8290_standby
,
680 .release
= tda829x_release
,
681 .i2c_gate_ctrl
= tda8290_i2c_bridge
,
684 static struct analog_tuner_ops tda8295_tuner_ops
= {
685 .set_tv_freq
= tda8295_set_freq
,
686 .set_radio_freq
= tda8295_set_freq
,
687 .has_signal
= tda8295_has_signal
,
688 .standby
= tda8295_standby
,
689 .release
= tda829x_release
,
690 .i2c_gate_ctrl
= tda8295_i2c_bridge
,
693 int tda829x_attach(struct tuner
*t
)
695 struct dvb_frontend
*fe
= &t
->fe
;
696 struct tda8290_priv
*priv
= NULL
;
698 priv
= kzalloc(sizeof(struct tda8290_priv
), GFP_KERNEL
);
701 fe
->analog_demod_priv
= priv
;
703 priv
->i2c_props
.addr
= t
->i2c
->addr
;
704 priv
->i2c_props
.adap
= t
->i2c
->adapter
;
705 priv
->cfg
.config
= &t
->config
;
706 priv
->cfg
.tuner_callback
= t
->tuner_callback
;
709 if (tda8290_probe(&priv
->i2c_props
) == 0) {
711 fe
->ops
.analog_demod_ops
= &tda8290_tuner_ops
;
714 if (tda8295_probe(&priv
->i2c_props
) == 0) {
716 fe
->ops
.analog_demod_ops
= &tda8295_tuner_ops
;
719 if (tda829x_find_tuner(fe
) < 0)
722 if (priv
->ver
& TDA8290
) {
723 tda8290_init_tuner(fe
);
725 } else if (priv
->ver
& TDA8295
)
728 tuner_info("type set to %s\n", t
->i2c
->name
);
730 t
->mode
= V4L2_TUNER_ANALOG_TV
;
734 EXPORT_SYMBOL_GPL(tda829x_attach
);
736 int tda829x_probe(struct tuner
*t
)
738 struct tuner_i2c_props i2c_props
= {
739 .adap
= t
->i2c
->adapter
,
743 unsigned char soft_reset
[] = { 0x00, 0x00 };
744 unsigned char easy_mode_b
[] = { 0x01, 0x02 };
745 unsigned char easy_mode_g
[] = { 0x01, 0x04 };
746 unsigned char restore_9886
[] = { 0x00, 0xd6, 0x30 };
747 unsigned char addr_dto_lsb
= 0x07;
749 #define PROBE_BUFFER_SIZE 8
750 unsigned char buf
[PROBE_BUFFER_SIZE
];
753 /* rule out tda9887, which would return the same byte repeatedly */
754 tuner_i2c_xfer_send(&i2c_props
, soft_reset
, 1);
755 tuner_i2c_xfer_recv(&i2c_props
, buf
, PROBE_BUFFER_SIZE
);
756 for (i
= 1; i
< PROBE_BUFFER_SIZE
; i
++) {
757 if (buf
[i
] != buf
[0])
761 /* all bytes are equal, not a tda829x - probably a tda9887 */
762 if (i
== PROBE_BUFFER_SIZE
)
765 if ((tda8290_probe(&i2c_props
) == 0) ||
766 (tda8295_probe(&i2c_props
) == 0))
769 /* fall back to old probing method */
770 tuner_i2c_xfer_send(&i2c_props
, easy_mode_b
, 2);
771 tuner_i2c_xfer_send(&i2c_props
, soft_reset
, 2);
772 tuner_i2c_xfer_send(&i2c_props
, &addr_dto_lsb
, 1);
773 tuner_i2c_xfer_recv(&i2c_props
, &data
, 1);
775 tuner_i2c_xfer_send(&i2c_props
, easy_mode_g
, 2);
776 tuner_i2c_xfer_send(&i2c_props
, soft_reset
, 2);
777 tuner_i2c_xfer_send(&i2c_props
, &addr_dto_lsb
, 1);
778 tuner_i2c_xfer_recv(&i2c_props
, &data
, 1);
783 tuner_i2c_xfer_send(&i2c_props
, restore_9886
, 3);
786 EXPORT_SYMBOL_GPL(tda829x_probe
);
788 MODULE_DESCRIPTION("Philips/NXP TDA8290/TDA8295 analog IF demodulator driver");
789 MODULE_AUTHOR("Gerd Knorr, Hartmut Hackmann, Michael Krufky");
790 MODULE_LICENSE("GPL");
793 * Overrides for Emacs so that we follow Linus's tabbing style.
794 * ---------------------------------------------------------------------------