Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
lg2160.c
Go to the documentation of this file.
1 /*
2  * Support for LG2160 - ATSC/MH
3  *
4  * Copyright (C) 2010 Michael Krufky <[email protected]>
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 {
55  const struct lg2160_config *cfg;
56 
58 
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 {
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,
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 
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 }
1454 
1455 MODULE_DESCRIPTION("LG Electronics LG216x ATSC/MH Demodulator Driver");
1456 MODULE_AUTHOR("Michael Krufky <[email protected]>");
1457 MODULE_LICENSE("GPL");
1458 MODULE_VERSION("0.3");
1459 
1460 /*
1461  * Local variables:
1462  * c-basic-offset: 8
1463  * End:
1464  */