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