?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] rc: img-ir: pass toggle bit to the rc driver
[linux-2.6/btrfs-unstable.git] / drivers / media / dvb-frontends / lg2160.c
blob99efeba3c31a53ef7194e4266b10fa1c986e26be
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; 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 default:
417 reg = 0x0500;
418 break;
419 }
420
421 ret = lg216x_read_reg(state, reg, &val);
422 if (lg_fail(ret))
423 goto fail;
424
425 val &= 0xfe;
426 val |= (id) ? 0x01 : 0x00;
427
428 ret = lg216x_write_reg(state, reg, val);
429 lg_fail(ret);
430 fail:
431 return ret;
432 }
433
434 static int lg2160_set_spi_clock(struct lg216x_state *state)
435 {
436 u8 val;
437 int ret;
438
439 ret = lg216x_read_reg(state, 0x0014, &val);
440 if (lg_fail(ret))
441 goto fail;
442
443 val &= 0xf3;
444 val |= (state->cfg->spi_clock << 2);
445
446 ret = lg216x_write_reg(state, 0x0014, val);
447 lg_fail(ret);
448 fail:
449 return ret;
450 }
451
452 static int lg2161_set_output_interface(struct lg216x_state *state)
453 {
454 u8 val;
455 int ret;
456
457 ret = lg216x_read_reg(state, 0x0014, &val);
458 if (lg_fail(ret))
459 goto fail;
460
461 val &= ~0x07;
462 val |= state->cfg->output_if; /* FIXME: needs sanity check */
463
464 ret = lg216x_write_reg(state, 0x0014, val);
465 lg_fail(ret);
466 fail:
467 return ret;
468 }
469
470 static int lg216x_enable_fic(struct lg216x_state *state, int onoff)
471 {
472 int ret;
473
474 ret = lg216x_write_reg(state, 0x0017, 0x23);
475 if (lg_fail(ret))
476 goto fail;
477
478 ret = lg216x_write_reg(state, 0x0016, 0xfc);
479 if (lg_fail(ret))
480 goto fail;
481
482 switch (state->cfg->lg_chip) {
483 case LG2160:
484 ret = lg216x_write_reg(state, 0x0016,
485 0xfc | ((onoff) ? 0x02 : 0x00));
486 break;
487 case LG2161:
488 ret = lg216x_write_reg(state, 0x0016, (onoff) ? 0x10 : 0x00);
489 break;
490 }
491 if (lg_fail(ret))
492 goto fail;
493
494 ret = lg216x_initialize(state);
495 if (lg_fail(ret))
496 goto fail;
497
498 if (onoff) {
499 ret = lg216x_write_reg(state, 0x0017, 0x03);
500 lg_fail(ret);
501 }
502 fail:
503 return ret;
504 }
505
506 /* ------------------------------------------------------------------------ */
507
508 static int lg216x_get_fic_version(struct lg216x_state *state, u8 *ficver)
509 {
510 u8 val;
511 int ret;
512
513 *ficver = 0xff; /* invalid value */
514
515 ret = lg216x_read_reg(state, 0x0128, &val);
516 if (lg_fail(ret))
517 goto fail;
518
519 *ficver = (val >> 3) & 0x1f;
520 fail:
521 return ret;
522 }
523
524 #if 0
525 static int lg2160_get_parade_id(struct lg216x_state *state, u8 *id)
526 {
527 u8 val;
528 int ret;
529
530 *id = 0xff; /* invalid value */
531
532 ret = lg216x_read_reg(state, 0x0123, &val);
533 if (lg_fail(ret))
534 goto fail;
535
536 *id = val & 0x7f;
537 fail:
538 return ret;
539 }
540 #endif
541
542 static int lg216x_get_nog(struct lg216x_state *state, u8 *nog)
543 {
544 u8 val;
545 int ret;
546
547 *nog = 0xff; /* invalid value */
548
549 ret = lg216x_read_reg(state, 0x0124, &val);
550 if (lg_fail(ret))
551 goto fail;
552
553 *nog = ((val >> 4) & 0x07) + 1;
554 fail:
555 return ret;
556 }
557
558 static int lg216x_get_tnog(struct lg216x_state *state, u8 *tnog)
559 {
560 u8 val;
561 int ret;
562
563 *tnog = 0xff; /* invalid value */
564
565 ret = lg216x_read_reg(state, 0x0125, &val);
566 if (lg_fail(ret))
567 goto fail;
568
569 *tnog = val & 0x1f;
570 fail:
571 return ret;
572 }
573
574 static int lg216x_get_sgn(struct lg216x_state *state, u8 *sgn)
575 {
576 u8 val;
577 int ret;
578
579 *sgn = 0xff; /* invalid value */
580
581 ret = lg216x_read_reg(state, 0x0124, &val);
582 if (lg_fail(ret))
583 goto fail;
584
585 *sgn = val & 0x0f;
586 fail:
587 return ret;
588 }
589
590 static int lg216x_get_prc(struct lg216x_state *state, u8 *prc)
591 {
592 u8 val;
593 int ret;
594
595 *prc = 0xff; /* invalid value */
596
597 ret = lg216x_read_reg(state, 0x0125, &val);
598 if (lg_fail(ret))
599 goto fail;
600
601 *prc = ((val >> 5) & 0x07) + 1;
602 fail:
603 return ret;
604 }
605
606 /* ------------------------------------------------------------------------ */
607
608 static int lg216x_get_rs_frame_mode(struct lg216x_state *state,
609 enum atscmh_rs_frame_mode *rs_framemode)
610 {
611 u8 val;
612 int ret;
613
614 switch (state->cfg->lg_chip) {
615 case LG2160:
616 ret = lg216x_read_reg(state, 0x0410, &val);
617 break;
618 case LG2161:
619 ret = lg216x_read_reg(state, 0x0513, &val);
620 break;
621 default:
622 ret = -EINVAL;
623 }
624 if (lg_fail(ret))
625 goto fail;
626
627 switch ((val >> 4) & 0x03) {
628 #if 1
629 default:
630 #endif
631 case 0x00:
632 *rs_framemode = ATSCMH_RSFRAME_PRI_ONLY;
633 break;
634 case 0x01:
635 *rs_framemode = ATSCMH_RSFRAME_PRI_SEC;
636 break;
637 #if 0
638 default:
639 *rs_framemode = ATSCMH_RSFRAME_RES;
640 break;
641 #endif
642 }
643 fail:
644 return ret;
645 }
646
647 static
648 int lg216x_get_rs_frame_ensemble(struct lg216x_state *state,
649 enum atscmh_rs_frame_ensemble *rs_frame_ens)
650 {
651 u8 val;
652 int ret;
653
654 switch (state->cfg->lg_chip) {
655 case LG2160:
656 ret = lg216x_read_reg(state, 0x0400, &val);
657 break;
658 case LG2161:
659 ret = lg216x_read_reg(state, 0x0500, &val);
660 break;
661 default:
662 ret = -EINVAL;
663 }
664 if (lg_fail(ret))
665 goto fail;
666
667 val &= 0x01;
668 *rs_frame_ens = (enum atscmh_rs_frame_ensemble) val;
669 fail:
670 return ret;
671 }
672
673 static int lg216x_get_rs_code_mode(struct lg216x_state *state,
674 enum atscmh_rs_code_mode *rs_code_pri,
675 enum atscmh_rs_code_mode *rs_code_sec)
676 {
677 u8 val;
678 int ret;
679
680 switch (state->cfg->lg_chip) {
681 case LG2160:
682 ret = lg216x_read_reg(state, 0x0410, &val);
683 break;
684 case LG2161:
685 ret = lg216x_read_reg(state, 0x0513, &val);
686 break;
687 default:
688 ret = -EINVAL;
689 }
690 if (lg_fail(ret))
691 goto fail;
692
693 *rs_code_pri = (enum atscmh_rs_code_mode) ((val >> 2) & 0x03);
694 *rs_code_sec = (enum atscmh_rs_code_mode) (val & 0x03);
695 fail:
696 return ret;
697 }
698
699 static int lg216x_get_sccc_block_mode(struct lg216x_state *state,
700 enum atscmh_sccc_block_mode *sccc_block)
701 {
702 u8 val;
703 int ret;
704
705 switch (state->cfg->lg_chip) {
706 case LG2160:
707 ret = lg216x_read_reg(state, 0x0315, &val);
708 break;
709 case LG2161:
710 ret = lg216x_read_reg(state, 0x0511, &val);
711 break;
712 default:
713 ret = -EINVAL;
714 }
715 if (lg_fail(ret))
716 goto fail;
717
718 switch (val & 0x03) {
719 case 0x00:
720 *sccc_block = ATSCMH_SCCC_BLK_SEP;
721 break;
722 case 0x01:
723 *sccc_block = ATSCMH_SCCC_BLK_COMB;
724 break;
725 default:
726 *sccc_block = ATSCMH_SCCC_BLK_RES;
727 break;
728 }
729 fail:
730 return ret;
731 }
732
733 static int lg216x_get_sccc_code_mode(struct lg216x_state *state,
734 enum atscmh_sccc_code_mode *mode_a,
735 enum atscmh_sccc_code_mode *mode_b,
736 enum atscmh_sccc_code_mode *mode_c,
737 enum atscmh_sccc_code_mode *mode_d)
738 {
739 u8 val;
740 int ret;
741
742 switch (state->cfg->lg_chip) {
743 case LG2160:
744 ret = lg216x_read_reg(state, 0x0316, &val);
745 break;
746 case LG2161:
747 ret = lg216x_read_reg(state, 0x0512, &val);
748 break;
749 default:
750 ret = -EINVAL;
751 }
752 if (lg_fail(ret))
753 goto fail;
754
755 switch ((val >> 6) & 0x03) {
756 case 0x00:
757 *mode_a = ATSCMH_SCCC_CODE_HLF;
758 break;
759 case 0x01:
760 *mode_a = ATSCMH_SCCC_CODE_QTR;
761 break;
762 default:
763 *mode_a = ATSCMH_SCCC_CODE_RES;
764 break;
765 }
766
767 switch ((val >> 4) & 0x03) {
768 case 0x00:
769 *mode_b = ATSCMH_SCCC_CODE_HLF;
770 break;
771 case 0x01:
772 *mode_b = ATSCMH_SCCC_CODE_QTR;
773 break;
774 default:
775 *mode_b = ATSCMH_SCCC_CODE_RES;
776 break;
777 }
778
779 switch ((val >> 2) & 0x03) {
780 case 0x00:
781 *mode_c = ATSCMH_SCCC_CODE_HLF;
782 break;
783 case 0x01:
784 *mode_c = ATSCMH_SCCC_CODE_QTR;
785 break;
786 default:
787 *mode_c = ATSCMH_SCCC_CODE_RES;
788 break;
789 }
790
791 switch (val & 0x03) {
792 case 0x00:
793 *mode_d = ATSCMH_SCCC_CODE_HLF;
794 break;
795 case 0x01:
796 *mode_d = ATSCMH_SCCC_CODE_QTR;
797 break;
798 default:
799 *mode_d = ATSCMH_SCCC_CODE_RES;
800 break;
801 }
802 fail:
803 return ret;
804 }
805
806 /* ------------------------------------------------------------------------ */
807
808 #if 0
809 static int lg216x_read_fic_err_count(struct lg216x_state *state, u8 *err)
810 {
811 u8 fic_err;
812 int ret;
813
814 *err = 0;
815
816 switch (state->cfg->lg_chip) {
817 case LG2160:
818 ret = lg216x_read_reg(state, 0x0012, &fic_err);
819 break;
820 case LG2161:
821 ret = lg216x_read_reg(state, 0x001e, &fic_err);
822 break;
823 }
824 if (lg_fail(ret))
825 goto fail;
826
827 *err = fic_err;
828 fail:
829 return ret;
830 }
831
832 static int lg2160_read_crc_err_count(struct lg216x_state *state, u16 *err)
833 {
834 u8 crc_err1, crc_err2;
835 int ret;
836
837 *err = 0;
838
839 ret = lg216x_read_reg(state, 0x0411, &crc_err1);
840 if (lg_fail(ret))
841 goto fail;
842
843 ret = lg216x_read_reg(state, 0x0412, &crc_err2);
844 if (lg_fail(ret))
845 goto fail;
846
847 *err = (u16)(((crc_err2 & 0x0f) << 8) | crc_err1);
848 fail:
849 return ret;
850 }
851
852 static int lg2161_read_crc_err_count(struct lg216x_state *state, u16 *err)
853 {
854 u8 crc_err;
855 int ret;
856
857 *err = 0;
858
859 ret = lg216x_read_reg(state, 0x0612, &crc_err);
860 if (lg_fail(ret))
861 goto fail;
862
863 *err = (u16)crc_err;
864 fail:
865 return ret;
866 }
867
868 static int lg216x_read_crc_err_count(struct lg216x_state *state, u16 *err)
869 {
870 int ret;
871 switch (state->cfg->lg_chip) {
872 case LG2160:
873 ret = lg2160_read_crc_err_count(state, err);
874 break;
875 case LG2161:
876 ret = lg2161_read_crc_err_count(state, err);
877 break;
878 default:
879 ret = -EINVAL;
880 break;
881 }
882 return ret;
883 }
884
885 static int lg2160_read_rs_err_count(struct lg216x_state *state, u16 *err)
886 {
887 u8 rs_err1, rs_err2;
888 int ret;
889
890 *err = 0;
891
892 ret = lg216x_read_reg(state, 0x0413, &rs_err1);
893 if (lg_fail(ret))
894 goto fail;
895
896 ret = lg216x_read_reg(state, 0x0414, &rs_err2);
897 if (lg_fail(ret))
898 goto fail;
899
900 *err = (u16)(((rs_err2 & 0x0f) << 8) | rs_err1);
901 fail:
902 return ret;
903 }
904
905 static int lg2161_read_rs_err_count(struct lg216x_state *state, u16 *err)
906 {
907 u8 rs_err1, rs_err2;
908 int ret;
909
910 *err = 0;
911
912 ret = lg216x_read_reg(state, 0x0613, &rs_err1);
913 if (lg_fail(ret))
914 goto fail;
915
916 ret = lg216x_read_reg(state, 0x0614, &rs_err2);
917 if (lg_fail(ret))
918 goto fail;
919
920 *err = (u16)((rs_err1 << 8) | rs_err2);
921 fail:
922 return ret;
923 }
924
925 static int lg216x_read_rs_err_count(struct lg216x_state *state, u16 *err)
926 {
927 int ret;
928 switch (state->cfg->lg_chip) {
929 case LG2160:
930 ret = lg2160_read_rs_err_count(state, err);
931 break;
932 case LG2161:
933 ret = lg2161_read_rs_err_count(state, err);
934 break;
935 default:
936 ret = -EINVAL;
937 break;
938 }
939 return ret;
940 }
941 #endif
942
943 /* ------------------------------------------------------------------------ */
944
945 static int lg216x_get_frontend(struct dvb_frontend *fe)
946 {
947 struct lg216x_state *state = fe->demodulator_priv;
948 int ret;
949
950 lg_dbg("\n");
951
952 fe->dtv_property_cache.modulation = VSB_8;
953 fe->dtv_property_cache.frequency = state->current_frequency;
954 fe->dtv_property_cache.delivery_system = SYS_ATSCMH;
955
956 ret = lg216x_get_fic_version(state,
957 &fe->dtv_property_cache.atscmh_fic_ver);
958 if (lg_fail(ret))
959 goto fail;
960 if (state->fic_ver != fe->dtv_property_cache.atscmh_fic_ver) {
961 state->fic_ver = fe->dtv_property_cache.atscmh_fic_ver;
962
963 #if 0
964 ret = lg2160_get_parade_id(state,
965 &fe->dtv_property_cache.atscmh_parade_id);
966 if (lg_fail(ret))
967 goto fail;
968 /* #else */
969 fe->dtv_property_cache.atscmh_parade_id = state->parade_id;
970 #endif
971 ret = lg216x_get_nog(state,
972 &fe->dtv_property_cache.atscmh_nog);
973 if (lg_fail(ret))
974 goto fail;
975 ret = lg216x_get_tnog(state,
976 &fe->dtv_property_cache.atscmh_tnog);
977 if (lg_fail(ret))
978 goto fail;
979 ret = lg216x_get_sgn(state,
980 &fe->dtv_property_cache.atscmh_sgn);
981 if (lg_fail(ret))
982 goto fail;
983 ret = lg216x_get_prc(state,
984 &fe->dtv_property_cache.atscmh_prc);
985 if (lg_fail(ret))
986 goto fail;
987
988 ret = lg216x_get_rs_frame_mode(state,
989 (enum atscmh_rs_frame_mode *)
990 &fe->dtv_property_cache.atscmh_rs_frame_mode);
991 if (lg_fail(ret))
992 goto fail;
993 ret = lg216x_get_rs_frame_ensemble(state,
994 (enum atscmh_rs_frame_ensemble *)
995 &fe->dtv_property_cache.atscmh_rs_frame_ensemble);
996 if (lg_fail(ret))
997 goto fail;
998 ret = lg216x_get_rs_code_mode(state,
999 (enum atscmh_rs_code_mode *)
1000 &fe->dtv_property_cache.atscmh_rs_code_mode_pri,
1001 (enum atscmh_rs_code_mode *)
1002 &fe->dtv_property_cache.atscmh_rs_code_mode_sec);
1003 if (lg_fail(ret))
1004 goto fail;
1005 ret = lg216x_get_sccc_block_mode(state,
1006 (enum atscmh_sccc_block_mode *)
1007 &fe->dtv_property_cache.atscmh_sccc_block_mode);
1008 if (lg_fail(ret))
1009 goto fail;
1010 ret = lg216x_get_sccc_code_mode(state,
1011 (enum atscmh_sccc_code_mode *)
1012 &fe->dtv_property_cache.atscmh_sccc_code_mode_a,
1013 (enum atscmh_sccc_code_mode *)
1014 &fe->dtv_property_cache.atscmh_sccc_code_mode_b,
1015 (enum atscmh_sccc_code_mode *)
1016 &fe->dtv_property_cache.atscmh_sccc_code_mode_c,
1017 (enum atscmh_sccc_code_mode *)
1018 &fe->dtv_property_cache.atscmh_sccc_code_mode_d);
1019 if (lg_fail(ret))
1020 goto fail;
1021 }
1022 #if 0
1023 ret = lg216x_read_fic_err_count(state,
1024 (u8 *)&fe->dtv_property_cache.atscmh_fic_err);
1025 if (lg_fail(ret))
1026 goto fail;
1027 ret = lg216x_read_crc_err_count(state,
1028 &fe->dtv_property_cache.atscmh_crc_err);
1029 if (lg_fail(ret))
1030 goto fail;
1031 ret = lg216x_read_rs_err_count(state,
1032 &fe->dtv_property_cache.atscmh_rs_err);
1033 if (lg_fail(ret))
1034 goto fail;
1035
1036 switch (state->cfg->lg_chip) {
1037 case LG2160:
1038 if (((fe->dtv_property_cache.atscmh_rs_err >= 240) &&
1039 (fe->dtv_property_cache.atscmh_crc_err >= 240)) &&
1040 ((jiffies_to_msecs(jiffies) - state->last_reset) > 6000))
1041 ret = lg216x_soft_reset(state);
1042 break;
1043 case LG2161:
1044 /* no fix needed here (as far as we know) */
1045 ret = 0;
1046 break;
1047 }
1048 lg_fail(ret);
1049 #endif
1050 fail:
1051 return ret;
1052 }
1053
1054 static int lg216x_get_property(struct dvb_frontend *fe,
1055 struct dtv_property *tvp)
1056 {
1057 return (DTV_ATSCMH_FIC_VER == tvp->cmd) ?
1058 lg216x_get_frontend(fe) : 0;
1059 }
1060
1061
1062 static int lg2160_set_frontend(struct dvb_frontend *fe)
1063 {
1064 struct lg216x_state *state = fe->demodulator_priv;
1065 int ret;
1066
1067 lg_dbg("(%d)\n", fe->dtv_property_cache.frequency);
1068
1069 if (fe->ops.tuner_ops.set_params) {
1070 ret = fe->ops.tuner_ops.set_params(fe);
1071 if (fe->ops.i2c_gate_ctrl)
1072 fe->ops.i2c_gate_ctrl(fe, 0);
1073 if (lg_fail(ret))
1074 goto fail;
1075 state->current_frequency = fe->dtv_property_cache.frequency;
1076 }
1077
1078 ret = lg2160_agc_fix(state, 0, 0);
1079 if (lg_fail(ret))
1080 goto fail;
1081 ret = lg2160_agc_polarity(state, 0, 0);
1082 if (lg_fail(ret))
1083 goto fail;
1084 ret = lg2160_tuner_pwr_save_polarity(state, 1);
1085 if (lg_fail(ret))
1086 goto fail;
1087 ret = lg216x_set_if(state);
1088 if (lg_fail(ret))
1089 goto fail;
1090 ret = lg2160_spectrum_polarity(state, state->cfg->spectral_inversion);
1091 if (lg_fail(ret))
1092 goto fail;
1093
1094 /* be tuned before this point */
1095 ret = lg216x_soft_reset(state);
1096 if (lg_fail(ret))
1097 goto fail;
1098
1099 ret = lg2160_tuner_pwr_save(state, 0);
1100 if (lg_fail(ret))
1101 goto fail;
1102
1103 switch (state->cfg->lg_chip) {
1104 case LG2160:
1105 ret = lg2160_set_spi_clock(state);
1106 if (lg_fail(ret))
1107 goto fail;
1108 break;
1109 case LG2161:
1110 ret = lg2161_set_output_interface(state);
1111 if (lg_fail(ret))
1112 goto fail;
1113 break;
1114 }
1115
1116 ret = lg216x_set_parade(state, fe->dtv_property_cache.atscmh_parade_id);
1117 if (lg_fail(ret))
1118 goto fail;
1119
1120 ret = lg216x_set_ensemble(state,
1121 fe->dtv_property_cache.atscmh_rs_frame_ensemble);
1122 if (lg_fail(ret))
1123 goto fail;
1124
1125 ret = lg216x_initialize(state);
1126 if (lg_fail(ret))
1127 goto fail;
1128
1129 ret = lg216x_enable_fic(state, 1);
1130 lg_fail(ret);
1131
1132 lg216x_get_frontend(fe);
1133 fail:
1134 return ret;
1135 }
1136
1137 /* ------------------------------------------------------------------------ */
1138
1139 static int lg2160_read_lock_status(struct lg216x_state *state,
1140 int *acq_lock, int *sync_lock)
1141 {
1142 u8 val;
1143 int ret;
1144
1145 *acq_lock = 0;
1146 *sync_lock = 0;
1147
1148 ret = lg216x_read_reg(state, 0x011b, &val);
1149 if (lg_fail(ret))
1150 goto fail;
1151
1152 *sync_lock = (val & 0x20) ? 0 : 1;
1153 *acq_lock = (val & 0x40) ? 0 : 1;
1154 fail:
1155 return ret;
1156 }
1157
1158 #ifdef USE_LG2161_LOCK_BITS
1159 static int lg2161_read_lock_status(struct lg216x_state *state,
1160 int *acq_lock, int *sync_lock)
1161 {
1162 u8 val;
1163 int ret;
1164
1165 *acq_lock = 0;
1166 *sync_lock = 0;
1167
1168 ret = lg216x_read_reg(state, 0x0304, &val);
1169 if (lg_fail(ret))
1170 goto fail;
1171
1172 *sync_lock = (val & 0x80) ? 0 : 1;
1173
1174 ret = lg216x_read_reg(state, 0x011b, &val);
1175 if (lg_fail(ret))
1176 goto fail;
1177
1178 *acq_lock = (val & 0x40) ? 0 : 1;
1179 fail:
1180 return ret;
1181 }
1182 #endif
1183
1184 static int lg216x_read_lock_status(struct lg216x_state *state,
1185 int *acq_lock, int *sync_lock)
1186 {
1187 #ifdef USE_LG2161_LOCK_BITS
1188 int ret;
1189 switch (state->cfg->lg_chip) {
1190 case LG2160:
1191 ret = lg2160_read_lock_status(state, acq_lock, sync_lock);
1192 break;
1193 case LG2161:
1194 ret = lg2161_read_lock_status(state, acq_lock, sync_lock);
1195 break;
1196 default:
1197 ret = -EINVAL;
1198 break;
1199 }
1200 return ret;
1201 #else
1202 return lg2160_read_lock_status(state, acq_lock, sync_lock);
1203 #endif
1204 }
1205
1206 static int lg216x_read_status(struct dvb_frontend *fe, fe_status_t *status)
1207 {
1208 struct lg216x_state *state = fe->demodulator_priv;
1209 int ret, acq_lock, sync_lock;
1210
1211 *status = 0;
1212
1213 ret = lg216x_read_lock_status(state, &acq_lock, &sync_lock);
1214 if (lg_fail(ret))
1215 goto fail;
1216
1217 lg_dbg("%s%s\n",
1218 acq_lock ? "SIGNALEXIST " : "",
1219 sync_lock ? "SYNCLOCK" : "");
1220
1221 if (acq_lock)
1222 *status |= FE_HAS_SIGNAL;
1223 if (sync_lock)
1224 *status |= FE_HAS_SYNC;
1225
1226 if (*status)
1227 *status |= FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_LOCK;
1228
1229 fail:
1230 return ret;
1231 }
1232
1233 /* ------------------------------------------------------------------------ */
1234
1235 static int lg2160_read_snr(struct dvb_frontend *fe, u16 *snr)
1236 {
1237 struct lg216x_state *state = fe->demodulator_priv;
1238 u8 snr1, snr2;
1239 int ret;
1240
1241 *snr = 0;
1242
1243 ret = lg216x_read_reg(state, 0x0202, &snr1);
1244 if (lg_fail(ret))
1245 goto fail;
1246
1247 ret = lg216x_read_reg(state, 0x0203, &snr2);
1248 if (lg_fail(ret))
1249 goto fail;
1250
1251 if ((snr1 == 0xba) || (snr2 == 0xdf))
1252 *snr = 0;
1253 else
1254 #if 1
1255 *snr = ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 >> 4);
1256 #else /* BCD */
1257 *snr = (snr2 | (snr1 << 8));
1258 #endif
1259 fail:
1260 return ret;
1261 }
1262
1263 static int lg2161_read_snr(struct dvb_frontend *fe, u16 *snr)
1264 {
1265 struct lg216x_state *state = fe->demodulator_priv;
1266 u8 snr1, snr2;
1267 int ret;
1268
1269 *snr = 0;
1270
1271 ret = lg216x_read_reg(state, 0x0302, &snr1);
1272 if (lg_fail(ret))
1273 goto fail;
1274
1275 ret = lg216x_read_reg(state, 0x0303, &snr2);
1276 if (lg_fail(ret))
1277 goto fail;
1278
1279 if ((snr1 == 0xba) || (snr2 == 0xfd))
1280 *snr = 0;
1281 else
1282
1283 *snr = ((snr1 >> 4) * 100) + ((snr1 & 0x0f) * 10) + (snr2 & 0x0f);
1284 fail:
1285 return ret;
1286 }
1287
1288 static int lg216x_read_signal_strength(struct dvb_frontend *fe,
1289 u16 *strength)
1290 {
1291 #if 0
1292 /* borrowed from lgdt330x.c
1293 *
1294 * Calculate strength from SNR up to 35dB
1295 * Even though the SNR can go higher than 35dB,
1296 * there is some comfort factor in having a range of
1297 * strong signals that can show at 100%
1298 */
1299 struct lg216x_state *state = fe->demodulator_priv;
1300 u16 snr;
1301 int ret;
1302 #endif
1303 *strength = 0;
1304 #if 0
1305 ret = fe->ops.read_snr(fe, &snr);
1306 if (lg_fail(ret))
1307 goto fail;
1308 /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
1309 /* scale the range 0 - 35*2^24 into 0 - 65535 */
1310 if (state->snr >= 8960 * 0x10000)
1311 *strength = 0xffff;
1312 else
1313 *strength = state->snr / 8960;
1314 fail:
1315 return ret;
1316 #else
1317 return 0;
1318 #endif
1319 }
1320
1321 /* ------------------------------------------------------------------------ */
1322
1323 static int lg216x_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1324 {
1325 #if 0
1326 struct lg216x_state *state = fe->demodulator_priv;
1327 int ret;
1328
1329 ret = lg216x_read_rs_err_count(state,
1330 &fe->dtv_property_cache.atscmh_rs_err);
1331 if (lg_fail(ret))
1332 goto fail;
1333
1334 *ucblocks = fe->dtv_property_cache.atscmh_rs_err;
1335 fail:
1336 #else
1337 *ucblocks = 0;
1338 #endif
1339 return 0;
1340 }
1341
1342 static int lg216x_get_tune_settings(struct dvb_frontend *fe,
1343 struct dvb_frontend_tune_settings
1344 *fe_tune_settings)
1345 {
1346 fe_tune_settings->min_delay_ms = 500;
1347 lg_dbg("\n");
1348 return 0;
1349 }
1350
1351 static void lg216x_release(struct dvb_frontend *fe)
1352 {
1353 struct lg216x_state *state = fe->demodulator_priv;
1354 lg_dbg("\n");
1355 kfree(state);
1356 }
1357
1358 static struct dvb_frontend_ops lg2160_ops = {
1359 .delsys = { SYS_ATSCMH },
1360 .info = {
1361 .name = "LG Electronics LG2160 ATSC/MH Frontend",
1362 .frequency_min = 54000000,
1363 .frequency_max = 858000000,
1364 .frequency_stepsize = 62500,
1365 },
1366 .i2c_gate_ctrl = lg216x_i2c_gate_ctrl,
1367 #if 0
1368 .init = lg216x_init,
1369 .sleep = lg216x_sleep,
1370 #endif
1371 .get_property = lg216x_get_property,
1372
1373 .set_frontend = lg2160_set_frontend,
1374 .get_frontend = lg216x_get_frontend,
1375 .get_tune_settings = lg216x_get_tune_settings,
1376 .read_status = lg216x_read_status,
1377 #if 0
1378 .read_ber = lg216x_read_ber,
1379 #endif
1380 .read_signal_strength = lg216x_read_signal_strength,
1381 .read_snr = lg2160_read_snr,
1382 .read_ucblocks = lg216x_read_ucblocks,
1383 .release = lg216x_release,
1384 };
1385
1386 static struct dvb_frontend_ops lg2161_ops = {
1387 .delsys = { SYS_ATSCMH },
1388 .info = {
1389 .name = "LG Electronics LG2161 ATSC/MH Frontend",
1390 .frequency_min = 54000000,
1391 .frequency_max = 858000000,
1392 .frequency_stepsize = 62500,
1393 },
1394 .i2c_gate_ctrl = lg216x_i2c_gate_ctrl,
1395 #if 0
1396 .init = lg216x_init,
1397 .sleep = lg216x_sleep,
1398 #endif
1399 .get_property = lg216x_get_property,
1400
1401 .set_frontend = lg2160_set_frontend,
1402 .get_frontend = lg216x_get_frontend,
1403 .get_tune_settings = lg216x_get_tune_settings,
1404 .read_status = lg216x_read_status,
1405 #if 0
1406 .read_ber = lg216x_read_ber,
1407 #endif
1408 .read_signal_strength = lg216x_read_signal_strength,
1409 .read_snr = lg2161_read_snr,
1410 .read_ucblocks = lg216x_read_ucblocks,
1411 .release = lg216x_release,
1412 };
1413
1414 struct dvb_frontend *lg2160_attach(const struct lg2160_config *config,
1415 struct i2c_adapter *i2c_adap)
1416 {
1417 struct lg216x_state *state = NULL;
1418
1419 lg_dbg("(%d-%04x)\n",
1420 i2c_adap ? i2c_adapter_id(i2c_adap) : 0,
1421 config ? config->i2c_addr : 0);
1422
1423 state = kzalloc(sizeof(struct lg216x_state), GFP_KERNEL);
1424 if (!state)
1425 return NULL;
1426
1427 state->cfg = config;
1428 state->i2c_adap = i2c_adap;
1429 state->fic_ver = 0xff;
1430 state->parade_id = 0xff;
1431
1432 switch (config->lg_chip) {
1433 default:
1434 lg_warn("invalid chip requested, defaulting to LG2160");
1435 /* fall-thru */
1436 case LG2160:
1437 memcpy(&state->frontend.ops, &lg2160_ops,
1438 sizeof(struct dvb_frontend_ops));
1439 break;
1440 case LG2161:
1441 memcpy(&state->frontend.ops, &lg2161_ops,
1442 sizeof(struct dvb_frontend_ops));
1443 break;
1444 }
1445
1446 state->frontend.demodulator_priv = state;
1447 state->current_frequency = -1;
1448 /* parade 1 by default */
1449 state->frontend.dtv_property_cache.atscmh_parade_id = 1;
1450
1451 return &state->frontend;
1452 }
1453 EXPORT_SYMBOL(lg2160_attach);
1454
1455 MODULE_DESCRIPTION("LG Electronics LG216x ATSC/MH Demodulator Driver");
1456 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1457 MODULE_LICENSE("GPL");
1458 MODULE_VERSION("0.3");
(deprecated) Btrfs devel tree