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