projects / deliverable / linux.git / blob
? search:


7bc28421752755eabf57bbd114865e92191986c1
[deliverable/linux.git] / drivers / media / dvb / frontends / lg2160.c
1 /*
2 * Support for LG2160 - ATSC/MH
3 *
4 * Copyright (C) 2010 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
22 #include <linux/jiffies.h>
23 #include <linux/dvb/frontend.h>
24 #include "lg2160.h"
25
26 static int debug;
27 module_param(debug, int, 0644);
28 MODULE_PARM_DESC(debug, "set debug level (info=1, reg=2 (or-able))");
29
30 #define DBG_INFO 1
31 #define DBG_REG 2
32
33 #define lg_printk(kern, fmt, arg...) \
34 printk(kern "%s: " fmt, __func__, ##arg)
35
36 #define lg_info(fmt, arg...) printk(KERN_INFO "lg2160: " fmt, ##arg)
37 #define lg_warn(fmt, arg...) lg_printk(KERN_WARNING, fmt, ##arg)
38 #define lg_err(fmt, arg...) lg_printk(KERN_ERR, fmt, ##arg)
39 #define lg_dbg(fmt, arg...) if (debug & DBG_INFO) \
40 lg_printk(KERN_DEBUG, fmt, ##arg)
41 #define lg_reg(fmt, arg...) if (debug & DBG_REG) \
42 lg_printk(KERN_DEBUG, fmt, ##arg)
43
44 #define lg_fail(ret) \
45 ({ \
46 int __ret; \
47 __ret = (ret < 0); \
48 if (__ret) \
49 lg_err("error %d on line %d\n", ret, __LINE__); \
50 __ret; \
51 })
52
53 struct lg216x_state {
54 struct i2c_adapter *i2c_adap;
55 const struct lg2160_config *cfg;
56
57 struct dvb_frontend frontend;
58
59 u32 current_frequency;
60 u8 parade_id;
61 u8 fic_ver;
62 unsigned int last_reset;
63 };
64
65 /* ------------------------------------------------------------------------ */
66
67 static int lg216x_write_reg(struct lg216x_state *state, u16 reg, u8 val)
68 {
69 int ret;
70 u8 buf[] = { reg >> 8, reg & 0xff, val };
71 struct i2c_msg msg = {
72 .addr = state->cfg->i2c_addr, .flags = 0,
73 .buf = buf, .len = 3,
74 };
75
76 lg_reg("reg: 0x%04x, val: 0x%02x\n", reg, val);
77
78 ret = i2c_transfer(state->i2c_adap, &msg, 1);
79
80 if (ret != 1) {
81 lg_err("error (addr %02x %02x <- %02x, err = %i)\n",
82 msg.buf[0], msg.buf[1], msg.buf[2], ret);
83 if (ret < 0)
84 return ret;
85 else
86 return -EREMOTEIO;
87 }
88 return 0;
89 }
90
91 static int lg216x_read_reg(struct lg216x_state *state, u16 reg, u8 *val)
92 {
93 int ret;
94 u8 reg_buf[] = { reg >> 8, reg & 0xff };
95 struct i2c_msg msg[] = {
96 { .addr = state->cfg->i2c_addr,
97 .flags = 0, .buf = reg_buf, .len = 2 },
98 { .addr = state->cfg->i2c_addr,
99 .flags = I2C_M_RD, .buf = val, .len = 1 },
100 };
101
102 lg_reg("reg: 0x%04x\n", reg);
103
104 ret = i2c_transfer(state->i2c_adap, msg, 2);
105
106 if (ret != 2) {
107 lg_err("error (addr %02x reg %04x error (ret == %i)\n",
108 state->cfg->i2c_addr, reg, ret);
109 if (ret < 0)
110 return ret;
111 else
112 return -EREMOTEIO;
113 }
114 return 0;
115 }
116
117 struct lg216x_reg {
118 u16 reg;
119 u8 val;
120 };
121
122 static int lg216x_write_regs(struct lg216x_state *state,
123 struct lg216x_reg *regs, int len)
124 {
125 int i, ret;
126
127 lg_reg("writing %d registers...\n", len);
128
129 for (i = 0; i < len - 1; i++) {
130 ret = lg216x_write_reg(state, regs[i].reg, regs[i].val);
131 if (lg_fail(ret))
132 return ret;
133 }
134 return 0;
135 }
136
137 static int lg216x_set_reg_bit(struct lg216x_state *state,
138 u16 reg, int bit, int onoff)
139 {
140 u8 val;
141 int ret;
142
143 lg_reg("reg: 0x%04x, bit: %d, level: %d\n", reg, bit, onoff);
144
145 ret = lg216x_read_reg(state, reg, &val);
146 if (lg_fail(ret))
147 goto fail;
148
149 val &= ~(1 << bit);
150 val |= (onoff & 1) << bit;
151
152 ret = lg216x_write_reg(state, reg, val);
153 lg_fail(ret);
154 fail:
155 return ret;
156 }
157
158 /* ------------------------------------------------------------------------ */
159
160 static int lg216x_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
161 {
162 struct lg216x_state *state = fe->demodulator_priv;
163 int ret;
164
165 if (state->cfg->deny_i2c_rptr)
166 return 0;
167
168 lg_dbg("(%d)\n", enable);
169
170 ret = lg216x_set_reg_bit(state, 0x0000, 0, enable ? 0 : 1);
171
172 msleep(1);
173
174 return ret;
175 }
176
177 static int lg216x_soft_reset(struct lg216x_state *state)
178 {
179 int ret;
180
181 lg_dbg("\n");
182
183 ret = lg216x_write_reg(state, 0x0002, 0x00);
184 if (lg_fail(ret))
185 goto fail;
186
187 msleep(20);
188 ret = lg216x_write_reg(state, 0x0002, 0x01);
189 if (lg_fail(ret))
190 goto fail;
191
192 state->last_reset = jiffies_to_msecs(jiffies);
193 fail:
194 return ret;
195 }
196
197 static int lg216x_initialize(struct lg216x_state *state)
198 {
199 int ret;
200
201 static struct lg216x_reg lg2160_init[] = {
202 #if 0
203 { .reg = 0x0015, .val = 0xe6 },
204 #else
205 { .reg = 0x0015, .val = 0xf7 },
206 { .reg = 0x001b, .val = 0x52 },
207 { .reg = 0x0208, .val = 0x00 },
208 { .reg = 0x0209, .val = 0x82 },
209 { .reg = 0x0210, .val = 0xf9 },
210 { .reg = 0x020a, .val = 0x00 },
211 { .reg = 0x020b, .val = 0x82 },
212 { .reg = 0x020d, .val = 0x28 },
213 { .reg = 0x020f, .val = 0x14 },
214 #endif
215 };
216
217 static struct lg216x_reg lg2161_init[] = {
218 { .reg = 0x0000, .val = 0x41 },
219 { .reg = 0x0001, .val = 0xfb },
220 { .reg = 0x0216, .val = 0x00 },
221 { .reg = 0x0219, .val = 0x00 },
222 { .reg = 0x021b, .val = 0x55 },
223 { .reg = 0x0606, .val = 0x0a },
224 };
225
226 switch (state->cfg->lg_chip) {
227 case LG2160:
228 ret = lg216x_write_regs(state,
229 lg2160_init, ARRAY_SIZE(lg2160_init));
230 break;
231 case LG2161:
232 ret = lg216x_write_regs(state,
233 lg2161_init, ARRAY_SIZE(lg2161_init));
234 break;
235 default:
236 ret = -EINVAL;
237 break;
238 }
239 if (lg_fail(ret))
240 goto fail;
241
242 ret = lg216x_soft_reset(state);
243 lg_fail(ret);
244 fail:
245 return ret;
246 }
247
248 /* ------------------------------------------------------------------------ */
249
250 static int lg216x_set_if(struct lg216x_state *state)
251 {
252 u8 val;
253 int ret;
254
255 lg_dbg("%d KHz\n", state->cfg->if_khz);
256
257 ret = lg216x_read_reg(state, 0x0132, &val);
258 if (lg_fail(ret))
259 goto fail;
260
261 val &= 0xfb;
262 val |= (0 == state->cfg->if_khz) ? 0x04 : 0x00;
263
264 ret = lg216x_write_reg(state, 0x0132, val);
265 lg_fail(ret);
266
267 /* if NOT zero IF, 6 MHz is the default */
268 fail:
269 return ret;
270 }
271
272 /* ------------------------------------------------------------------------ */
273
274 static int lg2160_agc_fix(struct lg216x_state *state,
275 int if_agc_fix, int rf_agc_fix)
276 {
277 u8 val;
278 int ret;
279
280 ret = lg216x_read_reg(state, 0x0100, &val);
281 if (lg_fail(ret))
282 goto fail;
283
284 val &= 0xf3;
285 val |= (if_agc_fix) ? 0x08 : 0x00;
286 val |= (rf_agc_fix) ? 0x04 : 0x00;
287
288 ret = lg216x_write_reg(state, 0x0100, val);
289 lg_fail(ret);
290 fail:
291 return ret;
292 }
293
294 #if 0
295 static int lg2160_agc_freeze(struct lg216x_state *state,
296 int if_agc_freeze, int rf_agc_freeze)
297 {
298 u8 val;
299 int ret;
300
301 ret = lg216x_read_reg(state, 0x0100, &val);
302 if (lg_fail(ret))
303 goto fail;
304
305 val &= 0xcf;
306 val |= (if_agc_freeze) ? 0x20 : 0x00;
307 val |= (rf_agc_freeze) ? 0x10 : 0x00;
308
309 ret = lg216x_write_reg(state, 0x0100, val);
310 lg_fail(ret);
311 fail:
312 return ret;
313 }
314 #endif
315
316 static int lg2160_agc_polarity(struct lg216x_state *state,
317 int if_agc_polarity, int rf_agc_polarity)
318 {
319 u8 val;
320 int ret;
321
322 ret = lg216x_read_reg(state, 0x0100, &val);
323 if (lg_fail(ret))
324 goto fail;
325
326 val &= 0xfc;
327 val |= (if_agc_polarity) ? 0x02 : 0x00;
328 val |= (rf_agc_polarity) ? 0x01 : 0x00;
329
330 ret = lg216x_write_reg(state, 0x0100, val);
331 lg_fail(ret);
332 fail:
333 return ret;
334 }
335
336 static int lg2160_tuner_pwr_save_polarity(struct lg216x_state *state,
337 int polarity)
338 {
339 u8 val;
340 int ret;
341
342 ret = lg216x_read_reg(state, 0x0008, &val);
343 if (lg_fail(ret))
344 goto fail;
345
346 val &= 0xfe;
347 val |= (polarity) ? 0x01 : 0x00;
348
349 ret = lg216x_write_reg(state, 0x0008, val);
350 lg_fail(ret);
351 fail:
352 return ret;
353 }
354
355 static int lg2160_spectrum_polarity(struct lg216x_state *state,
356 int inverted)
357 {
358 u8 val;
359 int ret;
360
361 ret = lg216x_read_reg(state, 0x0132, &val);
362 if (lg_fail(ret))
363 goto fail;
364
365 val &= 0xfd;
366 val |= (inverted) ? 0x02 : 0x00;
367
368 ret = lg216x_write_reg(state, 0x0132, val);
369 lg_fail(ret);
370 fail:
371 return lg216x_soft_reset(state);
372 }
373
374 static int lg2160_tuner_pwr_save(struct lg216x_state *state, int onoff)
375 {
376 u8 val;
377 int ret;
378
379 ret = lg216x_read_reg(state, 0x0007, &val);
380 if (lg_fail(ret))
381 goto fail;
382
383 val &= 0xbf;
384 val |= (onoff) ? 0x40 : 0x00;
385
386 ret = lg216x_write_reg(state, 0x0007, val);
387 lg_fail(ret);
388 fail:
389 return ret;
390 }
391
392 static int lg216x_set_parade(struct lg216x_state *state, int id)
393 {
394 int ret;
395
396 ret = lg216x_write_reg(state, 0x013e, id & 0x7f);
397 if (lg_fail(ret))
398 goto fail;
399
400 state->parade_id = id & 0x7f;
401 fail:
402 return ret;
403 }
404
405 static int lg216x_set_ensemble(struct lg216x_state *state, int id)
406 {
407 int ret;
408 u16 reg;
409 u8 val;
410
411 switch (state->cfg->lg_chip) {
412 case LG2160:
413 reg = 0x0400;
414 break;
415 case LG2161:
416 reg = 0x0500;
417 break;
418 }
419
420 ret = lg216x_read_reg(state, reg, &val);
421 if (lg_fail(ret))
422 goto fail;
423
424 val &= 0xfe;
425 val |= (id) ? 0x01 : 0x00;
426
427 ret = lg216x_write_reg(state, reg, val);
428 lg_fail(ret);
429 fail:
430 return ret;
431 }
432
433 static int lg2160_set_spi_clock(struct lg216x_state *state)
434 {
435 u8 val;
436 int ret;
437
438 ret = lg216x_read_reg(state, 0x0014, &val);
439 if (lg_fail(ret))
440 goto fail;
441
442 val &= 0xf3;
443 val |= (state->cfg->spi_clock << 2);
444
445 ret = lg216x_write_reg(state, 0x0014, val);
446 lg_fail(ret);
447 fail:
448 return ret;
449 }
450
451 static int lg2161_set_output_interface(struct lg216x_state *state)
452 {
453 u8 val;
454 int ret;
455
456 ret = lg216x_read_reg(state, 0x0014, &val);
457 if (lg_fail(ret))
458 goto fail;
459
460 val &= ~0x07;
461 val |= state->cfg->output_if; /* FIXME: needs sanity check */
462
463 ret = lg216x_write_reg(state, 0x0014, val);
464 lg_fail(ret);
465 fail:
466 return ret;
467 }
468
469 static int lg216x_enable_fic(struct lg216x_state *state, int onoff)
470 {
471 int ret;
472
473 ret = lg216x_write_reg(state, 0x0017, 0x23);
474 if (lg_fail(ret))
475 goto fail;
476
477 ret = lg216x_write_reg(state, 0x0016, 0xfc);
478 if (lg_fail(ret))
479 goto fail;
480
481 switch (state->cfg->lg_chip) {
482 case LG2160:
483 ret = lg216x_write_reg(state, 0x0016,
484 0xfc | ((onoff) ? 0x02 : 0x00));
485 break;
486 case LG2161:
487 ret = lg216x_write_reg(state, 0x0016, (onoff) ? 0x10 : 0x00);
488 break;
489 }
490 if (lg_fail(ret))
491 goto fail;
492
493 ret = lg216x_initialize(state);
494 if (lg_fail(ret))
495 goto fail;
496
497 if (onoff) {
498 ret = lg216x_write_reg(state, 0x0017, 0x03);
499 lg_fail(ret);
500 }
501 fail:
502 return ret;
503 }
504
505 /* ------------------------------------------------------------------------ */
506
507 static int lg216x_get_fic_version(struct lg216x_state *state, u8 *ficver)
508 {
509 u8 val;
510 int ret;
511
512 *ficver = 0xff; /* invalid value */
513
514 ret = lg216x_read_reg(state, 0x0128, &val);
515 if (lg_fail(ret))
516 goto fail;
517
518 *ficver = (val >> 3) & 0x1f;
519 fail:
520 return ret;
521 }
522
523 #if 0
524 static int lg2160_get_parade_id(struct lg216x_state *state, u8 *id)
525 {
526 u8 val;
527 int ret;
528
529 *id = 0xff; /* invalid value */
530
531 ret = lg216x_read_reg(state, 0x0123, &val);
532 if (lg_fail(ret))
533 goto fail;
534
535 *id = val & 0x7f;
536 fail:
537 return ret;
538 }
539 #endif
540
541 static int lg216x_get_nog(struct lg216x_state *state, u8 *nog)
542 {
543 u8 val;
544 int ret;
545
546 *nog = 0xff; /* invalid value */
547
548 ret = lg216x_read_reg(state, 0x0124, &val);
549 if (lg_fail(ret))
550 goto fail;
551
552 *nog = ((val >> 4) & 0x07) + 1;
553 fail:
554 return ret;
555 }
556
557 static int lg216x_get_tnog(struct lg216x_state *state, u8 *tnog)
558 {
559 u8 val;
560 int ret;
561
562 *tnog = 0xff; /* invalid value */
563
564 ret = lg216x_read_reg(state, 0x0125, &val);
565 if (lg_fail(ret))
566 goto fail;
567
568 *tnog = val & 0x1f;
569 fail:
570 return ret;
571 }
572
573 static int lg216x_get_sgn(struct lg216x_state *state, u8 *sgn)
574 {
575 u8 val;
576 int ret;
577
578 *sgn = 0xff; /* invalid value */
579
580 ret = lg216x_read_reg(state, 0x0124, &val);
581 if (lg_fail(ret))
582 goto fail;
583
584 *sgn = val & 0x0f;
585 fail:
586 return ret;
587 }
588
589 static int lg216x_get_prc(struct lg216x_state *state, u8 *prc)
590 {
591 u8 val;
592 int ret;
593
594 *prc = 0xff; /* invalid value */
595
596 ret = lg216x_read_reg(state, 0x0125, &val);
597 if (lg_fail(ret))
598 goto fail;
599
600 *prc = ((val >> 5) & 0x07) + 1;
601 fail:
602 return ret;
603 }
604
605 /* ------------------------------------------------------------------------ */
606
607 static int lg216x_get_rs_frame_mode(struct lg216x_state *state,
608 enum atscmh_rs_frame_mode *rs_framemode)
609 {
610 u8 val;
611 int ret;
612
613 switch (state->cfg->lg_chip) {
614 case LG2160:
615 ret = lg216x_read_reg(state, 0x0410, &val);
616 break;
617 case LG2161:
618 ret = lg216x_read_reg(state, 0x0513, &val);
619 break;
620 default:
621 ret = -EINVAL;
622 }
623 if (lg_fail(ret))
624 goto fail;
625
626 switch ((val >> 4) & 0x03) {
627 #if 1
628 default:
629 #endif
630 case 0x00:
631 *rs_framemode = ATSCMH_RSFRAME_PRI_ONLY;
632 break;
633 case 0x01:
634 *rs_framemode = ATSCMH_RSFRAME_PRI_SEC;
635 break;
636 #if 0
637 default:
638 *rs_framemode = ATSCMH_RSFRAME_RES;
639 break;
640 #endif
641 }
642 fail:
643 return ret;
644 }
645
646 static
647 int lg216x_get_rs_frame_ensemble(struct lg216x_state *state,
648 enum atscmh_rs_frame_ensemble *rs_frame_ens)
649 {
650 u8 val;
651 int ret;
652
653 switch (state->cfg->lg_chip) {
654 case LG2160:
655 ret = lg216x_read_reg(state, 0x0400, &val);
656 break;
657 case LG2161:
658 ret = lg216x_read_reg(state, 0x0500, &val);
659 break;
660 default:
661 ret = -EINVAL;
662 }
663 if (lg_fail(ret))
664 goto fail;
665
666 val &= 0x01;
667 *rs_frame_ens = (enum atscmh_rs_frame_ensemble) val;
668 fail:
669 return ret;
670 }
671
672 static int lg216x_get_rs_code_mode(struct lg216x_state *state,
673 enum atscmh_rs_code_mode *rs_code_pri,
674 enum atscmh_rs_code_mode *rs_code_sec)
675 {
676 u8 val;
677 int ret;
678
679 switch (state->cfg->lg_chip) {
680 case LG2160:
681 ret = lg216x_read_reg(state, 0x0410, &val);
682 break;
683 case LG2161:
684 ret = lg216x_read_reg(state, 0x0513, &val);
685 break;
686 default:
687 ret = -EINVAL;
688 }
689 if (lg_fail(ret))
690 goto fail;
691
692 *rs_code_pri = (enum atscmh_rs_code_mode) ((val >> 2) & 0x03);
693 *rs_code_sec = (enum atscmh_rs_code_mode) (val & 0x03);
694 fail:
695 return ret;
696 }
697
698 static int lg216x_get_sccc_block_mode(struct lg216x_state *state,
699 enum atscmh_sccc_block_mode *sccc_block)
700 {
701 u8 val;
702 int ret;
703
704 switch (state->cfg->lg_chip) {
705 case LG2160:
706 ret = lg216x_read_reg(state, 0x0315, &val);
707 break;
708 case LG2161:
709 ret = lg216x_read_reg(state, 0x0511, &val);
710 break;
711 default:
712 ret = -EINVAL;
713 }
714 if (lg_fail(ret))
715 goto fail;
716
717 switch (val & 0x03) {
718 case 0x00:
719 *sccc_block = ATSCMH_SCCC_BLK_SEP;
720 break;
721 case 0x01:
722 *sccc_block = ATSCMH_SCCC_BLK_COMB;
723 break;
724 default:
725 *sccc_block = ATSCMH_SCCC_BLK_RES;
726 break;
727 }
728 fail:
729 return ret;
730 }
731
732 static int lg216x_get_sccc_code_mode(struct lg216x_state *state,
733 enum atscmh_sccc_code_mode *mode_a,
734 enum atscmh_sccc_code_mode *mode_b,
735 enum atscmh_sccc_code_mode *mode_c,
736 enum atscmh_sccc_code_mode *mode_d)
737 {
738 u8 val;
739 int ret;
740
741 switch (state->cfg->lg_chip) {
742 case LG2160:
743 ret = lg216x_read_reg(state, 0x0316, &val);
744 break;
745 case LG2161:
746 ret = lg216x_read_reg(state, 0x0512, &val);
747 break;
748 default:
749 ret = -EINVAL;
750 }
751 if (lg_fail(ret))
752 goto fail;
753
754 switch ((val >> 6) & 0x03) {
755 case 0x00:
756 *mode_a = ATSCMH_SCCC_CODE_HLF;
757 break;
758 case 0x01:
759 *mode_a = ATSCMH_SCCC_CODE_QTR;
760 break;
761 default:
762 *mode_a = ATSCMH_SCCC_CODE_RES;
763 break;
764 }
765
766 switch ((val >> 4) & 0x03) {
767 case 0x00:
768 *mode_b = ATSCMH_SCCC_CODE_HLF;
769 break;
770 case 0x01:
771 *mode_b = ATSCMH_SCCC_CODE_QTR;
772 break;
773 default:
774 *mode_b = ATSCMH_SCCC_CODE_RES;
775 break;
776 }
777
778 switch ((val >> 2) & 0x03) {
779 case 0x00:
780 *mode_c = ATSCMH_SCCC_CODE_HLF;
781 break;
782 case 0x01:
783 *mode_c = ATSCMH_SCCC_CODE_QTR;
784 break;
785 default:
786 *mode_c = ATSCMH_SCCC_CODE_RES;
787 break;
788 }
789
790 switch (val & 0x03) {
791 case 0x00:
792 *mode_d = ATSCMH_SCCC_CODE_HLF;
793 break;
794 case 0x01:
795 *mode_d = ATSCMH_SCCC_CODE_QTR;
796 break;
797 default:
798 *mode_d = ATSCMH_SCCC_CODE_RES;
799 break;
800 }
801 fail:
802 return ret;
803 }
804
805 /* ------------------------------------------------------------------------ */
806
807 #if 0
808 static int lg216x_read_fic_err_count(struct lg216x_state *state, u8 *err)
809 {
810 u8 fic_err;
811 int ret;
812
813 *err = 0;
814
815 switch (state->cfg->lg_chip) {
816 case LG2160:
817 ret = lg216x_read_reg(state, 0x0012, &fic_err);
818 break;
819 case LG2161:
820 ret = lg216x_read_reg(state, 0x001e, &fic_err);
821 break;
822 }
823 if (lg_fail(ret))
824 goto fail;
825
826 *err = fic_err;
827 fail:
828 return ret;
829 }
830
831 static int lg2160_read_crc_err_count(struct lg216x_state *state, u16 *err)
832 {
833 u8 crc_err1, crc_err2;
834 int ret;
835
836 *err = 0;
837
838 ret = lg216x_read_reg(state, 0x0411, &crc_err1);
839 if (lg_fail(ret))
840 goto fail;
841
842 ret = lg216x_read_reg(state, 0x0412, &crc_err2);
843 if (lg_fail(ret))
844 goto fail;
845
846 *err = (u16)(((crc_err2 & 0x0f) << 8) | crc_err1);
847 fail:
848 return ret;
849 }
850
851 static int lg2161_read_crc_err_count(struct lg216x_state *state, u16 *err)
852 {
853 u8 crc_err;
854 int ret;
855
856 *err = 0;
857
858 ret = lg216x_read_reg(state, 0x0612, &crc_err);
859 if (lg_fail(ret))
860 goto fail;
861
862 *err = (u16)crc_err;
863 fail:
864 return ret;
865 }
866
867 static int lg216x_read_crc_err_count(struct lg216x_state *state, u16 *err)
868 {
869 int ret;
870 switch (state->cfg->lg_chip) {
871 case LG2160:
872 ret = lg2160_read_crc_err_count(state, err);
873 break;
874 case LG2161:
875 ret = lg2161_read_crc_err_count(state, err);
876 break;
877 default:
878 ret = -EINVAL;
879 break;
880 }
881 return ret;
882 }
883
884 static int lg2160_read_rs_err_count(struct lg216x_state *state, u16 *err)
885 {
886 u8 rs_err1, rs_err2;
887 int ret;
888
889 *err = 0;
890
891 ret = lg216x_read_reg(state, 0x0413, &rs_err1);
892 if (lg_fail(ret))
893 goto fail;
894
895 ret = lg216x_read_reg(state, 0x0414, &rs_err2);
896 if (lg_fail(ret))
897 goto fail;
898
899 *err = (u16)(((rs_err2 & 0x0f) << 8) | rs_err1);
900 fail:
901 return ret;
902 }
903
904 static int lg2161_read_rs_err_count(struct lg216x_state *state, u16 *err)
905 {
906 u8 rs_err1, rs_err2;
907 int ret;
908
909 *err = 0;
910
911 ret = lg216x_read_reg(state, 0x0613, &rs_err1);
912 if (lg_fail(ret))
913 goto fail;
914
915 ret = lg216x_read_reg(state, 0x0614, &rs_err2);
916 if (lg_fail(ret))
917 goto fail;
918
919 *err = (u16)((rs_err1 << 8) | rs_err2);
920 fail:
921 return ret;
922 }
923
924 static int lg216x_read_rs_err_count(struct lg216x_state *state, u16 *err)
925 {
926 int ret;
927 switch (state->cfg->lg_chip) {
928 case LG2160:
929 ret = lg2160_read_rs_err_count(state, err);
930 break;
931 case LG2161:
932 ret = lg2161_read_rs_err_count(state, err);
933 break;
934 default:
935 ret = -EINVAL;
936 break;
937 }
938 return ret;
939 }
940 #endif
941
942 /* ------------------------------------------------------------------------ */
943
944 static int lg216x_get_frontend(struct dvb_frontend *fe)
945 {
946 struct lg216x_state *state = fe->demodulator_priv;
947 int ret;
948
949 lg_dbg("\n");
950
951 fe->dtv_property_cache.modulation = VSB_8;
952 fe->dtv_property_cache.frequency = state->current_frequency;
953 fe->dtv_property_cache.delivery_system = SYS_ATSCMH;
954
955 ret = lg216x_get_fic_version(state,
956 &fe->dtv_property_cache.atscmh_fic_ver);
957 if (lg_fail(ret))
958 goto fail;
959 if (state->fic_ver != fe->dtv_property_cache.atscmh_fic_ver) {
960 state->fic_ver = fe->dtv_property_cache.atscmh_fic_ver;
961
962 #if 0
963 ret = lg2160_get_parade_id(state,
964 &fe->dtv_property_cache.atscmh_parade_id);
965 if (lg_fail(ret))
966 goto fail;
967 /* #else */
968 fe->dtv_property_cache.atscmh_parade_id = state->parade_id;
969 #endif
970 ret = lg216x_get_nog(state,
971 &fe->dtv_property_cache.atscmh_nog);
972 if (lg_fail(ret))
973 goto fail;
974 ret = lg216x_get_tnog(state,
975 &fe->dtv_property_cache.atscmh_tnog);
976 if (lg_fail(ret))
977 goto fail;
978 ret = lg216x_get_sgn(state,
979 &fe->dtv_property_cache.atscmh_sgn);
980 if (lg_fail(ret))
981 goto fail;
982 ret = lg216x_get_prc(state,
983 &fe->dtv_property_cache.atscmh_prc);
984 if (lg_fail(ret))
985 goto fail;
986
987 ret = lg216x_get_rs_frame_mode(state,
988 (enum atscmh_rs_frame_mode *)
989 &fe->dtv_property_cache.atscmh_rs_frame_mode);
990 if (lg_fail(ret))
991 goto fail;
992 ret = lg216x_get_rs_frame_ensemble(state,
993 (enum atscmh_rs_frame_ensemble *)
994 &fe->dtv_property_cache.atscmh_rs_frame_ensemble);
995 if (lg_fail(ret))
996 goto fail;
997 ret = lg216x_get_rs_code_mode(state,
998 (enum atscmh_rs_code_mode *)
999 &fe->dtv_property_cache.atscmh_rs_code_mode_pri,
1000 (enum atscmh_rs_code_mode *)
1001 &fe->dtv_property_cache.atscmh_rs_code_mode_sec);
1002 if (lg_fail(ret))
1003 goto fail;
1004 ret = lg216x_get_sccc_block_mode(state,
1005 (enum atscmh_sccc_block_mode *)
1006 &fe->dtv_property_cache.atscmh_sccc_block_mode);
1007 if (lg_fail(ret))
1008 goto fail;
1009 ret = lg216x_get_sccc_code_mode(state,
1010 (enum atscmh_sccc_code_mode *)
1011 &fe->dtv_property_cache.atscmh_sccc_code_mode_a,
1012 (enum atscmh_sccc_code_mode *)
1013 &fe->dtv_property_cache.atscmh_sccc_code_mode_b,
1014 (enum atscmh_sccc_code_mode *)
1015 &fe->dtv_property_cache.atscmh_sccc_code_mode_c,
1016 (enum atscmh_sccc_code_mode *)
1017 &fe->dtv_property_cache.atscmh_sccc_code_mode_d);
1018 if (lg_fail(ret))
1019 goto fail;
1020 }
1021 #if 0
1022 ret = lg216x_read_fic_err_count(state,
1023 (u8 *)&fe->dtv_property_cache.atscmh_fic_err);
1024 if (lg_fail(ret))
1025 goto fail;
1026 ret = lg216x_read_crc_err_count(state,
1027 &fe->dtv_property_cache.atscmh_crc_err);
1028 if (lg_fail(ret))
1029 goto fail;
1030 ret = lg216x_read_rs_err_count(state,
1031 &fe->dtv_property_cache.atscmh_rs_err);
1032 if (lg_fail(ret))
1033 goto fail;
1034
1035 switch (state->cfg->lg_chip) {
1036 case LG2160:
1037 if (((fe->dtv_property_cache.atscmh_rs_err >= 240) &&
1038 (fe->dtv_property_cache.atscmh_crc_err >= 240)) &&
1039 ((jiffies_to_msecs(jiffies) - state->last_reset) > 6000))
1040 ret = lg216x_soft_reset(state);
1041 break;
1042 case LG2161:
1043 /* no fix needed here (as far as we know) */
1044 ret = 0;
1045 break;
1046 }
1047 lg_fail(ret);
1048 #endif
1049 fail:
1050 return ret;
1051 }
1052
1053 static int lg216x_get_property(struct dvb_frontend *fe,
1054 struct dtv_property *tvp)
1055 {
1056 return (DTV_ATSCMH_FIC_VER == tvp->cmd) ?
1057 lg216x_get_frontend(fe) : 0;
1058 }
1059
1060
1061 static int lg2160_set_frontend(struct dvb_frontend *fe)
1062 {
1063 struct lg216x_state *state = fe->demodulator_priv;
1064 int ret;
1065
1066 lg_dbg("(%d)\n", fe->dtv_property_cache.frequency);
1067
1068 if (fe->ops.tuner_ops.set_params) {
1069 ret = fe->ops.tuner_ops.set_params(fe);
1070 if (fe->ops.i2c_gate_ctrl)
1071 fe->ops.i2c_gate_ctrl(fe, 0);
1072 if (lg_fail(ret))
1073 goto fail;
1074 state->current_frequency = fe->dtv_property_cache.frequency;
1075 }
1076
1077 ret = lg2160_agc_fix(state, 0, 0);
1078 if (lg_fail(ret))
1079 goto fail;
1080 ret = lg2160_agc_polarity(state, 0, 0);
1081 if (lg_fail(ret))
1082 goto fail;
1083 ret = lg2160_tuner_pwr_save_polarity(state, 1);
1084 if (lg_fail(ret))
1085 goto fail;
1086 ret = lg216x_set_if(state);
1087 if (lg_fail(ret))
1088 goto fail;
1089 ret = lg2160_spectrum_polarity(state, state->cfg->spectral_inversion);
1090 if (lg_fail(ret))
1091 goto fail;
1092
1093 /* be tuned before this point */
1094 ret = lg216x_soft_reset(state);
1095 if (lg_fail(ret))
1096 goto fail;
1097
1098 ret = lg2160_tuner_pwr_save(state, 0);
1099 if (lg_fail(ret))
1100 goto fail;
1101
1102 switch (state->cfg->lg_chip) {
1103 case LG2160:
1104 ret = lg2160_set_spi_clock(state);
1105 if (lg_fail(ret))
1106 goto fail;
1107 break;
1108 case LG2161:
1109 ret = lg2161_set_output_interface(state);
1110 if (lg_fail(ret))
1111 goto fail;
1112 break;
1113 }
1114
1115 ret = lg216x_set_parade(state, fe->dtv_property_cache.atscmh_parade_id);
1116 if (lg_fail(ret))
1117 goto fail;
1118
1119 ret = lg216x_set_ensemble(state,
1120 fe->dtv_property_cache.atscmh_rs_frame_ensemble);
1121 if (lg_fail(ret))
1122 goto fail;
1123
1124 ret = lg216x_initialize(state);
1125 if (lg_fail(ret))
1126 goto fail;
1127
1128 ret = lg216x_enable_fic(state, 1);
1129 lg_fail(ret);
1130
1131 lg216x_get_frontend(fe);
1132 fail:
1133 return ret;
1134 }
1135
1136 /* ------------------------------------------------------------------------ */
1137
1138 static int lg2160_read_lock_status(struct lg216x_state *state,
1139 int *acq_lock, int *sync_lock)
1140 {
1141 u8 val;
1142 int ret;
1143
1144 *acq_lock = 0;
1145 *sync_lock = 0;
1146
1147 ret = lg216x_read_reg(state, 0x011b, &val);
1148 if (lg_fail(ret))
1149 goto fail;
1150
1151 *sync_lock = (val & 0x20) ? 0 : 1;
1152 *acq_lock = (val & 0x40) ? 0 : 1;
1153 fail:
1154 return ret;
1155 }
1156
1157 #ifdef USE_LG2161_LOCK_BITS
1158 static int lg2161_read_lock_status(struct lg216x_state *state,
1159 int *acq_lock, int *sync_lock)
1160 {
1161 u8 val;
1162 int ret;
1163
1164 *acq_lock = 0;
1165 *sync_lock = 0;
1166
1167 ret = lg216x_read_reg(state, 0x0304, &val);
1168 if (lg_fail(ret))
1169 goto fail;
1170
1171 *sync_lock = (val & 0x80) ? 0 : 1;
1172
1173 ret = lg216x_read_reg(state, 0x011b, &val);
1174 if (lg_fail(ret))
1175 goto fail;
1176
1177 *acq_lock = (val & 0x40) ? 0 : 1;
1178 fail:
1179 return ret;
1180 }
1181 #endif
1182
1183 static int lg216x_read_lock_status(struct lg216x_state *state,
1184 int *acq_lock, int *sync_lock)
1185 {
1186 #ifdef USE_LG2161_LOCK_BITS
1187 int ret;
1188 switch (state->cfg->lg_chip) {
1189 case LG2160:
1190 ret = lg2160_read_lock_status(state, acq_lock, sync_lock);
1191 break;
1192 case LG2161:
1193 ret = lg2161_read_lock_status(state, acq_lock, sync_lock);
1194 break;
1195 default:
1196 ret = -EINVAL;
1197 break;
1198 }
1199 return ret;
1200 #else
1201 return lg2160_read_lock_status(state, acq_lock, sync_lock);
1202 #endif
1203 }
1204
1205 static int lg216x_read_status(struct dvb_frontend *fe, fe_status_t *status)
1206 {
1207 struct lg216x_state *state = fe->demodulator_priv;
1208 int ret, acq_lock, sync_lock;
1209
1210 *status = 0;
1211
1212 ret = lg216x_read_lock_status(state, &acq_lock, &sync_lock);
1213 if (lg_fail(ret))
1214 goto fail;
1215
1216 lg_dbg("%s%s\n",
1217 acq_lock ? "SIGNALEXIST " : "",
1218 sync_lock ? "SYNCLOCK" : "");
1219
1220 if (acq_lock)
1221 *status |= FE_HAS_SIGNAL;
1222 if (sync_lock)
1223 *status |= FE_HAS_SYNC;
1224
1225 if (*status)
1226 *status |= FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_LOCK;
1227
1228 fail:
1229 return ret;
1230 }
1231
1232 /* ------------------------------------------------------------------------ */
1233
1234 static int lg2160_read_snr(struct dvb_frontend *fe, u16 *snr)
1235 {
1236 struct lg216x_state *state = fe->demodulator_priv;
1237 u8 snr1, snr2;
1238 int ret;
1239
1240 *snr = 0;
1241
1242 ret = lg216x_read_reg(state, 0x0202, &snr1);
1243 if (lg_fail(ret))
1244 goto fail;
1245
1246 ret = lg216x_read_reg(state, 0x0203, &snr2);
1247 if (lg_fail(ret))
1248 goto fail;
1249
1250 if ((snr1 == 0xba) || (snr2 == 0xdf))
1251 *snr = 0;
1252 else
1253 #if 1
1254 *snr = ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 >> 4);
1255 #else /* BCD */
1256 *snr = (snr2 | (snr1 << 8));
1257 #endif
1258 fail:
1259 return ret;
1260 }
1261
1262 static int lg2161_read_snr(struct dvb_frontend *fe, u16 *snr)
1263 {
1264 struct lg216x_state *state = fe->demodulator_priv;
1265 u8 snr1, snr2;
1266 int ret;
1267
1268 *snr = 0;
1269
1270 ret = lg216x_read_reg(state, 0x0302, &snr1);
1271 if (lg_fail(ret))
1272 goto fail;
1273
1274 ret = lg216x_read_reg(state, 0x0303, &snr2);
1275 if (lg_fail(ret))
1276 goto fail;
1277
1278 if ((snr1 == 0xba) || (snr2 == 0xfd))
1279 *snr = 0;
1280 else
1281
1282 *snr = ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 & 0x0f);
1283 fail:
1284 return ret;
1285 }
1286
1287 static int lg216x_read_signal_strength(struct dvb_frontend *fe,
1288 u16 *strength)
1289 {
1290 #if 0
1291 /* borrowed from lgdt330x.c
1292 *
1293 * Calculate strength from SNR up to 35dB
1294 * Even though the SNR can go higher than 35dB,
1295 * there is some comfort factor in having a range of
1296 * strong signals that can show at 100%
1297 */
1298 struct lg216x_state *state = fe->demodulator_priv;
1299 u16 snr;
1300 int ret;
1301 #endif
1302 *strength = 0;
1303 #if 0
1304 ret = fe->ops.read_snr(fe, &snr);
1305 if (lg_fail(ret))
1306 goto fail;
1307 /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
1308 /* scale the range 0 - 35*2^24 into 0 - 65535 */
1309 if (state->snr >= 8960 * 0x10000)
1310 *strength = 0xffff;
1311 else
1312 *strength = state->snr / 8960;
1313 fail:
1314 return ret;
1315 #else
1316 return 0;
1317 #endif
1318 }
1319
1320 /* ------------------------------------------------------------------------ */
1321
1322 static int lg216x_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1323 {
1324 struct lg216x_state *state = fe->demodulator_priv;
1325 int ret;
1326 #if 0
1327 ret = lg216x_read_rs_err_count(state,
1328 &fe->dtv_property_cache.atscmh_rs_err);
1329 if (lg_fail(ret))
1330 goto fail;
1331
1332 *ucblocks = fe->dtv_property_cache.atscmh_rs_err;
1333 #else
1334 *ucblocks = 0;
1335 #endif
1336 fail:
1337 return 0;
1338 }
1339
1340 static int lg216x_get_tune_settings(struct dvb_frontend *fe,
1341 struct dvb_frontend_tune_settings
1342 *fe_tune_settings)
1343 {
1344 fe_tune_settings->min_delay_ms = 500;
1345 lg_dbg("\n");
1346 return 0;
1347 }
1348
1349 static void lg216x_release(struct dvb_frontend *fe)
1350 {
1351 struct lg216x_state *state = fe->demodulator_priv;
1352 lg_dbg("\n");
1353 kfree(state);
1354 }
1355
1356 static struct dvb_frontend_ops lg2160_ops = {
1357 .delsys = { SYS_ATSCMH },
1358 .info = {
1359 .name = "LG Electronics LG2160 ATSC/MH Frontend",
1360 .frequency_min = 54000000,
1361 .frequency_max = 858000000,
1362 .frequency_stepsize = 62500,
1363 },
1364 .i2c_gate_ctrl = lg216x_i2c_gate_ctrl,
1365 #if 0
1366 .init = lg216x_init,
1367 .sleep = lg216x_sleep,
1368 #endif
1369 .get_property = lg216x_get_property,
1370
1371 .set_frontend = lg2160_set_frontend,
1372 .get_frontend = lg216x_get_frontend,
1373 .get_tune_settings = lg216x_get_tune_settings,
1374 .read_status = lg216x_read_status,
1375 #if 0
1376 .read_ber = lg216x_read_ber,
1377 #endif
1378 .read_signal_strength = lg216x_read_signal_strength,
1379 .read_snr = lg2160_read_snr,
1380 .read_ucblocks = lg216x_read_ucblocks,
1381 .release = lg216x_release,
1382 };
1383
1384 static struct dvb_frontend_ops lg2161_ops = {
1385 .delsys = { SYS_ATSCMH },
1386 .info = {
1387 .name = "LG Electronics LG2161 ATSC/MH Frontend",
1388 .frequency_min = 54000000,
1389 .frequency_max = 858000000,
1390 .frequency_stepsize = 62500,
1391 },
1392 .i2c_gate_ctrl = lg216x_i2c_gate_ctrl,
1393 #if 0
1394 .init = lg216x_init,
1395 .sleep = lg216x_sleep,
1396 #endif
1397 .get_property = lg216x_get_property,
1398
1399 .set_frontend = lg2160_set_frontend,
1400 .get_frontend = lg216x_get_frontend,
1401 .get_tune_settings = lg216x_get_tune_settings,
1402 .read_status = lg216x_read_status,
1403 #if 0
1404 .read_ber = lg216x_read_ber,
1405 #endif
1406 .read_signal_strength = lg216x_read_signal_strength,
1407 .read_snr = lg2161_read_snr,
1408 .read_ucblocks = lg216x_read_ucblocks,
1409 .release = lg216x_release,
1410 };
1411
1412 struct dvb_frontend *lg2160_attach(const struct lg2160_config *config,
1413 struct i2c_adapter *i2c_adap)
1414 {
1415 struct lg216x_state *state = NULL;
1416
1417 lg_dbg("(%d-%04x)\n",
1418 i2c_adap ? i2c_adapter_id(i2c_adap) : 0,
1419 config ? config->i2c_addr : 0);
1420
1421 state = kzalloc(sizeof(struct lg216x_state), GFP_KERNEL);
1422 if (state == NULL)
1423 goto fail;
1424
1425 state->cfg = config;
1426 state->i2c_adap = i2c_adap;
1427 state->fic_ver = 0xff;
1428 state->parade_id = 0xff;
1429
1430 switch (config->lg_chip) {
1431 default:
1432 lg_warn("invalid chip requested, defaulting to LG2160");
1433 /* fall-thru */
1434 case LG2160:
1435 memcpy(&state->frontend.ops, &lg2160_ops,
1436 sizeof(struct dvb_frontend_ops));
1437 break;
1438 case LG2161:
1439 memcpy(&state->frontend.ops, &lg2161_ops,
1440 sizeof(struct dvb_frontend_ops));
1441 break;
1442 }
1443
1444 state->frontend.demodulator_priv = state;
1445 state->current_frequency = -1;
1446 /* parade 1 by default */
1447 state->frontend.dtv_property_cache.atscmh_parade_id = 1;
1448
1449 return &state->frontend;
1450 fail:
1451 lg_warn("unable to detect LG216x hardware\n");
1452 kfree(state);
1453 return NULL;
1454 }
1455 EXPORT_SYMBOL(lg2160_attach);
1456
1457 MODULE_DESCRIPTION("LG Electronics LG216x ATSC/MH Demodulator Driver");
1458 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1459 MODULE_LICENSE("GPL");
1460 MODULE_VERSION("0.3");
1461
1462 /*
1463 * Local variables:
1464 * c-basic-offset: 8
1465 * End:
1466 */
Linux kernel - Deliverables
This page took 0.154275 seconds and 4 git commands to generate.