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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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
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 
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 
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 
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 
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 
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 
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
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 		fallthrough;
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