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>
26 #include "tuner-i2c.h"
32 module_param(debug
, int, 0644);
33 MODULE_PARM_DESC(debug
, "enable verbose debug messages");
35 #define PREFIX "tda8290"
37 /* ---------------------------------------------------------------------- */
40 struct tuner_i2c_props i2c_props
;
42 unsigned char tda8290_easy_mode
;
44 unsigned char tda827x_addr
;
53 struct tda827x_config cfg
;
56 /*---------------------------------------------------------------------*/
58 static int tda8290_i2c_bridge(struct dvb_frontend
*fe
, int close
)
60 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
62 unsigned char enable
[2] = { 0x21, 0xC0 };
63 unsigned char disable
[2] = { 0x21, 0x00 };
68 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
69 /* let the bridge stabilize */
73 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
79 static int tda8295_i2c_bridge(struct dvb_frontend
*fe
, int close
)
81 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
83 unsigned char enable
[2] = { 0x45, 0xc1 };
84 unsigned char disable
[2] = { 0x46, 0x00 };
85 unsigned char buf
[3] = { 0x45, 0x01, 0x00 };
90 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
91 /* let the bridge stabilize */
95 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 1);
96 tuner_i2c_xfer_recv(&priv
->i2c_props
, &msg
[1], 1);
100 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 3);
104 tuner_i2c_xfer_send(&priv
->i2c_props
, msg
, 2);
110 /*---------------------------------------------------------------------*/
112 static void set_audio(struct dvb_frontend
*fe
,
113 struct analog_parameters
*params
)
115 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
118 if (params
->std
& V4L2_STD_MN
) {
119 priv
->tda8290_easy_mode
= 0x01;
121 } else if (params
->std
& V4L2_STD_B
) {
122 priv
->tda8290_easy_mode
= 0x02;
124 } else if (params
->std
& V4L2_STD_GH
) {
125 priv
->tda8290_easy_mode
= 0x04;
127 } else if (params
->std
& V4L2_STD_PAL_I
) {
128 priv
->tda8290_easy_mode
= 0x08;
130 } else if (params
->std
& V4L2_STD_DK
) {
131 priv
->tda8290_easy_mode
= 0x10;
133 } else if (params
->std
& V4L2_STD_SECAM_L
) {
134 priv
->tda8290_easy_mode
= 0x20;
136 } else if (params
->std
& V4L2_STD_SECAM_LC
) {
137 priv
->tda8290_easy_mode
= 0x40;
140 priv
->tda8290_easy_mode
= 0x10;
144 tuner_dbg("setting tda829x to system %s\n", mode
);
147 static void tda8290_set_params(struct dvb_frontend
*fe
,
148 struct analog_parameters
*params
)
150 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
152 unsigned char soft_reset
[] = { 0x00, 0x00 };
153 unsigned char easy_mode
[] = { 0x01, priv
->tda8290_easy_mode
};
154 unsigned char expert_mode
[] = { 0x01, 0x80 };
155 unsigned char agc_out_on
[] = { 0x02, 0x00 };
156 unsigned char gainset_off
[] = { 0x28, 0x14 };
157 unsigned char if_agc_spd
[] = { 0x0f, 0x88 };
158 unsigned char adc_head_6
[] = { 0x05, 0x04 };
159 unsigned char adc_head_9
[] = { 0x05, 0x02 };
160 unsigned char adc_head_12
[] = { 0x05, 0x01 };
161 unsigned char pll_bw_nom
[] = { 0x0d, 0x47 };
162 unsigned char pll_bw_low
[] = { 0x0d, 0x27 };
163 unsigned char gainset_2
[] = { 0x28, 0x64 };
164 unsigned char agc_rst_on
[] = { 0x0e, 0x0b };
165 unsigned char agc_rst_off
[] = { 0x0e, 0x09 };
166 unsigned char if_agc_set
[] = { 0x0f, 0x81 };
167 unsigned char addr_adc_sat
= 0x1a;
168 unsigned char addr_agc_stat
= 0x1d;
169 unsigned char addr_pll_stat
= 0x1b;
170 unsigned char adc_sat
, agc_stat
,
174 set_audio(fe
, params
);
176 if (priv
->cfg
.config
)
177 tuner_dbg("tda827xa config is 0x%02x\n", *priv
->cfg
.config
);
178 tuner_i2c_xfer_send(&priv
->i2c_props
, easy_mode
, 2);
179 tuner_i2c_xfer_send(&priv
->i2c_props
, agc_out_on
, 2);
180 tuner_i2c_xfer_send(&priv
->i2c_props
, soft_reset
, 2);
183 expert_mode
[1] = priv
->tda8290_easy_mode
+ 0x80;
184 tuner_i2c_xfer_send(&priv
->i2c_props
, expert_mode
, 2);
185 tuner_i2c_xfer_send(&priv
->i2c_props
, gainset_off
, 2);
186 tuner_i2c_xfer_send(&priv
->i2c_props
, if_agc_spd
, 2);
187 if (priv
->tda8290_easy_mode
& 0x60)
188 tuner_i2c_xfer_send(&priv
->i2c_props
, adc_head_9
, 2);
190 tuner_i2c_xfer_send(&priv
->i2c_props
, adc_head_6
, 2);
191 tuner_i2c_xfer_send(&priv
->i2c_props
, pll_bw_nom
, 2);
193 tda8290_i2c_bridge(fe
, 1);
195 if (fe
->ops
.tuner_ops
.set_analog_params
)
196 fe
->ops
.tuner_ops
.set_analog_params(fe
, params
);
198 for (i
= 0; i
< 3; i
++) {
199 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
200 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
201 if (pll_stat
& 0x80) {
202 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_adc_sat
, 1);
203 tuner_i2c_xfer_recv(&priv
->i2c_props
, &adc_sat
, 1);
204 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_agc_stat
, 1);
205 tuner_i2c_xfer_recv(&priv
->i2c_props
, &agc_stat
, 1);
206 tuner_dbg("tda8290 is locked, AGC: %d\n", agc_stat
);
209 tuner_dbg("tda8290 not locked, no signal?\n");
213 /* adjust headroom resp. gain */
214 if ((agc_stat
> 115) || (!(pll_stat
& 0x80) && (adc_sat
< 20))) {
215 tuner_dbg("adjust gain, step 1. Agc: %d, ADC stat: %d, lock: %d\n",
216 agc_stat
, adc_sat
, pll_stat
& 0x80);
217 tuner_i2c_xfer_send(&priv
->i2c_props
, gainset_2
, 2);
219 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_agc_stat
, 1);
220 tuner_i2c_xfer_recv(&priv
->i2c_props
, &agc_stat
, 1);
221 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
222 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
223 if ((agc_stat
> 115) || !(pll_stat
& 0x80)) {
224 tuner_dbg("adjust gain, step 2. Agc: %d, lock: %d\n",
225 agc_stat
, pll_stat
& 0x80);
229 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_agc_stat
, 1);
230 tuner_i2c_xfer_recv(&priv
->i2c_props
, &agc_stat
, 1);
231 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
232 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
233 if((agc_stat
> 115) || !(pll_stat
& 0x80)) {
234 tuner_dbg("adjust gain, step 3. Agc: %d\n", agc_stat
);
235 tuner_i2c_xfer_send(&priv
->i2c_props
, adc_head_12
, 2);
236 tuner_i2c_xfer_send(&priv
->i2c_props
, pll_bw_low
, 2);
242 /* l/ l' deadlock? */
243 if(priv
->tda8290_easy_mode
& 0x60) {
244 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_adc_sat
, 1);
245 tuner_i2c_xfer_recv(&priv
->i2c_props
, &adc_sat
, 1);
246 tuner_i2c_xfer_send(&priv
->i2c_props
, &addr_pll_stat
, 1);
247 tuner_i2c_xfer_recv(&priv
->i2c_props
, &pll_stat
, 1);
248 if ((adc_sat
> 20) || !(pll_stat
& 0x80)) {
249 tuner_dbg("trying to resolve SECAM L deadlock\n");
250 tuner_i2c_xfer_send(&priv
->i2c_props
, agc_rst_on
, 2);
252 tuner_i2c_xfer_send(&priv
->i2c_props
, agc_rst_off
, 2);
256 tda8290_i2c_bridge(fe
, 0);
257 tuner_i2c_xfer_send(&priv
->i2c_props
, if_agc_set
, 2);
260 /*---------------------------------------------------------------------*/
262 static void tda8295_power(struct dvb_frontend
*fe
, int enable
)
264 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
265 unsigned char buf
[] = { 0x30, 0x00 }; /* clb_stdbt */
267 tuner_i2c_xfer_send(&priv
->i2c_props
, &buf
[0], 1);
268 tuner_i2c_xfer_recv(&priv
->i2c_props
, &buf
[1], 1);
275 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
278 static void tda8295_set_easy_mode(struct dvb_frontend
*fe
, int enable
)
280 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
281 unsigned char buf
[] = { 0x01, 0x00 };
283 tuner_i2c_xfer_send(&priv
->i2c_props
, &buf
[0], 1);
284 tuner_i2c_xfer_recv(&priv
->i2c_props
, &buf
[1], 1);
287 buf
[1] = 0x01; /* rising edge sets regs 0x02 - 0x23 */
289 buf
[1] = 0x00; /* reset active bit */
291 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
294 static void tda8295_set_video_std(struct dvb_frontend
*fe
)
296 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
297 unsigned char buf
[] = { 0x00, priv
->tda8290_easy_mode
};
299 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
301 tda8295_set_easy_mode(fe
, 1);
303 tda8295_set_easy_mode(fe
, 0);
306 /*---------------------------------------------------------------------*/
308 static void tda8295_agc1_out(struct dvb_frontend
*fe
, int enable
)
310 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
311 unsigned char buf
[] = { 0x02, 0x00 }; /* DIV_FUNC */
313 tuner_i2c_xfer_send(&priv
->i2c_props
, &buf
[0], 1);
314 tuner_i2c_xfer_recv(&priv
->i2c_props
, &buf
[1], 1);
321 tuner_i2c_xfer_send(&priv
->i2c_props
, buf
, 2);
324 static void tda8295_agc2_out(struct dvb_frontend
*fe
, int enable
)
326 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
327 unsigned char set_gpio_cf
[] = { 0x44, 0x00 };
328 unsigned char set_gpio_val
[] = { 0x46, 0x00 };
330 tuner_i2c_xfer_send(&priv
->i2c_props
, &set_gpio_cf
[0], 1);
331 tuner_i2c_xfer_recv(&priv
->i2c_props
, &set_gpio_cf
[1], 1);
332 tuner_i2c_xfer_send(&priv
->i2c_props
, &set_gpio_val
[0], 1);
333 tuner_i2c_xfer_recv(&priv
->i2c_props
, &set_gpio_val
[1], 1);
335 set_gpio_cf
[1] &= 0xf0; /* clear GPIO_0 bits 3-0 */
338 set_gpio_cf
[1] |= 0x01; /* config GPIO_0 as Open Drain Out */
339 set_gpio_val
[1] &= 0xfe; /* set GPIO_0 pin low */
341 tuner_i2c_xfer_send(&priv
->i2c_props
, set_gpio_cf
, 2);
342 tuner_i2c_xfer_send(&priv
->i2c_props
, set_gpio_val
, 2);
345 static int tda8295_has_signal(struct dvb_frontend
*fe
)
347 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
349 unsigned char hvpll_stat
= 0x26;
352 tuner_i2c_xfer_send(&priv
->i2c_props
, &hvpll_stat
, 1);
353 tuner_i2c_xfer_recv(&priv
->i2c_props
, &ret
, 1);
354 return (ret
& 0x01) ? 65535 : 0;
357 /*---------------------------------------------------------------------*/
359 static void tda8295_set_params(struct dvb_frontend
*fe
,
360 struct analog_parameters
*params
)
362 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
364 unsigned char blanking_mode
[] = { 0x1d, 0x00 };
366 set_audio(fe
, params
);
368 tuner_dbg("%s: freq = %d\n", __FUNCTION__
, params
->frequency
);
370 tda8295_power(fe
, 1);
371 tda8295_agc1_out(fe
, 1);
373 tuner_i2c_xfer_send(&priv
->i2c_props
, &blanking_mode
[0], 1);
374 tuner_i2c_xfer_recv(&priv
->i2c_props
, &blanking_mode
[1], 1);
376 tda8295_set_video_std(fe
);
378 blanking_mode
[1] = 0x03;
379 tuner_i2c_xfer_send(&priv
->i2c_props
, blanking_mode
, 2);
382 tda8295_i2c_bridge(fe
, 1);
384 if (fe
->ops
.tuner_ops
.set_analog_params
)
385 fe
->ops
.tuner_ops
.set_analog_params(fe
, params
);
390 if (tda8295_has_signal(fe
))
391 tuner_dbg("tda8295 is locked\n");
393 tuner_dbg("tda8295 not locked, no signal?\n");
395 tda8295_i2c_bridge(fe
, 0);
398 /*---------------------------------------------------------------------*/
400 static int tda8290_has_signal(struct dvb_frontend
*fe
)
402 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
404 unsigned char i2c_get_afc
[1] = { 0x1B };
405 unsigned char afc
= 0;
407 tuner_i2c_xfer_send(&priv
->i2c_props
, i2c_get_afc
, ARRAY_SIZE(i2c_get_afc
));
408 tuner_i2c_xfer_recv(&priv
->i2c_props
, &afc
, 1);
409 return (afc
& 0x80)? 65535:0;
412 /*---------------------------------------------------------------------*/
414 static void tda8290_standby(struct dvb_frontend
*fe
)
416 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
418 unsigned char cb1
[] = { 0x30, 0xD0 };
419 unsigned char tda8290_standby
[] = { 0x00, 0x02 };
420 unsigned char tda8290_agc_tri
[] = { 0x02, 0x20 };
421 struct i2c_msg msg
= {.addr
= priv
->tda827x_addr
, .flags
=0, .buf
=cb1
, .len
= 2};
423 tda8290_i2c_bridge(fe
, 1);
424 if (priv
->ver
& TDA8275A
)
426 i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
427 tda8290_i2c_bridge(fe
, 0);
428 tuner_i2c_xfer_send(&priv
->i2c_props
, tda8290_agc_tri
, 2);
429 tuner_i2c_xfer_send(&priv
->i2c_props
, tda8290_standby
, 2);
432 static void tda8295_standby(struct dvb_frontend
*fe
)
434 tda8295_agc1_out(fe
, 0); /* Put AGC in tri-state */
436 tda8295_power(fe
, 0);
439 static void tda8290_init_if(struct dvb_frontend
*fe
)
441 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
443 unsigned char set_VS
[] = { 0x30, 0x6F };
444 unsigned char set_GP00_CF
[] = { 0x20, 0x01 };
445 unsigned char set_GP01_CF
[] = { 0x20, 0x0B };
447 if ((priv
->cfg
.config
) &&
448 ((*priv
->cfg
.config
== 1) || (*priv
->cfg
.config
== 2)))
449 tuner_i2c_xfer_send(&priv
->i2c_props
, set_GP00_CF
, 2);
451 tuner_i2c_xfer_send(&priv
->i2c_props
, set_GP01_CF
, 2);
452 tuner_i2c_xfer_send(&priv
->i2c_props
, set_VS
, 2);
455 static void tda8295_init_if(struct dvb_frontend
*fe
)
457 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
459 static unsigned char set_adc_ctl
[] = { 0x33, 0x14 };
460 static unsigned char set_adc_ctl2
[] = { 0x34, 0x00 };
461 static unsigned char set_pll_reg6
[] = { 0x3e, 0x63 };
462 static unsigned char set_pll_reg0
[] = { 0x38, 0x23 };
463 static unsigned char set_pll_reg7
[] = { 0x3f, 0x01 };
464 static unsigned char set_pll_reg10
[] = { 0x42, 0x61 };
465 static unsigned char set_gpio_reg0
[] = { 0x44, 0x0b };
467 tda8295_power(fe
, 1);
469 tda8295_set_easy_mode(fe
, 0);
470 tda8295_set_video_std(fe
);
472 tuner_i2c_xfer_send(&priv
->i2c_props
, set_adc_ctl
, 2);
473 tuner_i2c_xfer_send(&priv
->i2c_props
, set_adc_ctl2
, 2);
474 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg6
, 2);
475 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg0
, 2);
476 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg7
, 2);
477 tuner_i2c_xfer_send(&priv
->i2c_props
, set_pll_reg10
, 2);
478 tuner_i2c_xfer_send(&priv
->i2c_props
, set_gpio_reg0
, 2);
480 tda8295_agc1_out(fe
, 0);
481 tda8295_agc2_out(fe
, 0);
484 static void tda8290_init_tuner(struct dvb_frontend
*fe
)
486 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
487 unsigned char tda8275_init
[] = { 0x00, 0x00, 0x00, 0x40, 0xdC, 0x04, 0xAf,
488 0x3F, 0x2A, 0x04, 0xFF, 0x00, 0x00, 0x40 };
489 unsigned char tda8275a_init
[] = { 0x00, 0x00, 0x00, 0x00, 0xdC, 0x05, 0x8b,
490 0x0c, 0x04, 0x20, 0xFF, 0x00, 0x00, 0x4b };
491 struct i2c_msg msg
= {.addr
= priv
->tda827x_addr
, .flags
=0,
492 .buf
=tda8275_init
, .len
= 14};
493 if (priv
->ver
& TDA8275A
)
494 msg
.buf
= tda8275a_init
;
496 tda8290_i2c_bridge(fe
, 1);
497 i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
498 tda8290_i2c_bridge(fe
, 0);
501 /*---------------------------------------------------------------------*/
503 static void tda829x_release(struct dvb_frontend
*fe
)
505 if (fe
->ops
.tuner_ops
.release
)
506 fe
->ops
.tuner_ops
.release(fe
);
508 kfree(fe
->analog_demod_priv
);
509 fe
->analog_demod_priv
= NULL
;
512 static int tda829x_find_tuner(struct dvb_frontend
*fe
)
514 struct tda8290_priv
*priv
= fe
->analog_demod_priv
;
515 struct analog_tuner_ops
*ops
= fe
->ops
.analog_demod_ops
;
516 int i
, ret
, tuners_found
;
519 struct i2c_msg msg
= { .flags
= I2C_M_RD
, .buf
= &data
, .len
= 1 };
524 ops
->i2c_gate_ctrl(fe
, 1);
526 /* probe for tuner chip */
529 for (i
= 0x60; i
<= 0x63; i
++) {
531 ret
= i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
534 tuner_addrs
= (tuner_addrs
<< 8) + i
;
537 /* if there is more than one tuner, we expect the right one is
538 behind the bridge and we choose the highest address that doesn't
542 ops
->i2c_gate_ctrl(fe
, 0);
544 if (tuners_found
> 1)
545 for (i
= 0; i
< tuners_found
; i
++) {
546 msg
.addr
= tuner_addrs
& 0xff;
547 ret
= i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
549 tuner_addrs
= tuner_addrs
>> 8;
554 if (tuner_addrs
== 0) {
556 tuner_info("could not clearly identify tuner address, "
557 "defaulting to %x\n", tuner_addrs
);
559 tuner_addrs
= tuner_addrs
& 0xff;
560 tuner_info("setting tuner address to %x\n", tuner_addrs
);
562 priv
->tda827x_addr
= tuner_addrs
;
563 msg
.addr
= tuner_addrs
;
565 ops
->i2c_gate_ctrl(fe
, 1);
566 ret
= i2c_transfer(priv
->i2c_props
.adap
, &msg
, 1);
569 tuner_warn("tuner access failed!\n");
574 priv
->ver
|= TDA18271
;
575 tda18271_attach(fe
, priv
->tda827x_addr
,
576 priv
->i2c_props
.adap
,
577 TDA18271_GATE_ANALOG
);
579 if ((data
& 0x3c) == 0)
580 priv
->ver
|= TDA8275
;
582 priv
->ver
|= TDA8275A
;
584 tda827x_attach(fe
, priv
->tda827x_addr
,
585 priv
->i2c_props
.adap
, &priv
->cfg
);
587 if (fe
->ops
.tuner_ops
.init
)
588 fe
->ops
.tuner_ops
.init(fe
);
590 if (fe
->ops
.tuner_ops
.sleep
)
591 fe
->ops
.tuner_ops
.sleep(fe
);
593 ops
->i2c_gate_ctrl(fe
, 0);
598 static int tda8290_probe(struct tuner_i2c_props
*i2c_props
)
600 #define TDA8290_ID 0x89
601 unsigned char tda8290_id
[] = { 0x1f, 0x00 };
604 tuner_i2c_xfer_send(i2c_props
, &tda8290_id
[0], 1);
605 tuner_i2c_xfer_recv(i2c_props
, &tda8290_id
[1], 1);
607 if (tda8290_id
[1] == TDA8290_ID
) {
609 printk(KERN_DEBUG
"%s: tda8290 detected @ %d-%04x\n",
610 __FUNCTION__
, i2c_adapter_id(i2c_props
->adap
),
618 static int tda8295_probe(struct tuner_i2c_props
*i2c_props
)
620 #define TDA8295_ID 0x8a
621 unsigned char tda8295_id
[] = { 0x2f, 0x00 };
624 tuner_i2c_xfer_send(i2c_props
, &tda8295_id
[0], 1);
625 tuner_i2c_xfer_recv(i2c_props
, &tda8295_id
[1], 1);
627 if (tda8295_id
[1] == TDA8295_ID
) {
629 printk(KERN_DEBUG
"%s: tda8295 detected @ %d-%04x\n",
630 __FUNCTION__
, i2c_adapter_id(i2c_props
->adap
),
638 static struct analog_tuner_ops tda8290_tuner_ops
= {
642 .set_params
= tda8290_set_params
,
643 .has_signal
= tda8290_has_signal
,
644 .standby
= tda8290_standby
,
645 .release
= tda829x_release
,
646 .i2c_gate_ctrl
= tda8290_i2c_bridge
,
649 static struct analog_tuner_ops tda8295_tuner_ops
= {
653 .set_params
= tda8295_set_params
,
654 .has_signal
= tda8295_has_signal
,
655 .standby
= tda8295_standby
,
656 .release
= tda829x_release
,
657 .i2c_gate_ctrl
= tda8295_i2c_bridge
,
660 struct dvb_frontend
*tda829x_attach(struct dvb_frontend
*fe
,
661 struct i2c_adapter
*i2c_adap
, u8 i2c_addr
,
662 struct tda829x_config
*cfg
)
664 struct tda8290_priv
*priv
= NULL
;
667 priv
= kzalloc(sizeof(struct tda8290_priv
), GFP_KERNEL
);
670 fe
->analog_demod_priv
= priv
;
672 priv
->i2c_props
.addr
= i2c_addr
;
673 priv
->i2c_props
.adap
= i2c_adap
;
675 priv
->cfg
.config
= cfg
->lna_cfg
;
676 priv
->cfg
.tuner_callback
= cfg
->tuner_callback
;
679 if (tda8290_probe(&priv
->i2c_props
) == 0) {
681 fe
->ops
.analog_demod_ops
= &tda8290_tuner_ops
;
684 if (tda8295_probe(&priv
->i2c_props
) == 0) {
686 fe
->ops
.analog_demod_ops
= &tda8295_tuner_ops
;
689 if (tda829x_find_tuner(fe
) < 0)
693 case TDA8290
| TDA8275
:
696 case TDA8295
| TDA8275
:
699 case TDA8290
| TDA8275A
:
700 name
= "tda8290+75a";
702 case TDA8295
| TDA8275A
:
703 name
= "tda8295+75a";
705 case TDA8290
| TDA18271
:
706 name
= "tda8290+18271";
708 case TDA8295
| TDA18271
:
709 name
= "tda8295+18271";
714 tuner_info("type set to %s\n", name
);
716 if (priv
->ver
& TDA8290
) {
717 tda8290_init_tuner(fe
);
719 } else if (priv
->ver
& TDA8295
)
726 fe
->ops
.analog_demod_ops
= NULL
;
729 EXPORT_SYMBOL_GPL(tda829x_attach
);
731 int tda829x_probe(struct i2c_adapter
*i2c_adap
, u8 i2c_addr
)
733 struct tuner_i2c_props i2c_props
= {
738 unsigned char soft_reset
[] = { 0x00, 0x00 };
739 unsigned char easy_mode_b
[] = { 0x01, 0x02 };
740 unsigned char easy_mode_g
[] = { 0x01, 0x04 };
741 unsigned char restore_9886
[] = { 0x00, 0xd6, 0x30 };
742 unsigned char addr_dto_lsb
= 0x07;
744 #define PROBE_BUFFER_SIZE 8
745 unsigned char buf
[PROBE_BUFFER_SIZE
];
748 /* rule out tda9887, which would return the same byte repeatedly */
749 tuner_i2c_xfer_send(&i2c_props
, soft_reset
, 1);
750 tuner_i2c_xfer_recv(&i2c_props
, buf
, PROBE_BUFFER_SIZE
);
751 for (i
= 1; i
< PROBE_BUFFER_SIZE
; i
++) {
752 if (buf
[i
] != buf
[0])
756 /* all bytes are equal, not a tda829x - probably a tda9887 */
757 if (i
== PROBE_BUFFER_SIZE
)
760 if ((tda8290_probe(&i2c_props
) == 0) ||
761 (tda8295_probe(&i2c_props
) == 0))
764 /* fall back to old probing method */
765 tuner_i2c_xfer_send(&i2c_props
, easy_mode_b
, 2);
766 tuner_i2c_xfer_send(&i2c_props
, soft_reset
, 2);
767 tuner_i2c_xfer_send(&i2c_props
, &addr_dto_lsb
, 1);
768 tuner_i2c_xfer_recv(&i2c_props
, &data
, 1);
770 tuner_i2c_xfer_send(&i2c_props
, easy_mode_g
, 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);
778 tuner_i2c_xfer_send(&i2c_props
, restore_9886
, 3);
781 EXPORT_SYMBOL_GPL(tda829x_probe
);
783 MODULE_DESCRIPTION("Philips/NXP TDA8290/TDA8295 analog IF demodulator driver");
784 MODULE_AUTHOR("Gerd Knorr, Hartmut Hackmann, Michael Krufky");
785 MODULE_LICENSE("GPL");
788 * Overrides for Emacs so that we follow Linus's tabbing style.
789 * ---------------------------------------------------------------------------