?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / media / dvb-frontends / lgdt3305.c
blob62d743988919663d62189e9de4d58c68ffb63fa3
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Support for LG Electronics LGDT3304 and LGDT3305 - VSB/QAM
4 *
5 * Copyright (C) 2008, 2009, 2010 Michael Krufky <mkrufky@linuxtv.org>
6 *
7 * LGDT3304 support by Jarod Wilson <jarod@redhat.com>
8 */
9
10 #include <asm/div64.h>
11 #include <linux/dvb/frontend.h>
12 #include <linux/slab.h>
13 #include <media/dvb_math.h>
14 #include "lgdt3305.h"
15
16 static int debug;
17 module_param(debug, int, 0644);
18 MODULE_PARM_DESC(debug, "set debug level (info=1, reg=2 (or-able))");
19
20 #define DBG_INFO 1
21 #define DBG_REG 2
22
23 #define lg_printk(kern, fmt, arg...) \
24 printk(kern "%s: " fmt, __func__, ##arg)
25
26 #define lg_info(fmt, arg...) printk(KERN_INFO "lgdt3305: " fmt, ##arg)
27 #define lg_warn(fmt, arg...) lg_printk(KERN_WARNING, fmt, ##arg)
28 #define lg_err(fmt, arg...) lg_printk(KERN_ERR, fmt, ##arg)
29 #define lg_dbg(fmt, arg...) if (debug & DBG_INFO) \
30 lg_printk(KERN_DEBUG, fmt, ##arg)
31 #define lg_reg(fmt, arg...) if (debug & DBG_REG) \
32 lg_printk(KERN_DEBUG, fmt, ##arg)
33
34 #define lg_fail(ret) \
35 ({ \
36 int __ret; \
37 __ret = (ret < 0); \
38 if (__ret) \
39 lg_err("error %d on line %d\n", ret, __LINE__); \
40 __ret; \
41 })
42
43 struct lgdt3305_state {
44 struct i2c_adapter *i2c_adap;
45 const struct lgdt3305_config *cfg;
46
47 struct dvb_frontend frontend;
48
49 enum fe_modulation current_modulation;
50 u32 current_frequency;
51 u32 snr;
52 };
53
54 /* ------------------------------------------------------------------------ */
55
56 /* FIXME: verify & document the LGDT3304 registers */
57
58 #define LGDT3305_GEN_CTRL_1 0x0000
59 #define LGDT3305_GEN_CTRL_2 0x0001
60 #define LGDT3305_GEN_CTRL_3 0x0002
61 #define LGDT3305_GEN_STATUS 0x0003
62 #define LGDT3305_GEN_CONTROL 0x0007
63 #define LGDT3305_GEN_CTRL_4 0x000a
64 #define LGDT3305_DGTL_AGC_REF_1 0x0012
65 #define LGDT3305_DGTL_AGC_REF_2 0x0013
66 #define LGDT3305_CR_CTR_FREQ_1 0x0106
67 #define LGDT3305_CR_CTR_FREQ_2 0x0107
68 #define LGDT3305_CR_CTR_FREQ_3 0x0108
69 #define LGDT3305_CR_CTR_FREQ_4 0x0109
70 #define LGDT3305_CR_MSE_1 0x011b
71 #define LGDT3305_CR_MSE_2 0x011c
72 #define LGDT3305_CR_LOCK_STATUS 0x011d
73 #define LGDT3305_CR_CTRL_7 0x0126
74 #define LGDT3305_AGC_POWER_REF_1 0x0300
75 #define LGDT3305_AGC_POWER_REF_2 0x0301
76 #define LGDT3305_AGC_DELAY_PT_1 0x0302
77 #define LGDT3305_AGC_DELAY_PT_2 0x0303
78 #define LGDT3305_RFAGC_LOOP_FLTR_BW_1 0x0306
79 #define LGDT3305_RFAGC_LOOP_FLTR_BW_2 0x0307
80 #define LGDT3305_IFBW_1 0x0308
81 #define LGDT3305_IFBW_2 0x0309
82 #define LGDT3305_AGC_CTRL_1 0x030c
83 #define LGDT3305_AGC_CTRL_4 0x0314
84 #define LGDT3305_EQ_MSE_1 0x0413
85 #define LGDT3305_EQ_MSE_2 0x0414
86 #define LGDT3305_EQ_MSE_3 0x0415
87 #define LGDT3305_PT_MSE_1 0x0417
88 #define LGDT3305_PT_MSE_2 0x0418
89 #define LGDT3305_PT_MSE_3 0x0419
90 #define LGDT3305_FEC_BLOCK_CTRL 0x0504
91 #define LGDT3305_FEC_LOCK_STATUS 0x050a
92 #define LGDT3305_FEC_PKT_ERR_1 0x050c
93 #define LGDT3305_FEC_PKT_ERR_2 0x050d
94 #define LGDT3305_TP_CTRL_1 0x050e
95 #define LGDT3305_BERT_PERIOD 0x0801
96 #define LGDT3305_BERT_ERROR_COUNT_1 0x080a
97 #define LGDT3305_BERT_ERROR_COUNT_2 0x080b
98 #define LGDT3305_BERT_ERROR_COUNT_3 0x080c
99 #define LGDT3305_BERT_ERROR_COUNT_4 0x080d
100
101 static int lgdt3305_write_reg(struct lgdt3305_state *state, u16 reg, u8 val)
102 {
103 int ret;
104 u8 buf[] = { reg >> 8, reg & 0xff, val };
105 struct i2c_msg msg = {
106 .addr = state->cfg->i2c_addr, .flags = 0,
107 .buf = buf, .len = 3,
108 };
109
110 lg_reg("reg: 0x%04x, val: 0x%02x\n", reg, val);
111
112 ret = i2c_transfer(state->i2c_adap, &msg, 1);
113
114 if (ret != 1) {
115 lg_err("error (addr %02x %02x <- %02x, err = %i)\n",
116 msg.buf[0], msg.buf[1], msg.buf[2], ret);
117 if (ret < 0)
118 return ret;
119 else
120 return -EREMOTEIO;
121 }
122 return 0;
123 }
124
125 static int lgdt3305_read_reg(struct lgdt3305_state *state, u16 reg, u8 *val)
126 {
127 int ret;
128 u8 reg_buf[] = { reg >> 8, reg & 0xff };
129 struct i2c_msg msg[] = {
130 { .addr = state->cfg->i2c_addr,
131 .flags = 0, .buf = reg_buf, .len = 2 },
132 { .addr = state->cfg->i2c_addr,
133 .flags = I2C_M_RD, .buf = val, .len = 1 },
134 };
135
136 lg_reg("reg: 0x%04x\n", reg);
137
138 ret = i2c_transfer(state->i2c_adap, msg, 2);
139
140 if (ret != 2) {
141 lg_err("error (addr %02x reg %04x error (ret == %i)\n",
142 state->cfg->i2c_addr, reg, ret);
143 if (ret < 0)
144 return ret;
145 else
146 return -EREMOTEIO;
147 }
148 return 0;
149 }
150
151 #define read_reg(state, reg) \
152 ({ \
153 u8 __val; \
154 int ret = lgdt3305_read_reg(state, reg, &__val); \
155 if (lg_fail(ret)) \
156 __val = 0; \
157 __val; \
158 })
159
160 static int lgdt3305_set_reg_bit(struct lgdt3305_state *state,
161 u16 reg, int bit, int onoff)
162 {
163 u8 val;
164 int ret;
165
166 lg_reg("reg: 0x%04x, bit: %d, level: %d\n", reg, bit, onoff);
167
168 ret = lgdt3305_read_reg(state, reg, &val);
169 if (lg_fail(ret))
170 goto fail;
171
172 val &= ~(1 << bit);
173 val |= (onoff & 1) << bit;
174
175 ret = lgdt3305_write_reg(state, reg, val);
176 fail:
177 return ret;
178 }
179
180 struct lgdt3305_reg {
181 u16 reg;
182 u8 val;
183 };
184
185 static int lgdt3305_write_regs(struct lgdt3305_state *state,
186 struct lgdt3305_reg *regs, int len)
187 {
188 int i, ret;
189
190 lg_reg("writing %d registers...\n", len);
191
192 for (i = 0; i < len - 1; i++) {
193 ret = lgdt3305_write_reg(state, regs[i].reg, regs[i].val);
194 if (lg_fail(ret))
195 return ret;
196 }
197 return 0;
198 }
199
200 /* ------------------------------------------------------------------------ */
201
202 static int lgdt3305_soft_reset(struct lgdt3305_state *state)
203 {
204 int ret;
205
206 lg_dbg("\n");
207
208 ret = lgdt3305_set_reg_bit(state, LGDT3305_GEN_CTRL_3, 0, 0);
209 if (lg_fail(ret))
210 goto fail;
211
212 msleep(20);
213 ret = lgdt3305_set_reg_bit(state, LGDT3305_GEN_CTRL_3, 0, 1);
214 fail:
215 return ret;
216 }
217
218 static inline int lgdt3305_mpeg_mode(struct lgdt3305_state *state,
219 enum lgdt3305_mpeg_mode mode)
220 {
221 lg_dbg("(%d)\n", mode);
222 return lgdt3305_set_reg_bit(state, LGDT3305_TP_CTRL_1, 5, mode);
223 }
224
225 static int lgdt3305_mpeg_mode_polarity(struct lgdt3305_state *state)
226 {
227 u8 val;
228 int ret;
229 enum lgdt3305_tp_clock_edge edge = state->cfg->tpclk_edge;
230 enum lgdt3305_tp_clock_mode mode = state->cfg->tpclk_mode;
231 enum lgdt3305_tp_valid_polarity valid = state->cfg->tpvalid_polarity;
232
233 lg_dbg("edge = %d, valid = %d\n", edge, valid);
234
235 ret = lgdt3305_read_reg(state, LGDT3305_TP_CTRL_1, &val);
236 if (lg_fail(ret))
237 goto fail;
238
239 val &= ~0x09;
240
241 if (edge)
242 val |= 0x08;
243 if (mode)
244 val |= 0x40;
245 if (valid)
246 val |= 0x01;
247
248 ret = lgdt3305_write_reg(state, LGDT3305_TP_CTRL_1, val);
249 if (lg_fail(ret))
250 goto fail;
251
252 ret = lgdt3305_soft_reset(state);
253 fail:
254 return ret;
255 }
256
257 static int lgdt3305_set_modulation(struct lgdt3305_state *state,
258 struct dtv_frontend_properties *p)
259 {
260 u8 opermode;
261 int ret;
262
263 lg_dbg("\n");
264
265 ret = lgdt3305_read_reg(state, LGDT3305_GEN_CTRL_1, &opermode);
266 if (lg_fail(ret))
267 goto fail;
268
269 opermode &= ~0x03;
270
271 switch (p->modulation) {
272 case VSB_8:
273 opermode |= 0x03;
274 break;
275 case QAM_64:
276 opermode |= 0x00;
277 break;
278 case QAM_256:
279 opermode |= 0x01;
280 break;
281 default:
282 return -EINVAL;
283 }
284 ret = lgdt3305_write_reg(state, LGDT3305_GEN_CTRL_1, opermode);
285 fail:
286 return ret;
287 }
288
289 static int lgdt3305_set_filter_extension(struct lgdt3305_state *state,
290 struct dtv_frontend_properties *p)
291 {
292 int val;
293
294 switch (p->modulation) {
295 case VSB_8:
296 val = 0;
297 break;
298 case QAM_64:
299 case QAM_256:
300 val = 1;
301 break;
302 default:
303 return -EINVAL;
304 }
305 lg_dbg("val = %d\n", val);
306
307 return lgdt3305_set_reg_bit(state, 0x043f, 2, val);
308 }
309
310 /* ------------------------------------------------------------------------ */
311
312 static int lgdt3305_passband_digital_agc(struct lgdt3305_state *state,
313 struct dtv_frontend_properties *p)
314 {
315 u16 agc_ref;
316
317 switch (p->modulation) {
318 case VSB_8:
319 agc_ref = 0x32c4;
320 break;
321 case QAM_64:
322 agc_ref = 0x2a00;
323 break;
324 case QAM_256:
325 agc_ref = 0x2a80;
326 break;
327 default:
328 return -EINVAL;
329 }
330
331 lg_dbg("agc ref: 0x%04x\n", agc_ref);
332
333 lgdt3305_write_reg(state, LGDT3305_DGTL_AGC_REF_1, agc_ref >> 8);
334 lgdt3305_write_reg(state, LGDT3305_DGTL_AGC_REF_2, agc_ref & 0xff);
335
336 return 0;
337 }
338
339 static int lgdt3305_rfagc_loop(struct lgdt3305_state *state,
340 struct dtv_frontend_properties *p)
341 {
342 u16 ifbw, rfbw, agcdelay;
343
344 switch (p->modulation) {
345 case VSB_8:
346 agcdelay = 0x04c0;
347 rfbw = 0x8000;
348 ifbw = 0x8000;
349 break;
350 case QAM_64:
351 case QAM_256:
352 agcdelay = 0x046b;
353 rfbw = 0x8889;
354 /* FIXME: investigate optimal ifbw & rfbw values for the
355 * DT3304 and re-write this switch..case block */
356 if (state->cfg->demod_chip == LGDT3304)
357 ifbw = 0x6666;
358 else /* (state->cfg->demod_chip == LGDT3305) */
359 ifbw = 0x8888;
360 break;
361 default:
362 return -EINVAL;
363 }
364
365 if (state->cfg->rf_agc_loop) {
366 lg_dbg("agcdelay: 0x%04x, rfbw: 0x%04x\n", agcdelay, rfbw);
367
368 /* rf agc loop filter bandwidth */
369 lgdt3305_write_reg(state, LGDT3305_AGC_DELAY_PT_1,
370 agcdelay >> 8);
371 lgdt3305_write_reg(state, LGDT3305_AGC_DELAY_PT_2,
372 agcdelay & 0xff);
373
374 lgdt3305_write_reg(state, LGDT3305_RFAGC_LOOP_FLTR_BW_1,
375 rfbw >> 8);
376 lgdt3305_write_reg(state, LGDT3305_RFAGC_LOOP_FLTR_BW_2,
377 rfbw & 0xff);
378 } else {
379 lg_dbg("ifbw: 0x%04x\n", ifbw);
380
381 /* if agc loop filter bandwidth */
382 lgdt3305_write_reg(state, LGDT3305_IFBW_1, ifbw >> 8);
383 lgdt3305_write_reg(state, LGDT3305_IFBW_2, ifbw & 0xff);
384 }
385
386 return 0;
387 }
388
389 static int lgdt3305_agc_setup(struct lgdt3305_state *state,
390 struct dtv_frontend_properties *p)
391 {
392 int lockdten, acqen;
393
394 switch (p->modulation) {
395 case VSB_8:
396 lockdten = 0;
397 acqen = 0;
398 break;
399 case QAM_64:
400 case QAM_256:
401 lockdten = 1;
402 acqen = 1;
403 break;
404 default:
405 return -EINVAL;
406 }
407
408 lg_dbg("lockdten = %d, acqen = %d\n", lockdten, acqen);
409
410 /* control agc function */
411 switch (state->cfg->demod_chip) {
412 case LGDT3304:
413 lgdt3305_write_reg(state, 0x0314, 0xe1 | lockdten << 1);
414 lgdt3305_set_reg_bit(state, 0x030e, 2, acqen);
415 break;
416 case LGDT3305:
417 lgdt3305_write_reg(state, LGDT3305_AGC_CTRL_4, 0xe1 | lockdten << 1);
418 lgdt3305_set_reg_bit(state, LGDT3305_AGC_CTRL_1, 2, acqen);
419 break;
420 default:
421 return -EINVAL;
422 }
423
424 return lgdt3305_rfagc_loop(state, p);
425 }
426
427 static int lgdt3305_set_agc_power_ref(struct lgdt3305_state *state,
428 struct dtv_frontend_properties *p)
429 {
430 u16 usref = 0;
431
432 switch (p->modulation) {
433 case VSB_8:
434 if (state->cfg->usref_8vsb)
435 usref = state->cfg->usref_8vsb;
436 break;
437 case QAM_64:
438 if (state->cfg->usref_qam64)
439 usref = state->cfg->usref_qam64;
440 break;
441 case QAM_256:
442 if (state->cfg->usref_qam256)
443 usref = state->cfg->usref_qam256;
444 break;
445 default:
446 return -EINVAL;
447 }
448
449 if (usref) {
450 lg_dbg("set manual mode: 0x%04x\n", usref);
451
452 lgdt3305_set_reg_bit(state, LGDT3305_AGC_CTRL_1, 3, 1);
453
454 lgdt3305_write_reg(state, LGDT3305_AGC_POWER_REF_1,
455 0xff & (usref >> 8));
456 lgdt3305_write_reg(state, LGDT3305_AGC_POWER_REF_2,
457 0xff & (usref >> 0));
458 }
459 return 0;
460 }
461
462 /* ------------------------------------------------------------------------ */
463
464 static int lgdt3305_spectral_inversion(struct lgdt3305_state *state,
465 struct dtv_frontend_properties *p,
466 int inversion)
467 {
468 int ret;
469
470 lg_dbg("(%d)\n", inversion);
471
472 switch (p->modulation) {
473 case VSB_8:
474 ret = lgdt3305_write_reg(state, LGDT3305_CR_CTRL_7,
475 inversion ? 0xf9 : 0x79);
476 break;
477 case QAM_64:
478 case QAM_256:
479 ret = lgdt3305_write_reg(state, LGDT3305_FEC_BLOCK_CTRL,
480 inversion ? 0xfd : 0xff);
481 break;
482 default:
483 ret = -EINVAL;
484 }
485 return ret;
486 }
487
488 static int lgdt3305_set_if(struct lgdt3305_state *state,
489 struct dtv_frontend_properties *p)
490 {
491 u16 if_freq_khz;
492 u8 nco1, nco2, nco3, nco4;
493 u64 nco;
494
495 switch (p->modulation) {
496 case VSB_8:
497 if_freq_khz = state->cfg->vsb_if_khz;
498 break;
499 case QAM_64:
500 case QAM_256:
501 if_freq_khz = state->cfg->qam_if_khz;
502 break;
503 default:
504 return -EINVAL;
505 }
506
507 nco = if_freq_khz / 10;
508
509 switch (p->modulation) {
510 case VSB_8:
511 nco <<= 24;
512 do_div(nco, 625);
513 break;
514 case QAM_64:
515 case QAM_256:
516 nco <<= 28;
517 do_div(nco, 625);
518 break;
519 default:
520 return -EINVAL;
521 }
522
523 nco1 = (nco >> 24) & 0x3f;
524 nco1 |= 0x40;
525 nco2 = (nco >> 16) & 0xff;
526 nco3 = (nco >> 8) & 0xff;
527 nco4 = nco & 0xff;
528
529 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_1, nco1);
530 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_2, nco2);
531 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_3, nco3);
532 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_4, nco4);
533
534 lg_dbg("%d KHz -> [%02x%02x%02x%02x]\n",
535 if_freq_khz, nco1, nco2, nco3, nco4);
536
537 return 0;
538 }
539
540 /* ------------------------------------------------------------------------ */
541
542 static int lgdt3305_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
543 {
544 struct lgdt3305_state *state = fe->demodulator_priv;
545
546 if (state->cfg->deny_i2c_rptr)
547 return 0;
548
549 lg_dbg("(%d)\n", enable);
550
551 return lgdt3305_set_reg_bit(state, LGDT3305_GEN_CTRL_2, 5,
552 enable ? 0 : 1);
553 }
554
555 static int lgdt3305_sleep(struct dvb_frontend *fe)
556 {
557 struct lgdt3305_state *state = fe->demodulator_priv;
558 u8 gen_ctrl_3, gen_ctrl_4;
559
560 lg_dbg("\n");
561
562 gen_ctrl_3 = read_reg(state, LGDT3305_GEN_CTRL_3);
563 gen_ctrl_4 = read_reg(state, LGDT3305_GEN_CTRL_4);
564
565 /* hold in software reset while sleeping */
566 gen_ctrl_3 &= ~0x01;
567 /* tristate the IF-AGC pin */
568 gen_ctrl_3 |= 0x02;
569 /* tristate the RF-AGC pin */
570 gen_ctrl_3 |= 0x04;
571
572 /* disable vsb/qam module */
573 gen_ctrl_4 &= ~0x01;
574 /* disable adc module */
575 gen_ctrl_4 &= ~0x02;
576
577 lgdt3305_write_reg(state, LGDT3305_GEN_CTRL_3, gen_ctrl_3);
578 lgdt3305_write_reg(state, LGDT3305_GEN_CTRL_4, gen_ctrl_4);
579
580 return 0;
581 }
582
583 static int lgdt3305_init(struct dvb_frontend *fe)
584 {
585 struct lgdt3305_state *state = fe->demodulator_priv;
586 int ret;
587
588 static struct lgdt3305_reg lgdt3304_init_data[] = {
589 { .reg = LGDT3305_GEN_CTRL_1, .val = 0x03, },
590 { .reg = 0x000d, .val = 0x02, },
591 { .reg = 0x000e, .val = 0x02, },
592 { .reg = LGDT3305_DGTL_AGC_REF_1, .val = 0x32, },
593 { .reg = LGDT3305_DGTL_AGC_REF_2, .val = 0xc4, },
594 { .reg = LGDT3305_CR_CTR_FREQ_1, .val = 0x00, },
595 { .reg = LGDT3305_CR_CTR_FREQ_2, .val = 0x00, },
596 { .reg = LGDT3305_CR_CTR_FREQ_3, .val = 0x00, },
597 { .reg = LGDT3305_CR_CTR_FREQ_4, .val = 0x00, },
598 { .reg = LGDT3305_CR_CTRL_7, .val = 0xf9, },
599 { .reg = 0x0112, .val = 0x17, },
600 { .reg = 0x0113, .val = 0x15, },
601 { .reg = 0x0114, .val = 0x18, },
602 { .reg = 0x0115, .val = 0xff, },
603 { .reg = 0x0116, .val = 0x3c, },
604 { .reg = 0x0214, .val = 0x67, },
605 { .reg = 0x0424, .val = 0x8d, },
606 { .reg = 0x0427, .val = 0x12, },
607 { .reg = 0x0428, .val = 0x4f, },
608 { .reg = LGDT3305_IFBW_1, .val = 0x80, },
609 { .reg = LGDT3305_IFBW_2, .val = 0x00, },
610 { .reg = 0x030a, .val = 0x08, },
611 { .reg = 0x030b, .val = 0x9b, },
612 { .reg = 0x030d, .val = 0x00, },
613 { .reg = 0x030e, .val = 0x1c, },
614 { .reg = 0x0314, .val = 0xe1, },
615 { .reg = 0x000d, .val = 0x82, },
616 { .reg = LGDT3305_TP_CTRL_1, .val = 0x5b, },
617 { .reg = LGDT3305_TP_CTRL_1, .val = 0x5b, },
618 };
619
620 static struct lgdt3305_reg lgdt3305_init_data[] = {
621 { .reg = LGDT3305_GEN_CTRL_1, .val = 0x03, },
622 { .reg = LGDT3305_GEN_CTRL_2, .val = 0xb0, },
623 { .reg = LGDT3305_GEN_CTRL_3, .val = 0x01, },
624 { .reg = LGDT3305_GEN_CONTROL, .val = 0x6f, },
625 { .reg = LGDT3305_GEN_CTRL_4, .val = 0x03, },
626 { .reg = LGDT3305_DGTL_AGC_REF_1, .val = 0x32, },
627 { .reg = LGDT3305_DGTL_AGC_REF_2, .val = 0xc4, },
628 { .reg = LGDT3305_CR_CTR_FREQ_1, .val = 0x00, },
629 { .reg = LGDT3305_CR_CTR_FREQ_2, .val = 0x00, },
630 { .reg = LGDT3305_CR_CTR_FREQ_3, .val = 0x00, },
631 { .reg = LGDT3305_CR_CTR_FREQ_4, .val = 0x00, },
632 { .reg = LGDT3305_CR_CTRL_7, .val = 0x79, },
633 { .reg = LGDT3305_AGC_POWER_REF_1, .val = 0x32, },
634 { .reg = LGDT3305_AGC_POWER_REF_2, .val = 0xc4, },
635 { .reg = LGDT3305_AGC_DELAY_PT_1, .val = 0x0d, },
636 { .reg = LGDT3305_AGC_DELAY_PT_2, .val = 0x30, },
637 { .reg = LGDT3305_RFAGC_LOOP_FLTR_BW_1, .val = 0x80, },
638 { .reg = LGDT3305_RFAGC_LOOP_FLTR_BW_2, .val = 0x00, },
639 { .reg = LGDT3305_IFBW_1, .val = 0x80, },
640 { .reg = LGDT3305_IFBW_2, .val = 0x00, },
641 { .reg = LGDT3305_AGC_CTRL_1, .val = 0x30, },
642 { .reg = LGDT3305_AGC_CTRL_4, .val = 0x61, },
643 { .reg = LGDT3305_FEC_BLOCK_CTRL, .val = 0xff, },
644 { .reg = LGDT3305_TP_CTRL_1, .val = 0x1b, },
645 };
646
647 lg_dbg("\n");
648
649 switch (state->cfg->demod_chip) {
650 case LGDT3304:
651 ret = lgdt3305_write_regs(state, lgdt3304_init_data,
652 ARRAY_SIZE(lgdt3304_init_data));
653 break;
654 case LGDT3305:
655 ret = lgdt3305_write_regs(state, lgdt3305_init_data,
656 ARRAY_SIZE(lgdt3305_init_data));
657 break;
658 default:
659 ret = -EINVAL;
660 }
661 if (lg_fail(ret))
662 goto fail;
663
664 ret = lgdt3305_soft_reset(state);
665 fail:
666 return ret;
667 }
668
669 static int lgdt3304_set_parameters(struct dvb_frontend *fe)
670 {
671 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
672 struct lgdt3305_state *state = fe->demodulator_priv;
673 int ret;
674
675 lg_dbg("(%d, %d)\n", p->frequency, p->modulation);
676
677 if (fe->ops.tuner_ops.set_params) {
678 ret = fe->ops.tuner_ops.set_params(fe);
679 if (fe->ops.i2c_gate_ctrl)
680 fe->ops.i2c_gate_ctrl(fe, 0);
681 if (lg_fail(ret))
682 goto fail;
683 state->current_frequency = p->frequency;
684 }
685
686 ret = lgdt3305_set_modulation(state, p);
687 if (lg_fail(ret))
688 goto fail;
689
690 ret = lgdt3305_passband_digital_agc(state, p);
691 if (lg_fail(ret))
692 goto fail;
693
694 ret = lgdt3305_agc_setup(state, p);
695 if (lg_fail(ret))
696 goto fail;
697
698 /* reg 0x030d is 3304-only... seen in vsb and qam usbsnoops... */
699 switch (p->modulation) {
700 case VSB_8:
701 lgdt3305_write_reg(state, 0x030d, 0x00);
702 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_1, 0x4f);
703 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_2, 0x0c);
704 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_3, 0xac);
705 lgdt3305_write_reg(state, LGDT3305_CR_CTR_FREQ_4, 0xba);
706 break;
707 case QAM_64:
708 case QAM_256:
709 lgdt3305_write_reg(state, 0x030d, 0x14);
710 ret = lgdt3305_set_if(state, p);
711 if (lg_fail(ret))
712 goto fail;
713 break;
714 default:
715 return -EINVAL;
716 }
717
718
719 ret = lgdt3305_spectral_inversion(state, p,
720 state->cfg->spectral_inversion
721 ? 1 : 0);
722 if (lg_fail(ret))
723 goto fail;
724
725 state->current_modulation = p->modulation;
726
727 ret = lgdt3305_mpeg_mode(state, state->cfg->mpeg_mode);
728 if (lg_fail(ret))
729 goto fail;
730
731 /* lgdt3305_mpeg_mode_polarity calls lgdt3305_soft_reset */
732 ret = lgdt3305_mpeg_mode_polarity(state);
733 fail:
734 return ret;
735 }
736
737 static int lgdt3305_set_parameters(struct dvb_frontend *fe)
738 {
739 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
740 struct lgdt3305_state *state = fe->demodulator_priv;
741 int ret;
742
743 lg_dbg("(%d, %d)\n", p->frequency, p->modulation);
744
745 if (fe->ops.tuner_ops.set_params) {
746 ret = fe->ops.tuner_ops.set_params(fe);
747 if (fe->ops.i2c_gate_ctrl)
748 fe->ops.i2c_gate_ctrl(fe, 0);
749 if (lg_fail(ret))
750 goto fail;
751 state->current_frequency = p->frequency;
752 }
753
754 ret = lgdt3305_set_modulation(state, p);
755 if (lg_fail(ret))
756 goto fail;
757
758 ret = lgdt3305_passband_digital_agc(state, p);
759 if (lg_fail(ret))
760 goto fail;
761 ret = lgdt3305_set_agc_power_ref(state, p);
762 if (lg_fail(ret))
763 goto fail;
764 ret = lgdt3305_agc_setup(state, p);
765 if (lg_fail(ret))
766 goto fail;
767
768 /* low if */
769 ret = lgdt3305_write_reg(state, LGDT3305_GEN_CONTROL, 0x2f);
770 if (lg_fail(ret))
771 goto fail;
772 ret = lgdt3305_set_reg_bit(state, LGDT3305_CR_CTR_FREQ_1, 6, 1);
773 if (lg_fail(ret))
774 goto fail;
775
776 ret = lgdt3305_set_if(state, p);
777 if (lg_fail(ret))
778 goto fail;
779 ret = lgdt3305_spectral_inversion(state, p,
780 state->cfg->spectral_inversion
781 ? 1 : 0);
782 if (lg_fail(ret))
783 goto fail;
784
785 ret = lgdt3305_set_filter_extension(state, p);
786 if (lg_fail(ret))
787 goto fail;
788
789 state->current_modulation = p->modulation;
790
791 ret = lgdt3305_mpeg_mode(state, state->cfg->mpeg_mode);
792 if (lg_fail(ret))
793 goto fail;
794
795 /* lgdt3305_mpeg_mode_polarity calls lgdt3305_soft_reset */
796 ret = lgdt3305_mpeg_mode_polarity(state);
797 fail:
798 return ret;
799 }
800
801 static int lgdt3305_get_frontend(struct dvb_frontend *fe,
802 struct dtv_frontend_properties *p)
803 {
804 struct lgdt3305_state *state = fe->demodulator_priv;
805
806 lg_dbg("\n");
807
808 p->modulation = state->current_modulation;
809 p->frequency = state->current_frequency;
810 return 0;
811 }
812
813 /* ------------------------------------------------------------------------ */
814
815 static int lgdt3305_read_cr_lock_status(struct lgdt3305_state *state,
816 int *locked)
817 {
818 u8 val;
819 int ret;
820 char *cr_lock_state = "";
821
822 *locked = 0;
823
824 ret = lgdt3305_read_reg(state, LGDT3305_CR_LOCK_STATUS, &val);
825 if (lg_fail(ret))
826 goto fail;
827
828 switch (state->current_modulation) {
829 case QAM_256:
830 case QAM_64:
831 if (val & (1 << 1))
832 *locked = 1;
833
834 switch (val & 0x07) {
835 case 0:
836 cr_lock_state = "QAM UNLOCK";
837 break;
838 case 4:
839 cr_lock_state = "QAM 1stLock";
840 break;
841 case 6:
842 cr_lock_state = "QAM 2ndLock";
843 break;
844 case 7:
845 cr_lock_state = "QAM FinalLock";
846 break;
847 default:
848 cr_lock_state = "CLOCKQAM-INVALID!";
849 break;
850 }
851 break;
852 case VSB_8:
853 if (val & (1 << 7)) {
854 *locked = 1;
855 cr_lock_state = "CLOCKVSB";
856 }
857 break;
858 default:
859 ret = -EINVAL;
860 }
861 lg_dbg("(%d) %s\n", *locked, cr_lock_state);
862 fail:
863 return ret;
864 }
865
866 static int lgdt3305_read_fec_lock_status(struct lgdt3305_state *state,
867 int *locked)
868 {
869 u8 val;
870 int ret, mpeg_lock, fec_lock, viterbi_lock;
871
872 *locked = 0;
873
874 switch (state->current_modulation) {
875 case QAM_256:
876 case QAM_64:
877 ret = lgdt3305_read_reg(state,
878 LGDT3305_FEC_LOCK_STATUS, &val);
879 if (lg_fail(ret))
880 goto fail;
881
882 mpeg_lock = (val & (1 << 0)) ? 1 : 0;
883 fec_lock = (val & (1 << 2)) ? 1 : 0;
884 viterbi_lock = (val & (1 << 3)) ? 1 : 0;
885
886 *locked = mpeg_lock && fec_lock && viterbi_lock;
887
888 lg_dbg("(%d) %s%s%s\n", *locked,
889 mpeg_lock ? "mpeg lock " : "",
890 fec_lock ? "fec lock " : "",
891 viterbi_lock ? "viterbi lock" : "");
892 break;
893 case VSB_8:
894 default:
895 ret = -EINVAL;
896 }
897 fail:
898 return ret;
899 }
900
901 static int lgdt3305_read_status(struct dvb_frontend *fe, enum fe_status *status)
902 {
903 struct lgdt3305_state *state = fe->demodulator_priv;
904 u8 val;
905 int ret, signal, inlock, nofecerr, snrgood,
906 cr_lock, fec_lock, sync_lock;
907
908 *status = 0;
909
910 ret = lgdt3305_read_reg(state, LGDT3305_GEN_STATUS, &val);
911 if (lg_fail(ret))
912 goto fail;
913
914 signal = (val & (1 << 4)) ? 1 : 0;
915 inlock = (val & (1 << 3)) ? 0 : 1;
916 sync_lock = (val & (1 << 2)) ? 1 : 0;
917 nofecerr = (val & (1 << 1)) ? 1 : 0;
918 snrgood = (val & (1 << 0)) ? 1 : 0;
919
920 lg_dbg("%s%s%s%s%s\n",
921 signal ? "SIGNALEXIST " : "",
922 inlock ? "INLOCK " : "",
923 sync_lock ? "SYNCLOCK " : "",
924 nofecerr ? "NOFECERR " : "",
925 snrgood ? "SNRGOOD " : "");
926
927 ret = lgdt3305_read_cr_lock_status(state, &cr_lock);
928 if (lg_fail(ret))
929 goto fail;
930
931 if (signal)
932 *status |= FE_HAS_SIGNAL;
933 if (cr_lock)
934 *status |= FE_HAS_CARRIER;
935 if (nofecerr)
936 *status |= FE_HAS_VITERBI;
937 if (sync_lock)
938 *status |= FE_HAS_SYNC;
939
940 switch (state->current_modulation) {
941 case QAM_256:
942 case QAM_64:
943 /* signal bit is unreliable on the DT3304 in QAM mode */
944 if (((LGDT3304 == state->cfg->demod_chip)) && (cr_lock))
945 *status |= FE_HAS_SIGNAL;
946
947 ret = lgdt3305_read_fec_lock_status(state, &fec_lock);
948 if (lg_fail(ret))
949 goto fail;
950
951 if (fec_lock)
952 *status |= FE_HAS_LOCK;
953 break;
954 case VSB_8:
955 if (inlock)
956 *status |= FE_HAS_LOCK;
957 break;
958 default:
959 ret = -EINVAL;
960 }
961 fail:
962 return ret;
963 }
964
965 /* ------------------------------------------------------------------------ */
966
967 /* borrowed from lgdt330x.c */
968 static u32 calculate_snr(u32 mse, u32 c)
969 {
970 if (mse == 0) /* no signal */
971 return 0;
972
973 mse = intlog10(mse);
974 if (mse > c) {
975 /* Negative SNR, which is possible, but realisticly the
976 demod will lose lock before the signal gets this bad. The
977 API only allows for unsigned values, so just return 0 */
978 return 0;
979 }
980 return 10*(c - mse);
981 }
982
983 static int lgdt3305_read_snr(struct dvb_frontend *fe, u16 *snr)
984 {
985 struct lgdt3305_state *state = fe->demodulator_priv;
986 u32 noise; /* noise value */
987 u32 c; /* per-modulation SNR calculation constant */
988
989 switch (state->current_modulation) {
990 case VSB_8:
991 #ifdef USE_PTMSE
992 /* Use Phase Tracker Mean-Square Error Register */
993 /* SNR for ranges from -13.11 to +44.08 */
994 noise = ((read_reg(state, LGDT3305_PT_MSE_1) & 0x07) << 16) |
995 (read_reg(state, LGDT3305_PT_MSE_2) << 8) |
996 (read_reg(state, LGDT3305_PT_MSE_3) & 0xff);
997 c = 73957994; /* log10(25*32^2)*2^24 */
998 #else
999 /* Use Equalizer Mean-Square Error Register */
1000 /* SNR for ranges from -16.12 to +44.08 */
1001 noise = ((read_reg(state, LGDT3305_EQ_MSE_1) & 0x0f) << 16) |
1002 (read_reg(state, LGDT3305_EQ_MSE_2) << 8) |
1003 (read_reg(state, LGDT3305_EQ_MSE_3) & 0xff);
1004 c = 73957994; /* log10(25*32^2)*2^24 */
1005 #endif
1006 break;
1007 case QAM_64:
1008 case QAM_256:
1009 noise = (read_reg(state, LGDT3305_CR_MSE_1) << 8) |
1010 (read_reg(state, LGDT3305_CR_MSE_2) & 0xff);
1011
1012 c = (state->current_modulation == QAM_64) ?
1013 97939837 : 98026066;
1014 /* log10(688128)*2^24 and log10(696320)*2^24 */
1015 break;
1016 default:
1017 return -EINVAL;
1018 }
1019 state->snr = calculate_snr(noise, c);
1020 /* report SNR in dB * 10 */
1021 *snr = (state->snr / ((1 << 24) / 10));
1022 lg_dbg("noise = 0x%08x, snr = %d.%02d dB\n", noise,
1023 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
1024
1025 return 0;
1026 }
1027
1028 static int lgdt3305_read_signal_strength(struct dvb_frontend *fe,
1029 u16 *strength)
1030 {
1031 /* borrowed from lgdt330x.c
1032 *
1033 * Calculate strength from SNR up to 35dB
1034 * Even though the SNR can go higher than 35dB,
1035 * there is some comfort factor in having a range of
1036 * strong signals that can show at 100%
1037 */
1038 struct lgdt3305_state *state = fe->demodulator_priv;
1039 u16 snr;
1040 int ret;
1041
1042 *strength = 0;
1043
1044 ret = fe->ops.read_snr(fe, &snr);
1045 if (lg_fail(ret))
1046 goto fail;
1047 /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
1048 /* scale the range 0 - 35*2^24 into 0 - 65535 */
1049 if (state->snr >= 8960 * 0x10000)
1050 *strength = 0xffff;
1051 else
1052 *strength = state->snr / 8960;
1053 fail:
1054 return ret;
1055 }
1056
1057 /* ------------------------------------------------------------------------ */
1058
1059 static int lgdt3305_read_ber(struct dvb_frontend *fe, u32 *ber)
1060 {
1061 *ber = 0;
1062 return 0;
1063 }
1064
1065 static int lgdt3305_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1066 {
1067 struct lgdt3305_state *state = fe->demodulator_priv;
1068
1069 *ucblocks =
1070 (read_reg(state, LGDT3305_FEC_PKT_ERR_1) << 8) |
1071 (read_reg(state, LGDT3305_FEC_PKT_ERR_2) & 0xff);
1072
1073 return 0;
1074 }
1075
1076 static int lgdt3305_get_tune_settings(struct dvb_frontend *fe,
1077 struct dvb_frontend_tune_settings
1078 *fe_tune_settings)
1079 {
1080 fe_tune_settings->min_delay_ms = 500;
1081 lg_dbg("\n");
1082 return 0;
1083 }
1084
1085 static void lgdt3305_release(struct dvb_frontend *fe)
1086 {
1087 struct lgdt3305_state *state = fe->demodulator_priv;
1088 lg_dbg("\n");
1089 kfree(state);
1090 }
1091
1092 static const struct dvb_frontend_ops lgdt3304_ops;
1093 static const struct dvb_frontend_ops lgdt3305_ops;
1094
1095 struct dvb_frontend *lgdt3305_attach(const struct lgdt3305_config *config,
1096 struct i2c_adapter *i2c_adap)
1097 {
1098 struct lgdt3305_state *state = NULL;
1099 int ret;
1100 u8 val;
1101
1102 lg_dbg("(%d-%04x)\n",
1103 i2c_adap ? i2c_adapter_id(i2c_adap) : 0,
1104 config ? config->i2c_addr : 0);
1105
1106 state = kzalloc(sizeof(struct lgdt3305_state), GFP_KERNEL);
1107 if (state == NULL)
1108 goto fail;
1109
1110 state->cfg = config;
1111 state->i2c_adap = i2c_adap;
1112
1113 switch (config->demod_chip) {
1114 case LGDT3304:
1115 memcpy(&state->frontend.ops, &lgdt3304_ops,
1116 sizeof(struct dvb_frontend_ops));
1117 break;
1118 case LGDT3305:
1119 memcpy(&state->frontend.ops, &lgdt3305_ops,
1120 sizeof(struct dvb_frontend_ops));
1121 break;
1122 default:
1123 goto fail;
1124 }
1125 state->frontend.demodulator_priv = state;
1126
1127 /* verify that we're talking to a lg dt3304/5 */
1128 ret = lgdt3305_read_reg(state, LGDT3305_GEN_CTRL_2, &val);
1129 if ((lg_fail(ret)) | (val == 0))
1130 goto fail;
1131 ret = lgdt3305_write_reg(state, 0x0808, 0x80);
1132 if (lg_fail(ret))
1133 goto fail;
1134 ret = lgdt3305_read_reg(state, 0x0808, &val);
1135 if ((lg_fail(ret)) | (val != 0x80))
1136 goto fail;
1137 ret = lgdt3305_write_reg(state, 0x0808, 0x00);
1138 if (lg_fail(ret))
1139 goto fail;
1140
1141 state->current_frequency = -1;
1142 state->current_modulation = -1;
1143
1144 return &state->frontend;
1145 fail:
1146 lg_warn("unable to detect %s hardware\n",
1147 config->demod_chip ? "LGDT3304" : "LGDT3305");
1148 kfree(state);
1149 return NULL;
1150 }
1151 EXPORT_SYMBOL(lgdt3305_attach);
1152
1153 static const struct dvb_frontend_ops lgdt3304_ops = {
1154 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
1155 .info = {
1156 .name = "LG Electronics LGDT3304 VSB/QAM Frontend",
1157 .frequency_min_hz = 54 * MHz,
1158 .frequency_max_hz = 858 * MHz,
1159 .frequency_stepsize_hz = 62500,
1160 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
1161 },
1162 .i2c_gate_ctrl = lgdt3305_i2c_gate_ctrl,
1163 .init = lgdt3305_init,
1164 .sleep = lgdt3305_sleep,
1165 .set_frontend = lgdt3304_set_parameters,
1166 .get_frontend = lgdt3305_get_frontend,
1167 .get_tune_settings = lgdt3305_get_tune_settings,
1168 .read_status = lgdt3305_read_status,
1169 .read_ber = lgdt3305_read_ber,
1170 .read_signal_strength = lgdt3305_read_signal_strength,
1171 .read_snr = lgdt3305_read_snr,
1172 .read_ucblocks = lgdt3305_read_ucblocks,
1173 .release = lgdt3305_release,
1174 };
1175
1176 static const struct dvb_frontend_ops lgdt3305_ops = {
1177 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
1178 .info = {
1179 .name = "LG Electronics LGDT3305 VSB/QAM Frontend",
1180 .frequency_min_hz = 54 * MHz,
1181 .frequency_max_hz = 858 * MHz,
1182 .frequency_stepsize_hz = 62500,
1183 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
1184 },
1185 .i2c_gate_ctrl = lgdt3305_i2c_gate_ctrl,
1186 .init = lgdt3305_init,
1187 .sleep = lgdt3305_sleep,
1188 .set_frontend = lgdt3305_set_parameters,
1189 .get_frontend = lgdt3305_get_frontend,
1190 .get_tune_settings = lgdt3305_get_tune_settings,
1191 .read_status = lgdt3305_read_status,
1192 .read_ber = lgdt3305_read_ber,
1193 .read_signal_strength = lgdt3305_read_signal_strength,
1194 .read_snr = lgdt3305_read_snr,
1195 .read_ucblocks = lgdt3305_read_ucblocks,
1196 .release = lgdt3305_release,
1197 };
1198
1199 MODULE_DESCRIPTION("LG Electronics LGDT3304/5 ATSC/QAM-B Demodulator Driver");
1200 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1201 MODULE_LICENSE("GPL");
1202 MODULE_VERSION("0.2");
Linux with added FPC-III support