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