1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <linux/kernel.h>
37#include <linux/module.h>
38#include <linux/init.h>
39#include <linux/delay.h>
40#include <linux/string.h>
41#include <linux/slab.h>
42#include <asm/byteorder.h>
43
44#include "dvb_frontend.h"
45#include "dvb_math.h"
46#include "lgdt330x_priv.h"
47#include "lgdt330x.h"
48
49
50
51
52static int debug;
53module_param(debug, int, 0644);
54MODULE_PARM_DESC(debug,"Turn on/off lgdt330x frontend debugging (default:off).");
55#define dprintk(args...) \
56do { \
57if (debug) printk(KERN_DEBUG "lgdt330x: " args); \
58} while (0)
59
60struct lgdt330x_state
61{
62 struct i2c_adapter* i2c;
63
64
65 const struct lgdt330x_config* config;
66
67 struct dvb_frontend frontend;
68
69
70 enum fe_modulation current_modulation;
71 u32 snr;
72
73
74 u32 current_frequency;
75};
76
77static int i2c_write_demod_bytes (struct lgdt330x_state* state,
78 u8 *buf,
79 int len )
80{
81 struct i2c_msg msg =
82 { .addr = state->config->demod_address,
83 .flags = 0,
84 .buf = buf,
85 .len = 2 };
86 int i;
87 int err;
88
89 for (i=0; i<len-1; i+=2){
90 if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
91 printk(KERN_WARNING "lgdt330x: %s error (addr %02x <- %02x, err = %i)\n", __func__, msg.buf[0], msg.buf[1], err);
92 if (err < 0)
93 return err;
94 else
95 return -EREMOTEIO;
96 }
97 msg.buf += 2;
98 }
99 return 0;
100}
101
102
103
104
105
106
107static int i2c_read_demod_bytes(struct lgdt330x_state *state,
108 enum I2C_REG reg, u8 *buf, int len)
109{
110 u8 wr [] = { reg };
111 struct i2c_msg msg [] = {
112 { .addr = state->config->demod_address,
113 .flags = 0, .buf = wr, .len = 1 },
114 { .addr = state->config->demod_address,
115 .flags = I2C_M_RD, .buf = buf, .len = len },
116 };
117 int ret;
118 ret = i2c_transfer(state->i2c, msg, 2);
119 if (ret != 2) {
120 printk(KERN_WARNING "lgdt330x: %s: addr 0x%02x select 0x%02x error (ret == %i)\n", __func__, state->config->demod_address, reg, ret);
121 if (ret >= 0)
122 ret = -EIO;
123 } else {
124 ret = 0;
125 }
126 return ret;
127}
128
129
130static int lgdt3302_SwReset(struct lgdt330x_state* state)
131{
132 u8 ret;
133 u8 reset[] = {
134 IRQ_MASK,
135 0x00
136
137 };
138
139 ret = i2c_write_demod_bytes(state,
140 reset, sizeof(reset));
141 if (ret == 0) {
142
143
144 reset[1] = 0x7f;
145 ret = i2c_write_demod_bytes(state,
146 reset, sizeof(reset));
147 }
148 return ret;
149}
150
151static int lgdt3303_SwReset(struct lgdt330x_state* state)
152{
153 u8 ret;
154 u8 reset[] = {
155 0x02,
156 0x00
157 };
158
159 ret = i2c_write_demod_bytes(state,
160 reset, sizeof(reset));
161 if (ret == 0) {
162
163
164 reset[1] = 0x01;
165 ret = i2c_write_demod_bytes(state,
166 reset, sizeof(reset));
167 }
168 return ret;
169}
170
171static int lgdt330x_SwReset(struct lgdt330x_state* state)
172{
173 switch (state->config->demod_chip) {
174 case LGDT3302:
175 return lgdt3302_SwReset(state);
176 case LGDT3303:
177 return lgdt3303_SwReset(state);
178 default:
179 return -ENODEV;
180 }
181}
182
183static int lgdt330x_init(struct dvb_frontend* fe)
184{
185
186
187
188
189
190
191
192
193
194
195 static u8 lgdt3302_init_data[] = {
196
197
198
199 VSB_CARRIER_FREQ0, 0x00,
200 VSB_CARRIER_FREQ1, 0x87,
201 VSB_CARRIER_FREQ2, 0x8e,
202 VSB_CARRIER_FREQ3, 0x01,
203
204
205 DEMUX_CONTROL, 0xfb,
206
207
208 AGC_RF_BANDWIDTH0, 0x40,
209 AGC_RF_BANDWIDTH1, 0x93,
210 AGC_RF_BANDWIDTH2, 0x00,
211
212
213 AGC_FUNC_CTRL2, 0xc6,
214
215
216 AGC_FUNC_CTRL3, 0x40,
217
218
219 AGC_DELAY0, 0x07,
220 AGC_DELAY2, 0xfe,
221
222
223 AGC_LOOP_BANDWIDTH0, 0x08,
224 AGC_LOOP_BANDWIDTH1, 0x9a
225 };
226
227 static u8 lgdt3303_init_data[] = {
228 0x4c, 0x14
229 };
230
231 static u8 flip_1_lgdt3303_init_data[] = {
232 0x4c, 0x14,
233 0x87, 0xf3
234 };
235
236 static u8 flip_2_lgdt3303_init_data[] = {
237 0x4c, 0x14,
238 0x87, 0xda
239 };
240
241 struct lgdt330x_state* state = fe->demodulator_priv;
242 char *chip_name;
243 int err;
244
245 switch (state->config->demod_chip) {
246 case LGDT3302:
247 chip_name = "LGDT3302";
248 err = i2c_write_demod_bytes(state, lgdt3302_init_data,
249 sizeof(lgdt3302_init_data));
250 break;
251 case LGDT3303:
252 chip_name = "LGDT3303";
253 switch (state->config->clock_polarity_flip) {
254 case 2:
255 err = i2c_write_demod_bytes(state,
256 flip_2_lgdt3303_init_data,
257 sizeof(flip_2_lgdt3303_init_data));
258 break;
259 case 1:
260 err = i2c_write_demod_bytes(state,
261 flip_1_lgdt3303_init_data,
262 sizeof(flip_1_lgdt3303_init_data));
263 break;
264 case 0:
265 default:
266 err = i2c_write_demod_bytes(state, lgdt3303_init_data,
267 sizeof(lgdt3303_init_data));
268 }
269 break;
270 default:
271 chip_name = "undefined";
272 printk (KERN_WARNING "Only LGDT3302 and LGDT3303 are supported chips.\n");
273 err = -ENODEV;
274 }
275 dprintk("%s entered as %s\n", __func__, chip_name);
276 if (err < 0)
277 return err;
278 return lgdt330x_SwReset(state);
279}
280
281static int lgdt330x_read_ber(struct dvb_frontend* fe, u32* ber)
282{
283 *ber = 0;
284 return 0;
285}
286
287static int lgdt330x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
288{
289 struct lgdt330x_state* state = fe->demodulator_priv;
290 int err;
291 u8 buf[2];
292
293 *ucblocks = 0;
294
295 switch (state->config->demod_chip) {
296 case LGDT3302:
297 err = i2c_read_demod_bytes(state, LGDT3302_PACKET_ERR_COUNTER1,
298 buf, sizeof(buf));
299 break;
300 case LGDT3303:
301 err = i2c_read_demod_bytes(state, LGDT3303_PACKET_ERR_COUNTER1,
302 buf, sizeof(buf));
303 break;
304 default:
305 printk(KERN_WARNING
306 "Only LGDT3302 and LGDT3303 are supported chips.\n");
307 err = -ENODEV;
308 }
309 if (err < 0)
310 return err;
311
312 *ucblocks = (buf[0] << 8) | buf[1];
313 return 0;
314}
315
316static int lgdt330x_set_parameters(struct dvb_frontend *fe)
317{
318 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
319
320
321
322
323 static u8 lgdt3303_8vsb_44_data[] = {
324 0x04, 0x00,
325 0x0d, 0x40,
326 0x0e, 0x87,
327 0x0f, 0x8e,
328 0x10, 0x01,
329 0x47, 0x8b };
330
331
332
333
334
335 static u8 lgdt3303_qam_data[] = {
336 0x04, 0x00,
337 0x0d, 0x00,
338 0x0e, 0x00,
339 0x0f, 0x00,
340 0x10, 0x00,
341 0x51, 0x63,
342 0x47, 0x66,
343 0x48, 0x66,
344 0x4d, 0x1a,
345 0x49, 0x08,
346 0x4a, 0x9b };
347
348 struct lgdt330x_state* state = fe->demodulator_priv;
349
350 static u8 top_ctrl_cfg[] = { TOP_CONTROL, 0x03 };
351
352 int err = 0;
353
354 if (state->current_modulation != p->modulation) {
355 switch (p->modulation) {
356 case VSB_8:
357 dprintk("%s: VSB_8 MODE\n", __func__);
358
359
360 top_ctrl_cfg[1] = 0x03;
361
362
363 if (state->config->pll_rf_set)
364 state->config->pll_rf_set(fe, 1);
365
366 if (state->config->demod_chip == LGDT3303) {
367 err = i2c_write_demod_bytes(state, lgdt3303_8vsb_44_data,
368 sizeof(lgdt3303_8vsb_44_data));
369 }
370 break;
371
372 case QAM_64:
373 dprintk("%s: QAM_64 MODE\n", __func__);
374
375
376 top_ctrl_cfg[1] = 0x00;
377
378
379 if (state->config->pll_rf_set)
380 state->config->pll_rf_set(fe, 0);
381
382 if (state->config->demod_chip == LGDT3303) {
383 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
384 sizeof(lgdt3303_qam_data));
385 }
386 break;
387
388 case QAM_256:
389 dprintk("%s: QAM_256 MODE\n", __func__);
390
391
392 top_ctrl_cfg[1] = 0x01;
393
394
395 if (state->config->pll_rf_set)
396 state->config->pll_rf_set(fe, 0);
397
398 if (state->config->demod_chip == LGDT3303) {
399 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
400 sizeof(lgdt3303_qam_data));
401 }
402 break;
403 default:
404 printk(KERN_WARNING "lgdt330x: %s: Modulation type(%d) UNSUPPORTED\n", __func__, p->modulation);
405 return -1;
406 }
407 if (err < 0)
408 printk(KERN_WARNING "lgdt330x: %s: error blasting "
409 "bytes to lgdt3303 for modulation type(%d)\n",
410 __func__, p->modulation);
411
412
413
414
415
416
417 top_ctrl_cfg[1] |= state->config->serial_mpeg;
418
419
420 i2c_write_demod_bytes(state, top_ctrl_cfg,
421 sizeof(top_ctrl_cfg));
422 if (state->config->set_ts_params)
423 state->config->set_ts_params(fe, 0);
424 state->current_modulation = p->modulation;
425 }
426
427
428 if (fe->ops.tuner_ops.set_params) {
429 fe->ops.tuner_ops.set_params(fe);
430 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
431 }
432
433
434
435
436 state->current_frequency = p->frequency;
437
438 lgdt330x_SwReset(state);
439 return 0;
440}
441
442static int lgdt330x_get_frontend(struct dvb_frontend *fe,
443 struct dtv_frontend_properties *p)
444{
445 struct lgdt330x_state *state = fe->demodulator_priv;
446
447 p->frequency = state->current_frequency;
448 return 0;
449}
450
451static int lgdt3302_read_status(struct dvb_frontend *fe,
452 enum fe_status *status)
453{
454 struct lgdt330x_state* state = fe->demodulator_priv;
455 u8 buf[3];
456
457 *status = 0;
458
459
460 i2c_read_demod_bytes(state, AGC_STATUS, buf, 1);
461 dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
462 if ((buf[0] & 0x0c) == 0x8){
463
464
465 *status |= FE_HAS_SIGNAL;
466 }
467
468
469
470
471
472
473
474 i2c_read_demod_bytes(state, TOP_CONTROL, buf, sizeof(buf));
475 dprintk("%s: TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n", __func__, buf[0], buf[1], buf[2]);
476
477
478
479 if ((buf[2] & 0x03) == 0x01) {
480 *status |= FE_HAS_SYNC;
481 }
482
483
484 if ((buf[2] & 0x0c) == 0x08) {
485 *status |= FE_HAS_LOCK;
486 *status |= FE_HAS_VITERBI;
487 }
488
489
490 i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
491 dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
492 switch (state->current_modulation) {
493 case QAM_256:
494 case QAM_64:
495
496 if ((buf[0] & 0x07) == 0x07)
497 *status |= FE_HAS_CARRIER;
498 break;
499 case VSB_8:
500 if ((buf[0] & 0x80) == 0x80)
501 *status |= FE_HAS_CARRIER;
502 break;
503 default:
504 printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
505 }
506
507 return 0;
508}
509
510static int lgdt3303_read_status(struct dvb_frontend *fe,
511 enum fe_status *status)
512{
513 struct lgdt330x_state* state = fe->demodulator_priv;
514 int err;
515 u8 buf[3];
516
517 *status = 0;
518
519
520 err = i2c_read_demod_bytes(state, 0x58, buf, 1);
521 if (err < 0)
522 return err;
523
524 dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
525 if ((buf[0] & 0x21) == 0x01){
526
527
528 *status |= FE_HAS_SIGNAL;
529 }
530
531
532 i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
533 dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
534 switch (state->current_modulation) {
535 case QAM_256:
536 case QAM_64:
537
538 if ((buf[0] & 0x07) == 0x07)
539 *status |= FE_HAS_CARRIER;
540 else
541 break;
542 i2c_read_demod_bytes(state, 0x8a, buf, 1);
543 if ((buf[0] & 0x04) == 0x04)
544 *status |= FE_HAS_SYNC;
545 if ((buf[0] & 0x01) == 0x01)
546 *status |= FE_HAS_LOCK;
547 if ((buf[0] & 0x08) == 0x08)
548 *status |= FE_HAS_VITERBI;
549 break;
550 case VSB_8:
551 if ((buf[0] & 0x80) == 0x80)
552 *status |= FE_HAS_CARRIER;
553 else
554 break;
555 i2c_read_demod_bytes(state, 0x38, buf, 1);
556 if ((buf[0] & 0x02) == 0x00)
557 *status |= FE_HAS_SYNC;
558 if ((buf[0] & 0x01) == 0x01) {
559 *status |= FE_HAS_LOCK;
560 *status |= FE_HAS_VITERBI;
561 }
562 break;
563 default:
564 printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
565 }
566 return 0;
567}
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592static u32 calculate_snr(u32 mse, u32 c)
593{
594 if (mse == 0)
595 return 0;
596
597 mse = intlog10(mse);
598 if (mse > c) {
599
600
601
602 return 0;
603 }
604 return 10*(c - mse);
605}
606
607static int lgdt3302_read_snr(struct dvb_frontend* fe, u16* snr)
608{
609 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
610 u8 buf[5];
611 u32 noise;
612 u32 c;
613
614 switch(state->current_modulation) {
615 case VSB_8:
616 i2c_read_demod_bytes(state, LGDT3302_EQPH_ERR0, buf, 5);
617#ifdef USE_EQMSE
618
619
620 noise = ((buf[0] & 7) << 16) | (buf[1] << 8) | buf[2];
621 c = 69765745;
622#else
623
624
625 noise = ((buf[0] & 7<<3) << 13) | (buf[3] << 8) | buf[4];
626 c = 73957994;
627#endif
628 break;
629 case QAM_64:
630 case QAM_256:
631 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
632 noise = ((buf[0] & 3) << 8) | buf[1];
633 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
634
635 break;
636 default:
637 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
638 __func__);
639 return -EREMOTEIO;
640 }
641
642 state->snr = calculate_snr(noise, c);
643 *snr = (state->snr) >> 16;
644
645 dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
646 state->snr >> 24, (((state->snr>>8) & 0xffff) * 100) >> 16);
647
648 return 0;
649}
650
651static int lgdt3303_read_snr(struct dvb_frontend* fe, u16* snr)
652{
653 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
654 u8 buf[5];
655 u32 noise;
656 u32 c;
657
658 switch(state->current_modulation) {
659 case VSB_8:
660 i2c_read_demod_bytes(state, LGDT3303_EQPH_ERR0, buf, 5);
661#ifdef USE_EQMSE
662
663
664 noise = ((buf[0] & 0x78) << 13) | (buf[1] << 8) | buf[2];
665 c = 73957994;
666#else
667
668
669 noise = ((buf[0] & 7) << 16) | (buf[3] << 8) | buf[4];
670 c = 73957994;
671#endif
672 break;
673 case QAM_64:
674 case QAM_256:
675 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
676 noise = (buf[0] << 8) | buf[1];
677 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
678
679 break;
680 default:
681 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
682 __func__);
683 return -EREMOTEIO;
684 }
685
686 state->snr = calculate_snr(noise, c);
687 *snr = (state->snr) >> 16;
688
689 dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
690 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
691
692 return 0;
693}
694
695static int lgdt330x_read_signal_strength(struct dvb_frontend* fe, u16* strength)
696{
697
698
699
700 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
701 u16 snr;
702 int ret;
703
704 ret = fe->ops.read_snr(fe, &snr);
705 if (ret != 0)
706 return ret;
707
708
709 if (state->snr >= 8960 * 0x10000)
710 *strength = 0xffff;
711 else
712 *strength = state->snr / 8960;
713
714 return 0;
715}
716
717static int lgdt330x_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings)
718{
719
720 fe_tune_settings->min_delay_ms = 500;
721 fe_tune_settings->step_size = 0;
722 fe_tune_settings->max_drift = 0;
723 return 0;
724}
725
726static void lgdt330x_release(struct dvb_frontend* fe)
727{
728 struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
729 kfree(state);
730}
731
732static struct dvb_frontend_ops lgdt3302_ops;
733static struct dvb_frontend_ops lgdt3303_ops;
734
735struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
736 struct i2c_adapter* i2c)
737{
738 struct lgdt330x_state* state = NULL;
739 u8 buf[1];
740
741
742 state = kzalloc(sizeof(struct lgdt330x_state), GFP_KERNEL);
743 if (state == NULL)
744 goto error;
745
746
747 state->config = config;
748 state->i2c = i2c;
749
750
751 switch (config->demod_chip) {
752 case LGDT3302:
753 memcpy(&state->frontend.ops, &lgdt3302_ops, sizeof(struct dvb_frontend_ops));
754 break;
755 case LGDT3303:
756 memcpy(&state->frontend.ops, &lgdt3303_ops, sizeof(struct dvb_frontend_ops));
757 break;
758 default:
759 goto error;
760 }
761 state->frontend.demodulator_priv = state;
762
763
764 if (i2c_read_demod_bytes(state, 2, buf, 1))
765 goto error;
766
767 state->current_frequency = -1;
768 state->current_modulation = -1;
769
770 return &state->frontend;
771
772error:
773 kfree(state);
774 dprintk("%s: ERROR\n",__func__);
775 return NULL;
776}
777
778static struct dvb_frontend_ops lgdt3302_ops = {
779 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
780 .info = {
781 .name= "LG Electronics LGDT3302 VSB/QAM Frontend",
782 .frequency_min= 54000000,
783 .frequency_max= 858000000,
784 .frequency_stepsize= 62500,
785 .symbol_rate_min = 5056941,
786 .symbol_rate_max = 10762000,
787 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
788 },
789 .init = lgdt330x_init,
790 .set_frontend = lgdt330x_set_parameters,
791 .get_frontend = lgdt330x_get_frontend,
792 .get_tune_settings = lgdt330x_get_tune_settings,
793 .read_status = lgdt3302_read_status,
794 .read_ber = lgdt330x_read_ber,
795 .read_signal_strength = lgdt330x_read_signal_strength,
796 .read_snr = lgdt3302_read_snr,
797 .read_ucblocks = lgdt330x_read_ucblocks,
798 .release = lgdt330x_release,
799};
800
801static struct dvb_frontend_ops lgdt3303_ops = {
802 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
803 .info = {
804 .name= "LG Electronics LGDT3303 VSB/QAM Frontend",
805 .frequency_min= 54000000,
806 .frequency_max= 858000000,
807 .frequency_stepsize= 62500,
808 .symbol_rate_min = 5056941,
809 .symbol_rate_max = 10762000,
810 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
811 },
812 .init = lgdt330x_init,
813 .set_frontend = lgdt330x_set_parameters,
814 .get_frontend = lgdt330x_get_frontend,
815 .get_tune_settings = lgdt330x_get_tune_settings,
816 .read_status = lgdt3303_read_status,
817 .read_ber = lgdt330x_read_ber,
818 .read_signal_strength = lgdt330x_read_signal_strength,
819 .read_snr = lgdt3303_read_snr,
820 .read_ucblocks = lgdt330x_read_ucblocks,
821 .release = lgdt330x_release,
822};
823
824MODULE_DESCRIPTION("LGDT330X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
825MODULE_AUTHOR("Wilson Michaels");
826MODULE_LICENSE("GPL");
827
828EXPORT_SYMBOL(lgdt330x_attach);
829