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