projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
V4L/DVB (8036): tda18271: toggle rf agc speed mode on TDA18271HD/C2 only
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / common / tuners / tda18271-fe.c
1 /*
2 tda18271-fe.c - driver for the Philips / NXP TDA18271 silicon tuner
3
4 Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
5
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.
10
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.
15
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.
19 */
20
21 #include <linux/delay.h>
22 #include <linux/videodev2.h>
23 #include "tda18271-priv.h"
24
25 int tda18271_debug;
26 module_param_named(debug, tda18271_debug, int, 0644);
27 MODULE_PARM_DESC(debug, "set debug level "
28 "(info=1, map=2, reg=4, adv=8, cal=16 (or-able))");
29
30 static int tda18271_cal_on_startup;
31 module_param_named(cal, tda18271_cal_on_startup, int, 0644);
32 MODULE_PARM_DESC(cal, "perform RF tracking filter calibration on startup");
33
34 static DEFINE_MUTEX(tda18271_list_mutex);
35 static LIST_HEAD(hybrid_tuner_instance_list);
36
37 /*---------------------------------------------------------------------*/
38
39 static inline int charge_pump_source(struct dvb_frontend *fe, int force)
40 {
41 struct tda18271_priv *priv = fe->tuner_priv;
42 return tda18271_charge_pump_source(fe,
43 (priv->role == TDA18271_SLAVE) ?
44 TDA18271_CAL_PLL :
45 TDA18271_MAIN_PLL, force);
46 }
47
48 static inline void tda18271_set_if_notch(struct dvb_frontend *fe)
49 {
50 struct tda18271_priv *priv = fe->tuner_priv;
51 unsigned char *regs = priv->tda18271_regs;
52
53 switch (priv->mode) {
54 case TDA18271_ANALOG:
55 regs[R_MPD] &= ~0x80; /* IF notch = 0 */
56 break;
57 case TDA18271_DIGITAL:
58 regs[R_MPD] |= 0x80; /* IF notch = 1 */
59 break;
60 }
61 }
62
63 static int tda18271_channel_configuration(struct dvb_frontend *fe,
64 struct tda18271_std_map_item *map,
65 u32 freq, u32 bw)
66 {
67 struct tda18271_priv *priv = fe->tuner_priv;
68 unsigned char *regs = priv->tda18271_regs;
69 int ret;
70 u32 N;
71
72 /* update TV broadcast parameters */
73
74 /* set standard */
75 regs[R_EP3] &= ~0x1f; /* clear std bits */
76 regs[R_EP3] |= (map->agc_mode << 3) | map->std;
77
78 if (priv->id == TDA18271HDC2) {
79 /* set rfagc to high speed mode */
80 regs[R_EP3] &= ~0x04;
81 }
82
83 /* set cal mode to normal */
84 regs[R_EP4] &= ~0x03;
85
86 /* update IF output level */
87 regs[R_EP4] &= ~0x1c; /* clear if level bits */
88 regs[R_EP4] |= (map->if_lvl << 2);
89
90 /* update FM_RFn */
91 regs[R_EP4] &= ~0x80;
92 regs[R_EP4] |= map->fm_rfn << 7;
93
94 /* update rf top / if top */
95 regs[R_EB22] = 0x00;
96 regs[R_EB22] |= map->rfagc_top;
97 ret = tda18271_write_regs(fe, R_EB22, 1);
98 if (tda_fail(ret))
99 goto fail;
100
101 /* --------------------------------------------------------------- */
102
103 /* disable Power Level Indicator */
104 regs[R_EP1] |= 0x40;
105
106 /* frequency dependent parameters */
107
108 tda18271_calc_ir_measure(fe, &freq);
109
110 tda18271_calc_bp_filter(fe, &freq);
111
112 tda18271_calc_rf_band(fe, &freq);
113
114 tda18271_calc_gain_taper(fe, &freq);
115
116 /* --------------------------------------------------------------- */
117
118 /* dual tuner and agc1 extra configuration */
119
120 switch (priv->role) {
121 case TDA18271_MASTER:
122 regs[R_EB1] |= 0x04; /* main vco */
123 break;
124 case TDA18271_SLAVE:
125 regs[R_EB1] &= ~0x04; /* cal vco */
126 break;
127 }
128
129 /* agc1 always active */
130 regs[R_EB1] &= ~0x02;
131
132 /* agc1 has priority on agc2 */
133 regs[R_EB1] &= ~0x01;
134
135 ret = tda18271_write_regs(fe, R_EB1, 1);
136 if (tda_fail(ret))
137 goto fail;
138
139 /* --------------------------------------------------------------- */
140
141 N = map->if_freq * 1000 + freq;
142
143 switch (priv->role) {
144 case TDA18271_MASTER:
145 tda18271_calc_main_pll(fe, N);
146 tda18271_set_if_notch(fe);
147 tda18271_write_regs(fe, R_MPD, 4);
148 break;
149 case TDA18271_SLAVE:
150 tda18271_calc_cal_pll(fe, N);
151 tda18271_write_regs(fe, R_CPD, 4);
152
153 regs[R_MPD] = regs[R_CPD] & 0x7f;
154 tda18271_set_if_notch(fe);
155 tda18271_write_regs(fe, R_MPD, 1);
156 break;
157 }
158
159 ret = tda18271_write_regs(fe, R_TM, 7);
160 if (tda_fail(ret))
161 goto fail;
162
163 /* force charge pump source */
164 charge_pump_source(fe, 1);
165
166 msleep(1);
167
168 /* return pll to normal operation */
169 charge_pump_source(fe, 0);
170
171 msleep(20);
172
173 if (priv->id == TDA18271HDC2) {
174 /* set rfagc to normal speed mode */
175 if (map->fm_rfn)
176 regs[R_EP3] &= ~0x04;
177 else
178 regs[R_EP3] |= 0x04;
179 ret = tda18271_write_regs(fe, R_EP3, 1);
180 }
181 fail:
182 return ret;
183 }
184
185 static int tda18271_read_thermometer(struct dvb_frontend *fe)
186 {
187 struct tda18271_priv *priv = fe->tuner_priv;
188 unsigned char *regs = priv->tda18271_regs;
189 int tm;
190
191 /* switch thermometer on */
192 regs[R_TM] |= 0x10;
193 tda18271_write_regs(fe, R_TM, 1);
194
195 /* read thermometer info */
196 tda18271_read_regs(fe);
197
198 if ((((regs[R_TM] & 0x0f) == 0x00) && ((regs[R_TM] & 0x20) == 0x20)) ||
199 (((regs[R_TM] & 0x0f) == 0x08) && ((regs[R_TM] & 0x20) == 0x00))) {
200
201 if ((regs[R_TM] & 0x20) == 0x20)
202 regs[R_TM] &= ~0x20;
203 else
204 regs[R_TM] |= 0x20;
205
206 tda18271_write_regs(fe, R_TM, 1);
207
208 msleep(10); /* temperature sensing */
209
210 /* read thermometer info */
211 tda18271_read_regs(fe);
212 }
213
214 tm = tda18271_lookup_thermometer(fe);
215
216 /* switch thermometer off */
217 regs[R_TM] &= ~0x10;
218 tda18271_write_regs(fe, R_TM, 1);
219
220 /* set CAL mode to normal */
221 regs[R_EP4] &= ~0x03;
222 tda18271_write_regs(fe, R_EP4, 1);
223
224 return tm;
225 }
226
227 /* ------------------------------------------------------------------ */
228
229 static int tda18271c2_rf_tracking_filters_correction(struct dvb_frontend *fe,
230 u32 freq)
231 {
232 struct tda18271_priv *priv = fe->tuner_priv;
233 struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
234 unsigned char *regs = priv->tda18271_regs;
235 int tm_current, rfcal_comp, approx, i, ret;
236 u8 dc_over_dt, rf_tab;
237
238 /* power up */
239 ret = tda18271_set_standby_mode(fe, 0, 0, 0);
240 if (tda_fail(ret))
241 goto fail;
242
243 /* read die current temperature */
244 tm_current = tda18271_read_thermometer(fe);
245
246 /* frequency dependent parameters */
247
248 tda18271_calc_rf_cal(fe, &freq);
249 rf_tab = regs[R_EB14];
250
251 i = tda18271_lookup_rf_band(fe, &freq, NULL);
252 if (tda_fail(i))
253 return i;
254
255 if ((0 == map[i].rf3) || (freq / 1000 < map[i].rf2)) {
256 approx = map[i].rf_a1 *
257 (freq / 1000 - map[i].rf1) + map[i].rf_b1 + rf_tab;
258 } else {
259 approx = map[i].rf_a2 *
260 (freq / 1000 - map[i].rf2) + map[i].rf_b2 + rf_tab;
261 }
262
263 if (approx < 0)
264 approx = 0;
265 if (approx > 255)
266 approx = 255;
267
268 tda18271_lookup_map(fe, RF_CAL_DC_OVER_DT, &freq, &dc_over_dt);
269
270 /* calculate temperature compensation */
271 rfcal_comp = dc_over_dt * (tm_current - priv->tm_rfcal);
272
273 regs[R_EB14] = approx + rfcal_comp;
274 ret = tda18271_write_regs(fe, R_EB14, 1);
275 fail:
276 return ret;
277 }
278
279 static int tda18271_por(struct dvb_frontend *fe)
280 {
281 struct tda18271_priv *priv = fe->tuner_priv;
282 unsigned char *regs = priv->tda18271_regs;
283 int ret;
284
285 /* power up detector 1 */
286 regs[R_EB12] &= ~0x20;
287 ret = tda18271_write_regs(fe, R_EB12, 1);
288 if (tda_fail(ret))
289 goto fail;
290
291 regs[R_EB18] &= ~0x80; /* turn agc1 loop on */
292 regs[R_EB18] &= ~0x03; /* set agc1_gain to 6 dB */
293 ret = tda18271_write_regs(fe, R_EB18, 1);
294 if (tda_fail(ret))
295 goto fail;
296
297 regs[R_EB21] |= 0x03; /* set agc2_gain to -6 dB */
298
299 /* POR mode */
300 ret = tda18271_set_standby_mode(fe, 1, 0, 0);
301 if (tda_fail(ret))
302 goto fail;
303
304 /* disable 1.5 MHz low pass filter */
305 regs[R_EB23] &= ~0x04; /* forcelp_fc2_en = 0 */
306 regs[R_EB23] &= ~0x02; /* XXX: lp_fc[2] = 0 */
307 ret = tda18271_write_regs(fe, R_EB21, 3);
308 fail:
309 return ret;
310 }
311
312 static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq)
313 {
314 struct tda18271_priv *priv = fe->tuner_priv;
315 unsigned char *regs = priv->tda18271_regs;
316 u32 N;
317
318 /* set CAL mode to normal */
319 regs[R_EP4] &= ~0x03;
320 tda18271_write_regs(fe, R_EP4, 1);
321
322 /* switch off agc1 */
323 regs[R_EP3] |= 0x40; /* sm_lt = 1 */
324
325 regs[R_EB18] |= 0x03; /* set agc1_gain to 15 dB */
326 tda18271_write_regs(fe, R_EB18, 1);
327
328 /* frequency dependent parameters */
329
330 tda18271_calc_bp_filter(fe, &freq);
331 tda18271_calc_gain_taper(fe, &freq);
332 tda18271_calc_rf_band(fe, &freq);
333 tda18271_calc_km(fe, &freq);
334
335 tda18271_write_regs(fe, R_EP1, 3);
336 tda18271_write_regs(fe, R_EB13, 1);
337
338 /* main pll charge pump source */
339 tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
340
341 /* cal pll charge pump source */
342 tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 1);
343
344 /* force dcdc converter to 0 V */
345 regs[R_EB14] = 0x00;
346 tda18271_write_regs(fe, R_EB14, 1);
347
348 /* disable plls lock */
349 regs[R_EB20] &= ~0x20;
350 tda18271_write_regs(fe, R_EB20, 1);
351
352 /* set CAL mode to RF tracking filter calibration */
353 regs[R_EP4] |= 0x03;
354 tda18271_write_regs(fe, R_EP4, 2);
355
356 /* --------------------------------------------------------------- */
357
358 /* set the internal calibration signal */
359 N = freq;
360
361 tda18271_calc_cal_pll(fe, N);
362 tda18271_write_regs(fe, R_CPD, 4);
363
364 /* downconvert internal calibration */
365 N += 1000000;
366
367 tda18271_calc_main_pll(fe, N);
368 tda18271_write_regs(fe, R_MPD, 4);
369
370 msleep(5);
371
372 tda18271_write_regs(fe, R_EP2, 1);
373 tda18271_write_regs(fe, R_EP1, 1);
374 tda18271_write_regs(fe, R_EP2, 1);
375 tda18271_write_regs(fe, R_EP1, 1);
376
377 /* --------------------------------------------------------------- */
378
379 /* normal operation for the main pll */
380 tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
381
382 /* normal operation for the cal pll */
383 tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 0);
384
385 msleep(10); /* plls locking */
386
387 /* launch the rf tracking filters calibration */
388 regs[R_EB20] |= 0x20;
389 tda18271_write_regs(fe, R_EB20, 1);
390
391 msleep(60); /* calibration */
392
393 /* --------------------------------------------------------------- */
394
395 /* set CAL mode to normal */
396 regs[R_EP4] &= ~0x03;
397
398 /* switch on agc1 */
399 regs[R_EP3] &= ~0x40; /* sm_lt = 0 */
400
401 regs[R_EB18] &= ~0x03; /* set agc1_gain to 6 dB */
402 tda18271_write_regs(fe, R_EB18, 1);
403
404 tda18271_write_regs(fe, R_EP3, 2);
405
406 /* synchronization */
407 tda18271_write_regs(fe, R_EP1, 1);
408
409 /* get calibration result */
410 tda18271_read_extended(fe);
411
412 return regs[R_EB14];
413 }
414
415 static int tda18271_powerscan(struct dvb_frontend *fe,
416 u32 *freq_in, u32 *freq_out)
417 {
418 struct tda18271_priv *priv = fe->tuner_priv;
419 unsigned char *regs = priv->tda18271_regs;
420 int sgn, bcal, count, wait, ret;
421 u8 cid_target;
422 u16 count_limit;
423 u32 freq;
424
425 freq = *freq_in;
426
427 tda18271_calc_rf_band(fe, &freq);
428 tda18271_calc_rf_cal(fe, &freq);
429 tda18271_calc_gain_taper(fe, &freq);
430 tda18271_lookup_cid_target(fe, &freq, &cid_target, &count_limit);
431
432 tda18271_write_regs(fe, R_EP2, 1);
433 tda18271_write_regs(fe, R_EB14, 1);
434
435 /* downconvert frequency */
436 freq += 1000000;
437
438 tda18271_calc_main_pll(fe, freq);
439 tda18271_write_regs(fe, R_MPD, 4);
440
441 msleep(5); /* pll locking */
442
443 /* detection mode */
444 regs[R_EP4] &= ~0x03;
445 regs[R_EP4] |= 0x01;
446 tda18271_write_regs(fe, R_EP4, 1);
447
448 /* launch power detection measurement */
449 tda18271_write_regs(fe, R_EP2, 1);
450
451 /* read power detection info, stored in EB10 */
452 ret = tda18271_read_extended(fe);
453 if (tda_fail(ret))
454 return ret;
455
456 /* algorithm initialization */
457 sgn = 1;
458 *freq_out = *freq_in;
459 bcal = 0;
460 count = 0;
461 wait = false;
462
463 while ((regs[R_EB10] & 0x3f) < cid_target) {
464 /* downconvert updated freq to 1 MHz */
465 freq = *freq_in + (sgn * count) + 1000000;
466
467 tda18271_calc_main_pll(fe, freq);
468 tda18271_write_regs(fe, R_MPD, 4);
469
470 if (wait) {
471 msleep(5); /* pll locking */
472 wait = false;
473 } else
474 udelay(100); /* pll locking */
475
476 /* launch power detection measurement */
477 tda18271_write_regs(fe, R_EP2, 1);
478
479 /* read power detection info, stored in EB10 */
480 ret = tda18271_read_extended(fe);
481 if (tda_fail(ret))
482 return ret;
483
484 count += 200;
485
486 if (count <= count_limit)
487 continue;
488
489 if (sgn <= 0)
490 break;
491
492 sgn = -1 * sgn;
493 count = 200;
494 wait = true;
495 }
496
497 if ((regs[R_EB10] & 0x3f) >= cid_target) {
498 bcal = 1;
499 *freq_out = freq - 1000000;
500 } else
501 bcal = 0;
502
503 tda_cal("bcal = %d, freq_in = %d, freq_out = %d (freq = %d)\n",
504 bcal, *freq_in, *freq_out, freq);
505
506 return bcal;
507 }
508
509 static int tda18271_powerscan_init(struct dvb_frontend *fe)
510 {
511 struct tda18271_priv *priv = fe->tuner_priv;
512 unsigned char *regs = priv->tda18271_regs;
513 int ret;
514
515 /* set standard to digital */
516 regs[R_EP3] &= ~0x1f; /* clear std bits */
517 regs[R_EP3] |= 0x12;
518
519 /* set cal mode to normal */
520 regs[R_EP4] &= ~0x03;
521
522 /* update IF output level */
523 regs[R_EP4] &= ~0x1c; /* clear if level bits */
524
525 ret = tda18271_write_regs(fe, R_EP3, 2);
526 if (tda_fail(ret))
527 goto fail;
528
529 regs[R_EB18] &= ~0x03; /* set agc1_gain to 6 dB */
530 ret = tda18271_write_regs(fe, R_EB18, 1);
531 if (tda_fail(ret))
532 goto fail;
533
534 regs[R_EB21] &= ~0x03; /* set agc2_gain to -15 dB */
535
536 /* 1.5 MHz low pass filter */
537 regs[R_EB23] |= 0x04; /* forcelp_fc2_en = 1 */
538 regs[R_EB23] |= 0x02; /* lp_fc[2] = 1 */
539
540 ret = tda18271_write_regs(fe, R_EB21, 3);
541 fail:
542 return ret;
543 }
544
545 static int tda18271_rf_tracking_filters_init(struct dvb_frontend *fe, u32 freq)
546 {
547 struct tda18271_priv *priv = fe->tuner_priv;
548 struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
549 unsigned char *regs = priv->tda18271_regs;
550 int bcal, rf, i;
551 #define RF1 0
552 #define RF2 1
553 #define RF3 2
554 u32 rf_default[3];
555 u32 rf_freq[3];
556 u8 prog_cal[3];
557 u8 prog_tab[3];
558
559 i = tda18271_lookup_rf_band(fe, &freq, NULL);
560
561 if (tda_fail(i))
562 return i;
563
564 rf_default[RF1] = 1000 * map[i].rf1_def;
565 rf_default[RF2] = 1000 * map[i].rf2_def;
566 rf_default[RF3] = 1000 * map[i].rf3_def;
567
568 for (rf = RF1; rf <= RF3; rf++) {
569 if (0 == rf_default[rf])
570 return 0;
571 tda_cal("freq = %d, rf = %d\n", freq, rf);
572
573 /* look for optimized calibration frequency */
574 bcal = tda18271_powerscan(fe, &rf_default[rf], &rf_freq[rf]);
575 if (tda_fail(bcal))
576 return bcal;
577
578 tda18271_calc_rf_cal(fe, &rf_freq[rf]);
579 prog_tab[rf] = regs[R_EB14];
580
581 if (1 == bcal)
582 prog_cal[rf] = tda18271_calibrate_rf(fe, rf_freq[rf]);
583 else
584 prog_cal[rf] = prog_tab[rf];
585
586 switch (rf) {
587 case RF1:
588 map[i].rf_a1 = 0;
589 map[i].rf_b1 = prog_cal[RF1] - prog_tab[RF1];
590 map[i].rf1 = rf_freq[RF1] / 1000;
591 break;
592 case RF2:
593 map[i].rf_a1 = (prog_cal[RF2] - prog_tab[RF2] -
594 prog_cal[RF1] + prog_tab[RF1]) /
595 ((rf_freq[RF2] - rf_freq[RF1]) / 1000);
596 map[i].rf2 = rf_freq[RF2] / 1000;
597 break;
598 case RF3:
599 map[i].rf_a2 = (prog_cal[RF3] - prog_tab[RF3] -
600 prog_cal[RF2] + prog_tab[RF2]) /
601 ((rf_freq[RF3] - rf_freq[RF2]) / 1000);
602 map[i].rf_b2 = prog_cal[RF2] - prog_tab[RF2];
603 map[i].rf3 = rf_freq[RF3] / 1000;
604 break;
605 default:
606 BUG();
607 }
608 }
609
610 return 0;
611 }
612
613 static int tda18271_calc_rf_filter_curve(struct dvb_frontend *fe)
614 {
615 struct tda18271_priv *priv = fe->tuner_priv;
616 unsigned int i;
617 int ret;
618
619 tda_info("tda18271: performing RF tracking filter calibration\n");
620
621 /* wait for die temperature stabilization */
622 msleep(200);
623
624 ret = tda18271_powerscan_init(fe);
625 if (tda_fail(ret))
626 goto fail;
627
628 /* rf band calibration */
629 for (i = 0; priv->rf_cal_state[i].rfmax != 0; i++) {
630 ret =
631 tda18271_rf_tracking_filters_init(fe, 1000 *
632 priv->rf_cal_state[i].rfmax);
633 if (tda_fail(ret))
634 goto fail;
635 }
636
637 priv->tm_rfcal = tda18271_read_thermometer(fe);
638 fail:
639 return ret;
640 }
641
642 /* ------------------------------------------------------------------ */
643
644 static int tda18271c2_rf_cal_init(struct dvb_frontend *fe)
645 {
646 struct tda18271_priv *priv = fe->tuner_priv;
647 unsigned char *regs = priv->tda18271_regs;
648 int ret;
649
650 /* test RF_CAL_OK to see if we need init */
651 if ((regs[R_EP1] & 0x10) == 0)
652 priv->cal_initialized = false;
653
654 if (priv->cal_initialized)
655 return 0;
656
657 ret = tda18271_calc_rf_filter_curve(fe);
658 if (tda_fail(ret))
659 goto fail;
660
661 ret = tda18271_por(fe);
662 if (tda_fail(ret))
663 goto fail;
664
665 tda_info("tda18271: RF tracking filter calibration complete\n");
666
667 priv->cal_initialized = true;
668 goto end;
669 fail:
670 tda_info("tda18271: RF tracking filter calibration failed!\n");
671 end:
672 return ret;
673 }
674
675 static int tda18271c1_rf_tracking_filter_calibration(struct dvb_frontend *fe,
676 u32 freq, u32 bw)
677 {
678 struct tda18271_priv *priv = fe->tuner_priv;
679 unsigned char *regs = priv->tda18271_regs;
680 int ret;
681 u32 N = 0;
682
683 /* calculate bp filter */
684 tda18271_calc_bp_filter(fe, &freq);
685 tda18271_write_regs(fe, R_EP1, 1);
686
687 regs[R_EB4] &= 0x07;
688 regs[R_EB4] |= 0x60;
689 tda18271_write_regs(fe, R_EB4, 1);
690
691 regs[R_EB7] = 0x60;
692 tda18271_write_regs(fe, R_EB7, 1);
693
694 regs[R_EB14] = 0x00;
695 tda18271_write_regs(fe, R_EB14, 1);
696
697 regs[R_EB20] = 0xcc;
698 tda18271_write_regs(fe, R_EB20, 1);
699
700 /* set cal mode to RF tracking filter calibration */
701 regs[R_EP4] |= 0x03;
702
703 /* calculate cal pll */
704
705 switch (priv->mode) {
706 case TDA18271_ANALOG:
707 N = freq - 1250000;
708 break;
709 case TDA18271_DIGITAL:
710 N = freq + bw / 2;
711 break;
712 }
713
714 tda18271_calc_cal_pll(fe, N);
715
716 /* calculate main pll */
717
718 switch (priv->mode) {
719 case TDA18271_ANALOG:
720 N = freq - 250000;
721 break;
722 case TDA18271_DIGITAL:
723 N = freq + bw / 2 + 1000000;
724 break;
725 }
726
727 tda18271_calc_main_pll(fe, N);
728
729 ret = tda18271_write_regs(fe, R_EP3, 11);
730 if (tda_fail(ret))
731 return ret;
732
733 msleep(5); /* RF tracking filter calibration initialization */
734
735 /* search for K,M,CO for RF calibration */
736 tda18271_calc_km(fe, &freq);
737 tda18271_write_regs(fe, R_EB13, 1);
738
739 /* search for rf band */
740 tda18271_calc_rf_band(fe, &freq);
741
742 /* search for gain taper */
743 tda18271_calc_gain_taper(fe, &freq);
744
745 tda18271_write_regs(fe, R_EP2, 1);
746 tda18271_write_regs(fe, R_EP1, 1);
747 tda18271_write_regs(fe, R_EP2, 1);
748 tda18271_write_regs(fe, R_EP1, 1);
749
750 regs[R_EB4] &= 0x07;
751 regs[R_EB4] |= 0x40;
752 tda18271_write_regs(fe, R_EB4, 1);
753
754 regs[R_EB7] = 0x40;
755 tda18271_write_regs(fe, R_EB7, 1);
756 msleep(10); /* pll locking */
757
758 regs[R_EB20] = 0xec;
759 tda18271_write_regs(fe, R_EB20, 1);
760 msleep(60); /* RF tracking filter calibration completion */
761
762 regs[R_EP4] &= ~0x03; /* set cal mode to normal */
763 tda18271_write_regs(fe, R_EP4, 1);
764
765 tda18271_write_regs(fe, R_EP1, 1);
766
767 /* RF tracking filter correction for VHF_Low band */
768 if (0 == tda18271_calc_rf_cal(fe, &freq))
769 tda18271_write_regs(fe, R_EB14, 1);
770
771 return 0;
772 }
773
774 /* ------------------------------------------------------------------ */
775
776 static int tda18271_ir_cal_init(struct dvb_frontend *fe)
777 {
778 struct tda18271_priv *priv = fe->tuner_priv;
779 unsigned char *regs = priv->tda18271_regs;
780 int ret;
781
782 ret = tda18271_read_regs(fe);
783 if (tda_fail(ret))
784 goto fail;
785
786 /* test IR_CAL_OK to see if we need init */
787 if ((regs[R_EP1] & 0x08) == 0)
788 ret = tda18271_init_regs(fe);
789 fail:
790 return ret;
791 }
792
793 static int tda18271_init(struct dvb_frontend *fe)
794 {
795 struct tda18271_priv *priv = fe->tuner_priv;
796 int ret;
797
798 mutex_lock(&priv->lock);
799
800 /* power up */
801 ret = tda18271_set_standby_mode(fe, 0, 0, 0);
802 if (tda_fail(ret))
803 goto fail;
804
805 /* initialization */
806 ret = tda18271_ir_cal_init(fe);
807 if (tda_fail(ret))
808 goto fail;
809
810 if (priv->id == TDA18271HDC2)
811 tda18271c2_rf_cal_init(fe);
812 fail:
813 mutex_unlock(&priv->lock);
814
815 return ret;
816 }
817
818 static int tda18271_tune(struct dvb_frontend *fe,
819 struct tda18271_std_map_item *map, u32 freq, u32 bw)
820 {
821 struct tda18271_priv *priv = fe->tuner_priv;
822 int ret;
823
824 tda_dbg("freq = %d, ifc = %d, bw = %d, agc_mode = %d, std = %d\n",
825 freq, map->if_freq, bw, map->agc_mode, map->std);
826
827 ret = tda18271_init(fe);
828 if (tda_fail(ret))
829 goto fail;
830
831 mutex_lock(&priv->lock);
832
833 switch (priv->id) {
834 case TDA18271HDC1:
835 tda18271c1_rf_tracking_filter_calibration(fe, freq, bw);
836 break;
837 case TDA18271HDC2:
838 tda18271c2_rf_tracking_filters_correction(fe, freq);
839 break;
840 }
841 ret = tda18271_channel_configuration(fe, map, freq, bw);
842
843 mutex_unlock(&priv->lock);
844 fail:
845 return ret;
846 }
847
848 /* ------------------------------------------------------------------ */
849
850 static int tda18271_set_params(struct dvb_frontend *fe,
851 struct dvb_frontend_parameters *params)
852 {
853 struct tda18271_priv *priv = fe->tuner_priv;
854 struct tda18271_std_map *std_map = &priv->std;
855 struct tda18271_std_map_item *map;
856 int ret;
857 u32 bw, freq = params->frequency;
858
859 priv->mode = TDA18271_DIGITAL;
860
861 if (fe->ops.info.type == FE_ATSC) {
862 switch (params->u.vsb.modulation) {
863 case VSB_8:
864 case VSB_16:
865 map = &std_map->atsc_6;
866 break;
867 case QAM_64:
868 case QAM_256:
869 map = &std_map->qam_6;
870 break;
871 default:
872 tda_warn("modulation not set!\n");
873 return -EINVAL;
874 }
875 #if 0
876 /* userspace request is already center adjusted */
877 freq += 1750000; /* Adjust to center (+1.75MHZ) */
878 #endif
879 bw = 6000000;
880 } else if (fe->ops.info.type == FE_OFDM) {
881 switch (params->u.ofdm.bandwidth) {
882 case BANDWIDTH_6_MHZ:
883 bw = 6000000;
884 map = &std_map->dvbt_6;
885 break;
886 case BANDWIDTH_7_MHZ:
887 bw = 7000000;
888 map = &std_map->dvbt_7;
889 break;
890 case BANDWIDTH_8_MHZ:
891 bw = 8000000;
892 map = &std_map->dvbt_8;
893 break;
894 default:
895 tda_warn("bandwidth not set!\n");
896 return -EINVAL;
897 }
898 } else {
899 tda_warn("modulation type not supported!\n");
900 return -EINVAL;
901 }
902
903 /* When tuning digital, the analog demod must be tri-stated */
904 if (fe->ops.analog_ops.standby)
905 fe->ops.analog_ops.standby(fe);
906
907 ret = tda18271_tune(fe, map, freq, bw);
908
909 if (tda_fail(ret))
910 goto fail;
911
912 priv->frequency = freq;
913 priv->bandwidth = (fe->ops.info.type == FE_OFDM) ?
914 params->u.ofdm.bandwidth : 0;
915 fail:
916 return ret;
917 }
918
919 static int tda18271_set_analog_params(struct dvb_frontend *fe,
920 struct analog_parameters *params)
921 {
922 struct tda18271_priv *priv = fe->tuner_priv;
923 struct tda18271_std_map *std_map = &priv->std;
924 struct tda18271_std_map_item *map;
925 char *mode;
926 int ret;
927 u32 freq = params->frequency * 62500;
928
929 priv->mode = TDA18271_ANALOG;
930
931 if (params->mode == V4L2_TUNER_RADIO) {
932 freq = freq / 1000;
933 map = &std_map->fm_radio;
934 mode = "fm";
935 } else if (params->std & V4L2_STD_MN) {
936 map = &std_map->atv_mn;
937 mode = "MN";
938 } else if (params->std & V4L2_STD_B) {
939 map = &std_map->atv_b;
940 mode = "B";
941 } else if (params->std & V4L2_STD_GH) {
942 map = &std_map->atv_gh;
943 mode = "GH";
944 } else if (params->std & V4L2_STD_PAL_I) {
945 map = &std_map->atv_i;
946 mode = "I";
947 } else if (params->std & V4L2_STD_DK) {
948 map = &std_map->atv_dk;
949 mode = "DK";
950 } else if (params->std & V4L2_STD_SECAM_L) {
951 map = &std_map->atv_l;
952 mode = "L";
953 } else if (params->std & V4L2_STD_SECAM_LC) {
954 map = &std_map->atv_lc;
955 mode = "L'";
956 } else {
957 map = &std_map->atv_i;
958 mode = "xx";
959 }
960
961 tda_dbg("setting tda18271 to system %s\n", mode);
962
963 ret = tda18271_tune(fe, map, freq, 0);
964
965 if (tda_fail(ret))
966 goto fail;
967
968 priv->frequency = freq;
969 priv->bandwidth = 0;
970 fail:
971 return ret;
972 }
973
974 static int tda18271_sleep(struct dvb_frontend *fe)
975 {
976 struct tda18271_priv *priv = fe->tuner_priv;
977 int ret;
978
979 mutex_lock(&priv->lock);
980
981 /* standby mode w/ slave tuner output
982 * & loop thru & xtal oscillator on */
983 ret = tda18271_set_standby_mode(fe, 1, 0, 0);
984
985 mutex_unlock(&priv->lock);
986
987 return ret;
988 }
989
990 static int tda18271_release(struct dvb_frontend *fe)
991 {
992 struct tda18271_priv *priv = fe->tuner_priv;
993
994 mutex_lock(&tda18271_list_mutex);
995
996 if (priv)
997 hybrid_tuner_release_state(priv);
998
999 mutex_unlock(&tda18271_list_mutex);
1000
1001 fe->tuner_priv = NULL;
1002
1003 return 0;
1004 }
1005
1006 static int tda18271_get_frequency(struct dvb_frontend *fe, u32 *frequency)
1007 {
1008 struct tda18271_priv *priv = fe->tuner_priv;
1009 *frequency = priv->frequency;
1010 return 0;
1011 }
1012
1013 static int tda18271_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
1014 {
1015 struct tda18271_priv *priv = fe->tuner_priv;
1016 *bandwidth = priv->bandwidth;
1017 return 0;
1018 }
1019
1020 /* ------------------------------------------------------------------ */
1021
1022 #define tda18271_update_std(std_cfg, name) do { \
1023 if (map->std_cfg.if_freq + \
1024 map->std_cfg.agc_mode + map->std_cfg.std + \
1025 map->std_cfg.if_lvl + map->std_cfg.rfagc_top > 0) { \
1026 tda_dbg("Using custom std config for %s\n", name); \
1027 memcpy(&std->std_cfg, &map->std_cfg, \
1028 sizeof(struct tda18271_std_map_item)); \
1029 } } while (0)
1030
1031 #define tda18271_dump_std_item(std_cfg, name) do { \
1032 tda_dbg("(%s) if_freq = %d, agc_mode = %d, std = %d, " \
1033 "if_lvl = %d, rfagc_top = 0x%02x\n", \
1034 name, std->std_cfg.if_freq, \
1035 std->std_cfg.agc_mode, std->std_cfg.std, \
1036 std->std_cfg.if_lvl, std->std_cfg.rfagc_top); \
1037 } while (0)
1038
1039 static int tda18271_dump_std_map(struct dvb_frontend *fe)
1040 {
1041 struct tda18271_priv *priv = fe->tuner_priv;
1042 struct tda18271_std_map *std = &priv->std;
1043
1044 tda_dbg("========== STANDARD MAP SETTINGS ==========\n");
1045 tda18271_dump_std_item(fm_radio, " fm ");
1046 tda18271_dump_std_item(atv_b, "atv b ");
1047 tda18271_dump_std_item(atv_dk, "atv dk");
1048 tda18271_dump_std_item(atv_gh, "atv gh");
1049 tda18271_dump_std_item(atv_i, "atv i ");
1050 tda18271_dump_std_item(atv_l, "atv l ");
1051 tda18271_dump_std_item(atv_lc, "atv l'");
1052 tda18271_dump_std_item(atv_mn, "atv mn");
1053 tda18271_dump_std_item(atsc_6, "atsc 6");
1054 tda18271_dump_std_item(dvbt_6, "dvbt 6");
1055 tda18271_dump_std_item(dvbt_7, "dvbt 7");
1056 tda18271_dump_std_item(dvbt_8, "dvbt 8");
1057 tda18271_dump_std_item(qam_6, "qam 6 ");
1058 tda18271_dump_std_item(qam_8, "qam 8 ");
1059
1060 return 0;
1061 }
1062
1063 static int tda18271_update_std_map(struct dvb_frontend *fe,
1064 struct tda18271_std_map *map)
1065 {
1066 struct tda18271_priv *priv = fe->tuner_priv;
1067 struct tda18271_std_map *std = &priv->std;
1068
1069 if (!map)
1070 return -EINVAL;
1071
1072 tda18271_update_std(fm_radio, "fm");
1073 tda18271_update_std(atv_b, "atv b");
1074 tda18271_update_std(atv_dk, "atv dk");
1075 tda18271_update_std(atv_gh, "atv gh");
1076 tda18271_update_std(atv_i, "atv i");
1077 tda18271_update_std(atv_l, "atv l");
1078 tda18271_update_std(atv_lc, "atv l'");
1079 tda18271_update_std(atv_mn, "atv mn");
1080 tda18271_update_std(atsc_6, "atsc 6");
1081 tda18271_update_std(dvbt_6, "dvbt 6");
1082 tda18271_update_std(dvbt_7, "dvbt 7");
1083 tda18271_update_std(dvbt_8, "dvbt 8");
1084 tda18271_update_std(qam_6, "qam 6");
1085 tda18271_update_std(qam_8, "qam 8");
1086
1087 return 0;
1088 }
1089
1090 static int tda18271_get_id(struct dvb_frontend *fe)
1091 {
1092 struct tda18271_priv *priv = fe->tuner_priv;
1093 unsigned char *regs = priv->tda18271_regs;
1094 char *name;
1095 int ret = 0;
1096
1097 mutex_lock(&priv->lock);
1098 tda18271_read_regs(fe);
1099 mutex_unlock(&priv->lock);
1100
1101 switch (regs[R_ID] & 0x7f) {
1102 case 3:
1103 name = "TDA18271HD/C1";
1104 priv->id = TDA18271HDC1;
1105 break;
1106 case 4:
1107 name = "TDA18271HD/C2";
1108 priv->id = TDA18271HDC2;
1109 break;
1110 default:
1111 name = "Unknown device";
1112 ret = -EINVAL;
1113 break;
1114 }
1115
1116 tda_info("%s detected @ %d-%04x%s\n", name,
1117 i2c_adapter_id(priv->i2c_props.adap),
1118 priv->i2c_props.addr,
1119 (0 == ret) ? "" : ", device not supported.");
1120
1121 return ret;
1122 }
1123
1124 static struct dvb_tuner_ops tda18271_tuner_ops = {
1125 .info = {
1126 .name = "NXP TDA18271HD",
1127 .frequency_min = 45000000,
1128 .frequency_max = 864000000,
1129 .frequency_step = 62500
1130 },
1131 .init = tda18271_init,
1132 .sleep = tda18271_sleep,
1133 .set_params = tda18271_set_params,
1134 .set_analog_params = tda18271_set_analog_params,
1135 .release = tda18271_release,
1136 .get_frequency = tda18271_get_frequency,
1137 .get_bandwidth = tda18271_get_bandwidth,
1138 };
1139
1140 struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
1141 struct i2c_adapter *i2c,
1142 struct tda18271_config *cfg)
1143 {
1144 struct tda18271_priv *priv = NULL;
1145 int instance;
1146
1147 mutex_lock(&tda18271_list_mutex);
1148
1149 instance = hybrid_tuner_request_state(struct tda18271_priv, priv,
1150 hybrid_tuner_instance_list,
1151 i2c, addr, "tda18271");
1152 switch (instance) {
1153 case 0:
1154 goto fail;
1155 break;
1156 case 1:
1157 /* new tuner instance */
1158 priv->gate = (cfg) ? cfg->gate : TDA18271_GATE_AUTO;
1159 priv->role = (cfg) ? cfg->role : TDA18271_MASTER;
1160 priv->cal_initialized = false;
1161 mutex_init(&priv->lock);
1162
1163 fe->tuner_priv = priv;
1164
1165 if (cfg)
1166 priv->small_i2c = cfg->small_i2c;
1167
1168 if (tda_fail(tda18271_get_id(fe)))
1169 goto fail;
1170
1171 if (tda_fail(tda18271_assign_map_layout(fe)))
1172 goto fail;
1173
1174 mutex_lock(&priv->lock);
1175 tda18271_init_regs(fe);
1176
1177 if ((tda18271_cal_on_startup) && (priv->id == TDA18271HDC2))
1178 tda18271c2_rf_cal_init(fe);
1179
1180 mutex_unlock(&priv->lock);
1181 break;
1182 default:
1183 /* existing tuner instance */
1184 fe->tuner_priv = priv;
1185
1186 /* allow dvb driver to override i2c gate setting */
1187 if ((cfg) && (cfg->gate != TDA18271_GATE_ANALOG))
1188 priv->gate = cfg->gate;
1189 break;
1190 }
1191
1192 /* override default std map with values in config struct */
1193 if ((cfg) && (cfg->std_map))
1194 tda18271_update_std_map(fe, cfg->std_map);
1195
1196 mutex_unlock(&tda18271_list_mutex);
1197
1198 memcpy(&fe->ops.tuner_ops, &tda18271_tuner_ops,
1199 sizeof(struct dvb_tuner_ops));
1200
1201 if (tda18271_debug & (DBG_MAP | DBG_ADV))
1202 tda18271_dump_std_map(fe);
1203
1204 return fe;
1205 fail:
1206 mutex_unlock(&tda18271_list_mutex);
1207
1208 tda18271_release(fe);
1209 return NULL;
1210 }
1211 EXPORT_SYMBOL_GPL(tda18271_attach);
1212 MODULE_DESCRIPTION("NXP TDA18271HD analog / digital tuner driver");
1213 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1214 MODULE_LICENSE("GPL");
1215 MODULE_VERSION("0.3");
1216
1217 /*
1218 * Overrides for Emacs so that we follow Linus's tabbing style.
1219 * ---------------------------------------------------------------------------
1220 * Local variables:
1221 * c-basic-offset: 8
1222 * End:
1223 */
kernel source for telekom puls (alcatel/mediatek)