Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / media / dvb-frontends / dib8000.c
blobe64014f338fbd5352207c8797487513c63ebc82b
1 /*
2 * Linux-DVB Driver for DiBcom's DiB8000 chip (ISDB-T).
4 * Copyright (C) 2009 DiBcom (http://www.dibcom.fr/)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation, version 2.
9 */
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/i2c.h>
16 #include <linux/mutex.h>
17 #include <asm/div64.h>
19 #include <media/dvb_math.h>
21 #include <media/dvb_frontend.h>
23 #include "dib8000.h"
25 #define LAYER_ALL -1
26 #define LAYER_A 1
27 #define LAYER_B 2
28 #define LAYER_C 3
30 #define MAX_NUMBER_OF_FRONTENDS 6
31 /* #define DIB8000_AGC_FREEZE */
33 static int debug;
34 module_param(debug, int, 0644);
35 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
37 #define dprintk(fmt, arg...) do { \
38 if (debug) \
39 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
40 __func__, ##arg); \
41 } while (0)
43 struct i2c_device {
44 struct i2c_adapter *adap;
45 u8 addr;
46 u8 *i2c_write_buffer;
47 u8 *i2c_read_buffer;
48 struct mutex *i2c_buffer_lock;
51 enum param_loop_step {
52 LOOP_TUNE_1,
53 LOOP_TUNE_2
56 enum dib8000_autosearch_step {
57 AS_START = 0,
58 AS_SEARCHING_FFT,
59 AS_SEARCHING_GUARD,
60 AS_DONE = 100,
63 enum timeout_mode {
64 SYMBOL_DEPENDENT_OFF = 0,
65 SYMBOL_DEPENDENT_ON,
68 struct dib8000_state {
69 struct dib8000_config cfg;
71 struct i2c_device i2c;
73 struct dibx000_i2c_master i2c_master;
75 u16 wbd_ref;
77 u8 current_band;
78 u32 current_bandwidth;
79 struct dibx000_agc_config *current_agc;
80 u32 timf;
81 u32 timf_default;
83 u8 div_force_off:1;
84 u8 div_state:1;
85 u16 div_sync_wait;
87 u8 agc_state;
88 u8 differential_constellation;
89 u8 diversity_onoff;
91 s16 ber_monitored_layer;
92 u16 gpio_dir;
93 u16 gpio_val;
95 u16 revision;
96 u8 isdbt_cfg_loaded;
97 enum frontend_tune_state tune_state;
98 s32 status;
100 struct dvb_frontend *fe[MAX_NUMBER_OF_FRONTENDS];
102 /* for the I2C transfer */
103 struct i2c_msg msg[2];
104 u8 i2c_write_buffer[4];
105 u8 i2c_read_buffer[2];
106 struct mutex i2c_buffer_lock;
107 u8 input_mode_mpeg;
109 u16 tuner_enable;
110 struct i2c_adapter dib8096p_tuner_adap;
111 u16 current_demod_bw;
113 u16 seg_mask;
114 u16 seg_diff_mask;
115 u16 mode;
116 u8 layer_b_nb_seg;
117 u8 layer_c_nb_seg;
119 u8 channel_parameters_set;
120 u16 autosearch_state;
121 u16 found_nfft;
122 u16 found_guard;
123 u8 subchannel;
124 u8 symbol_duration;
125 unsigned long timeout;
126 u8 longest_intlv_layer;
127 u16 output_mode;
129 /* for DVBv5 stats */
130 s64 init_ucb;
131 unsigned long per_jiffies_stats;
132 unsigned long ber_jiffies_stats;
133 unsigned long ber_jiffies_stats_layer[3];
135 #ifdef DIB8000_AGC_FREEZE
136 u16 agc1_max;
137 u16 agc1_min;
138 u16 agc2_max;
139 u16 agc2_min;
140 #endif
143 enum dib8000_power_mode {
144 DIB8000_POWER_ALL = 0,
145 DIB8000_POWER_INTERFACE_ONLY,
148 static u16 dib8000_i2c_read16(struct i2c_device *i2c, u16 reg)
150 u16 ret;
151 struct i2c_msg msg[2] = {
152 {.addr = i2c->addr >> 1, .flags = 0, .len = 2},
153 {.addr = i2c->addr >> 1, .flags = I2C_M_RD, .len = 2},
156 if (mutex_lock_interruptible(i2c->i2c_buffer_lock) < 0) {
157 dprintk("could not acquire lock\n");
158 return 0;
161 msg[0].buf = i2c->i2c_write_buffer;
162 msg[0].buf[0] = reg >> 8;
163 msg[0].buf[1] = reg & 0xff;
164 msg[1].buf = i2c->i2c_read_buffer;
166 if (i2c_transfer(i2c->adap, msg, 2) != 2)
167 dprintk("i2c read error on %d\n", reg);
169 ret = (msg[1].buf[0] << 8) | msg[1].buf[1];
170 mutex_unlock(i2c->i2c_buffer_lock);
171 return ret;
174 static u16 __dib8000_read_word(struct dib8000_state *state, u16 reg)
176 u16 ret;
178 state->i2c_write_buffer[0] = reg >> 8;
179 state->i2c_write_buffer[1] = reg & 0xff;
181 memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
182 state->msg[0].addr = state->i2c.addr >> 1;
183 state->msg[0].flags = 0;
184 state->msg[0].buf = state->i2c_write_buffer;
185 state->msg[0].len = 2;
186 state->msg[1].addr = state->i2c.addr >> 1;
187 state->msg[1].flags = I2C_M_RD;
188 state->msg[1].buf = state->i2c_read_buffer;
189 state->msg[1].len = 2;
191 if (i2c_transfer(state->i2c.adap, state->msg, 2) != 2)
192 dprintk("i2c read error on %d\n", reg);
194 ret = (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
196 return ret;
199 static u16 dib8000_read_word(struct dib8000_state *state, u16 reg)
201 u16 ret;
203 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
204 dprintk("could not acquire lock\n");
205 return 0;
208 ret = __dib8000_read_word(state, reg);
210 mutex_unlock(&state->i2c_buffer_lock);
212 return ret;
215 static u32 dib8000_read32(struct dib8000_state *state, u16 reg)
217 u16 rw[2];
219 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
220 dprintk("could not acquire lock\n");
221 return 0;
224 rw[0] = __dib8000_read_word(state, reg + 0);
225 rw[1] = __dib8000_read_word(state, reg + 1);
227 mutex_unlock(&state->i2c_buffer_lock);
229 return ((rw[0] << 16) | (rw[1]));
232 static int dib8000_i2c_write16(struct i2c_device *i2c, u16 reg, u16 val)
234 struct i2c_msg msg = {.addr = i2c->addr >> 1, .flags = 0, .len = 4};
235 int ret = 0;
237 if (mutex_lock_interruptible(i2c->i2c_buffer_lock) < 0) {
238 dprintk("could not acquire lock\n");
239 return -EINVAL;
242 msg.buf = i2c->i2c_write_buffer;
243 msg.buf[0] = (reg >> 8) & 0xff;
244 msg.buf[1] = reg & 0xff;
245 msg.buf[2] = (val >> 8) & 0xff;
246 msg.buf[3] = val & 0xff;
248 ret = i2c_transfer(i2c->adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
249 mutex_unlock(i2c->i2c_buffer_lock);
251 return ret;
254 static int dib8000_write_word(struct dib8000_state *state, u16 reg, u16 val)
256 int ret;
258 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
259 dprintk("could not acquire lock\n");
260 return -EINVAL;
263 state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
264 state->i2c_write_buffer[1] = reg & 0xff;
265 state->i2c_write_buffer[2] = (val >> 8) & 0xff;
266 state->i2c_write_buffer[3] = val & 0xff;
268 memset(&state->msg[0], 0, sizeof(struct i2c_msg));
269 state->msg[0].addr = state->i2c.addr >> 1;
270 state->msg[0].flags = 0;
271 state->msg[0].buf = state->i2c_write_buffer;
272 state->msg[0].len = 4;
274 ret = (i2c_transfer(state->i2c.adap, state->msg, 1) != 1 ?
275 -EREMOTEIO : 0);
276 mutex_unlock(&state->i2c_buffer_lock);
278 return ret;
281 static const s16 coeff_2k_sb_1seg_dqpsk[8] = {
282 (769 << 5) | 0x0a, (745 << 5) | 0x03, (595 << 5) | 0x0d, (769 << 5) | 0x0a, (920 << 5) | 0x09, (784 << 5) | 0x02, (519 << 5) | 0x0c,
283 (920 << 5) | 0x09
286 static const s16 coeff_2k_sb_1seg[8] = {
287 (692 << 5) | 0x0b, (683 << 5) | 0x01, (519 << 5) | 0x09, (692 << 5) | 0x0b, 0 | 0x1f, 0 | 0x1f, 0 | 0x1f, 0 | 0x1f
290 static const s16 coeff_2k_sb_3seg_0dqpsk_1dqpsk[8] = {
291 (832 << 5) | 0x10, (912 << 5) | 0x05, (900 << 5) | 0x12, (832 << 5) | 0x10, (-931 << 5) | 0x0f, (912 << 5) | 0x04, (807 << 5) | 0x11,
292 (-931 << 5) | 0x0f
295 static const s16 coeff_2k_sb_3seg_0dqpsk[8] = {
296 (622 << 5) | 0x0c, (941 << 5) | 0x04, (796 << 5) | 0x10, (622 << 5) | 0x0c, (982 << 5) | 0x0c, (519 << 5) | 0x02, (572 << 5) | 0x0e,
297 (982 << 5) | 0x0c
300 static const s16 coeff_2k_sb_3seg_1dqpsk[8] = {
301 (699 << 5) | 0x14, (607 << 5) | 0x04, (944 << 5) | 0x13, (699 << 5) | 0x14, (-720 << 5) | 0x0d, (640 << 5) | 0x03, (866 << 5) | 0x12,
302 (-720 << 5) | 0x0d
305 static const s16 coeff_2k_sb_3seg[8] = {
306 (664 << 5) | 0x0c, (925 << 5) | 0x03, (937 << 5) | 0x10, (664 << 5) | 0x0c, (-610 << 5) | 0x0a, (697 << 5) | 0x01, (836 << 5) | 0x0e,
307 (-610 << 5) | 0x0a
310 static const s16 coeff_4k_sb_1seg_dqpsk[8] = {
311 (-955 << 5) | 0x0e, (687 << 5) | 0x04, (818 << 5) | 0x10, (-955 << 5) | 0x0e, (-922 << 5) | 0x0d, (750 << 5) | 0x03, (665 << 5) | 0x0f,
312 (-922 << 5) | 0x0d
315 static const s16 coeff_4k_sb_1seg[8] = {
316 (638 << 5) | 0x0d, (683 << 5) | 0x02, (638 << 5) | 0x0d, (638 << 5) | 0x0d, (-655 << 5) | 0x0a, (517 << 5) | 0x00, (698 << 5) | 0x0d,
317 (-655 << 5) | 0x0a
320 static const s16 coeff_4k_sb_3seg_0dqpsk_1dqpsk[8] = {
321 (-707 << 5) | 0x14, (910 << 5) | 0x06, (889 << 5) | 0x16, (-707 << 5) | 0x14, (-958 << 5) | 0x13, (993 << 5) | 0x05, (523 << 5) | 0x14,
322 (-958 << 5) | 0x13
325 static const s16 coeff_4k_sb_3seg_0dqpsk[8] = {
326 (-723 << 5) | 0x13, (910 << 5) | 0x05, (777 << 5) | 0x14, (-723 << 5) | 0x13, (-568 << 5) | 0x0f, (547 << 5) | 0x03, (696 << 5) | 0x12,
327 (-568 << 5) | 0x0f
330 static const s16 coeff_4k_sb_3seg_1dqpsk[8] = {
331 (-940 << 5) | 0x15, (607 << 5) | 0x05, (915 << 5) | 0x16, (-940 << 5) | 0x15, (-848 << 5) | 0x13, (683 << 5) | 0x04, (543 << 5) | 0x14,
332 (-848 << 5) | 0x13
335 static const s16 coeff_4k_sb_3seg[8] = {
336 (612 << 5) | 0x12, (910 << 5) | 0x04, (864 << 5) | 0x14, (612 << 5) | 0x12, (-869 << 5) | 0x13, (683 << 5) | 0x02, (869 << 5) | 0x12,
337 (-869 << 5) | 0x13
340 static const s16 coeff_8k_sb_1seg_dqpsk[8] = {
341 (-835 << 5) | 0x12, (684 << 5) | 0x05, (735 << 5) | 0x14, (-835 << 5) | 0x12, (-598 << 5) | 0x10, (781 << 5) | 0x04, (739 << 5) | 0x13,
342 (-598 << 5) | 0x10
345 static const s16 coeff_8k_sb_1seg[8] = {
346 (673 << 5) | 0x0f, (683 << 5) | 0x03, (808 << 5) | 0x12, (673 << 5) | 0x0f, (585 << 5) | 0x0f, (512 << 5) | 0x01, (780 << 5) | 0x0f,
347 (585 << 5) | 0x0f
350 static const s16 coeff_8k_sb_3seg_0dqpsk_1dqpsk[8] = {
351 (863 << 5) | 0x17, (930 << 5) | 0x07, (878 << 5) | 0x19, (863 << 5) | 0x17, (0 << 5) | 0x14, (521 << 5) | 0x05, (980 << 5) | 0x18,
352 (0 << 5) | 0x14
355 static const s16 coeff_8k_sb_3seg_0dqpsk[8] = {
356 (-924 << 5) | 0x17, (910 << 5) | 0x06, (774 << 5) | 0x17, (-924 << 5) | 0x17, (-877 << 5) | 0x15, (565 << 5) | 0x04, (553 << 5) | 0x15,
357 (-877 << 5) | 0x15
360 static const s16 coeff_8k_sb_3seg_1dqpsk[8] = {
361 (-921 << 5) | 0x19, (607 << 5) | 0x06, (881 << 5) | 0x19, (-921 << 5) | 0x19, (-921 << 5) | 0x14, (713 << 5) | 0x05, (1018 << 5) | 0x18,
362 (-921 << 5) | 0x14
365 static const s16 coeff_8k_sb_3seg[8] = {
366 (514 << 5) | 0x14, (910 << 5) | 0x05, (861 << 5) | 0x17, (514 << 5) | 0x14, (690 << 5) | 0x14, (683 << 5) | 0x03, (662 << 5) | 0x15,
367 (690 << 5) | 0x14
370 static const s16 ana_fe_coeff_3seg[24] = {
371 81, 80, 78, 74, 68, 61, 54, 45, 37, 28, 19, 11, 4, 1022, 1017, 1013, 1010, 1008, 1008, 1008, 1008, 1010, 1014, 1017
374 static const s16 ana_fe_coeff_1seg[24] = {
375 249, 226, 164, 82, 5, 981, 970, 988, 1018, 20, 31, 26, 8, 1012, 1000, 1018, 1012, 8, 15, 14, 9, 3, 1017, 1003
378 static const s16 ana_fe_coeff_13seg[24] = {
379 396, 305, 105, -51, -77, -12, 41, 31, -11, -30, -11, 14, 15, -2, -13, -7, 5, 8, 1, -6, -7, -3, 0, 1
382 static u16 fft_to_mode(struct dib8000_state *state)
384 u16 mode;
385 switch (state->fe[0]->dtv_property_cache.transmission_mode) {
386 case TRANSMISSION_MODE_2K:
387 mode = 1;
388 break;
389 case TRANSMISSION_MODE_4K:
390 mode = 2;
391 break;
392 default:
393 case TRANSMISSION_MODE_AUTO:
394 case TRANSMISSION_MODE_8K:
395 mode = 3;
396 break;
398 return mode;
401 static void dib8000_set_acquisition_mode(struct dib8000_state *state)
403 u16 nud = dib8000_read_word(state, 298);
404 nud |= (1 << 3) | (1 << 0);
405 dprintk("acquisition mode activated\n");
406 dib8000_write_word(state, 298, nud);
408 static int dib8000_set_output_mode(struct dvb_frontend *fe, int mode)
410 struct dib8000_state *state = fe->demodulator_priv;
411 u16 outreg, fifo_threshold, smo_mode, sram = 0x0205; /* by default SDRAM deintlv is enabled */
413 state->output_mode = mode;
414 outreg = 0;
415 fifo_threshold = 1792;
416 smo_mode = (dib8000_read_word(state, 299) & 0x0050) | (1 << 1);
418 dprintk("-I- Setting output mode for demod %p to %d\n",
419 &state->fe[0], mode);
421 switch (mode) {
422 case OUTMODE_MPEG2_PAR_GATED_CLK: // STBs with parallel gated clock
423 outreg = (1 << 10); /* 0x0400 */
424 break;
425 case OUTMODE_MPEG2_PAR_CONT_CLK: // STBs with parallel continues clock
426 outreg = (1 << 10) | (1 << 6); /* 0x0440 */
427 break;
428 case OUTMODE_MPEG2_SERIAL: // STBs with serial input
429 outreg = (1 << 10) | (2 << 6) | (0 << 1); /* 0x0482 */
430 break;
431 case OUTMODE_DIVERSITY:
432 if (state->cfg.hostbus_diversity) {
433 outreg = (1 << 10) | (4 << 6); /* 0x0500 */
434 sram &= 0xfdff;
435 } else
436 sram |= 0x0c00;
437 break;
438 case OUTMODE_MPEG2_FIFO: // e.g. USB feeding
439 smo_mode |= (3 << 1);
440 fifo_threshold = 512;
441 outreg = (1 << 10) | (5 << 6);
442 break;
443 case OUTMODE_HIGH_Z: // disable
444 outreg = 0;
445 break;
447 case OUTMODE_ANALOG_ADC:
448 outreg = (1 << 10) | (3 << 6);
449 dib8000_set_acquisition_mode(state);
450 break;
452 default:
453 dprintk("Unhandled output_mode passed to be set for demod %p\n",
454 &state->fe[0]);
455 return -EINVAL;
458 if (state->cfg.output_mpeg2_in_188_bytes)
459 smo_mode |= (1 << 5);
461 dib8000_write_word(state, 299, smo_mode);
462 dib8000_write_word(state, 300, fifo_threshold); /* synchronous fread */
463 dib8000_write_word(state, 1286, outreg);
464 dib8000_write_word(state, 1291, sram);
466 return 0;
469 static int dib8000_set_diversity_in(struct dvb_frontend *fe, int onoff)
471 struct dib8000_state *state = fe->demodulator_priv;
472 u16 tmp, sync_wait = dib8000_read_word(state, 273) & 0xfff0;
474 dprintk("set diversity input to %i\n", onoff);
475 if (!state->differential_constellation) {
476 dib8000_write_word(state, 272, 1 << 9); //dvsy_off_lmod4 = 1
477 dib8000_write_word(state, 273, sync_wait | (1 << 2) | 2); // sync_enable = 1; comb_mode = 2
478 } else {
479 dib8000_write_word(state, 272, 0); //dvsy_off_lmod4 = 0
480 dib8000_write_word(state, 273, sync_wait); // sync_enable = 0; comb_mode = 0
482 state->diversity_onoff = onoff;
484 switch (onoff) {
485 case 0: /* only use the internal way - not the diversity input */
486 dib8000_write_word(state, 270, 1);
487 dib8000_write_word(state, 271, 0);
488 break;
489 case 1: /* both ways */
490 dib8000_write_word(state, 270, 6);
491 dib8000_write_word(state, 271, 6);
492 break;
493 case 2: /* only the diversity input */
494 dib8000_write_word(state, 270, 0);
495 dib8000_write_word(state, 271, 1);
496 break;
499 if (state->revision == 0x8002) {
500 tmp = dib8000_read_word(state, 903);
501 dib8000_write_word(state, 903, tmp & ~(1 << 3));
502 msleep(30);
503 dib8000_write_word(state, 903, tmp | (1 << 3));
505 return 0;
508 static void dib8000_set_power_mode(struct dib8000_state *state, enum dib8000_power_mode mode)
510 /* by default everything is going to be powered off */
511 u16 reg_774 = 0x3fff, reg_775 = 0xffff, reg_776 = 0xffff,
512 reg_900 = (dib8000_read_word(state, 900) & 0xfffc) | 0x3,
513 reg_1280;
515 if (state->revision != 0x8090)
516 reg_1280 = (dib8000_read_word(state, 1280) & 0x00ff) | 0xff00;
517 else
518 reg_1280 = (dib8000_read_word(state, 1280) & 0x707f) | 0x8f80;
520 /* now, depending on the requested mode, we power on */
521 switch (mode) {
522 /* power up everything in the demod */
523 case DIB8000_POWER_ALL:
524 reg_774 = 0x0000;
525 reg_775 = 0x0000;
526 reg_776 = 0x0000;
527 reg_900 &= 0xfffc;
528 if (state->revision != 0x8090)
529 reg_1280 &= 0x00ff;
530 else
531 reg_1280 &= 0x707f;
532 break;
533 case DIB8000_POWER_INTERFACE_ONLY:
534 if (state->revision != 0x8090)
535 reg_1280 &= 0x00ff;
536 else
537 reg_1280 &= 0xfa7b;
538 break;
541 dprintk("powermode : 774 : %x ; 775 : %x; 776 : %x ; 900 : %x; 1280 : %x\n", reg_774, reg_775, reg_776, reg_900, reg_1280);
542 dib8000_write_word(state, 774, reg_774);
543 dib8000_write_word(state, 775, reg_775);
544 dib8000_write_word(state, 776, reg_776);
545 dib8000_write_word(state, 900, reg_900);
546 dib8000_write_word(state, 1280, reg_1280);
549 static int dib8000_set_adc_state(struct dib8000_state *state, enum dibx000_adc_states no)
551 int ret = 0;
552 u16 reg, reg_907 = dib8000_read_word(state, 907);
553 u16 reg_908 = dib8000_read_word(state, 908);
555 switch (no) {
556 case DIBX000_SLOW_ADC_ON:
557 if (state->revision != 0x8090) {
558 reg_908 |= (1 << 1) | (1 << 0);
559 ret |= dib8000_write_word(state, 908, reg_908);
560 reg_908 &= ~(1 << 1);
561 } else {
562 reg = dib8000_read_word(state, 1925);
563 /* en_slowAdc = 1 & reset_sladc = 1 */
564 dib8000_write_word(state, 1925, reg |
565 (1<<4) | (1<<2));
567 /* read acces to make it works... strange ... */
568 reg = dib8000_read_word(state, 1925);
569 msleep(20);
570 /* en_slowAdc = 1 & reset_sladc = 0 */
571 dib8000_write_word(state, 1925, reg & ~(1<<4));
573 reg = dib8000_read_word(state, 921) & ~((0x3 << 14)
574 | (0x3 << 12));
575 /* ref = Vin1 => Vbg ; sel = Vin0 or Vin3 ;
576 (Vin2 = Vcm) */
577 dib8000_write_word(state, 921, reg | (1 << 14)
578 | (3 << 12));
580 break;
582 case DIBX000_SLOW_ADC_OFF:
583 if (state->revision == 0x8090) {
584 reg = dib8000_read_word(state, 1925);
585 /* reset_sladc = 1 en_slowAdc = 0 */
586 dib8000_write_word(state, 1925,
587 (reg & ~(1<<2)) | (1<<4));
589 reg_908 |= (1 << 1) | (1 << 0);
590 break;
592 case DIBX000_ADC_ON:
593 reg_907 &= 0x0fff;
594 reg_908 &= 0x0003;
595 break;
597 case DIBX000_ADC_OFF: // leave the VBG voltage on
598 reg_907 = (1 << 13) | (1 << 12);
599 reg_908 = (1 << 6) | (1 << 5) | (1 << 4) | (1 << 3) | (1 << 1);
600 break;
602 case DIBX000_VBG_ENABLE:
603 reg_907 &= ~(1 << 15);
604 break;
606 case DIBX000_VBG_DISABLE:
607 reg_907 |= (1 << 15);
608 break;
610 default:
611 break;
614 ret |= dib8000_write_word(state, 907, reg_907);
615 ret |= dib8000_write_word(state, 908, reg_908);
617 return ret;
620 static int dib8000_set_bandwidth(struct dvb_frontend *fe, u32 bw)
622 struct dib8000_state *state = fe->demodulator_priv;
623 u32 timf;
625 if (bw == 0)
626 bw = 6000;
628 if (state->timf == 0) {
629 dprintk("using default timf\n");
630 timf = state->timf_default;
631 } else {
632 dprintk("using updated timf\n");
633 timf = state->timf;
636 dib8000_write_word(state, 29, (u16) ((timf >> 16) & 0xffff));
637 dib8000_write_word(state, 30, (u16) ((timf) & 0xffff));
639 return 0;
642 static int dib8000_sad_calib(struct dib8000_state *state)
644 u8 sad_sel = 3;
646 if (state->revision == 0x8090) {
647 dib8000_write_word(state, 922, (sad_sel << 2));
648 dib8000_write_word(state, 923, 2048);
650 dib8000_write_word(state, 922, (sad_sel << 2) | 0x1);
651 dib8000_write_word(state, 922, (sad_sel << 2));
652 } else {
653 /* internal */
654 dib8000_write_word(state, 923, (0 << 1) | (0 << 0));
655 dib8000_write_word(state, 924, 776);
657 /* do the calibration */
658 dib8000_write_word(state, 923, (1 << 0));
659 dib8000_write_word(state, 923, (0 << 0));
662 msleep(1);
663 return 0;
666 static int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value)
668 struct dib8000_state *state = fe->demodulator_priv;
669 if (value > 4095)
670 value = 4095;
671 state->wbd_ref = value;
672 return dib8000_write_word(state, 106, value);
675 static void dib8000_reset_pll_common(struct dib8000_state *state, const struct dibx000_bandwidth_config *bw)
677 dprintk("ifreq: %d %x, inversion: %d\n", bw->ifreq, bw->ifreq, bw->ifreq >> 25);
678 if (state->revision != 0x8090) {
679 dib8000_write_word(state, 23,
680 (u16) (((bw->internal * 1000) >> 16) & 0xffff));
681 dib8000_write_word(state, 24,
682 (u16) ((bw->internal * 1000) & 0xffff));
683 } else {
684 dib8000_write_word(state, 23, (u16) (((bw->internal / 2 * 1000) >> 16) & 0xffff));
685 dib8000_write_word(state, 24,
686 (u16) ((bw->internal / 2 * 1000) & 0xffff));
688 dib8000_write_word(state, 27, (u16) ((bw->ifreq >> 16) & 0x01ff));
689 dib8000_write_word(state, 28, (u16) (bw->ifreq & 0xffff));
690 dib8000_write_word(state, 26, (u16) ((bw->ifreq >> 25) & 0x0003));
692 if (state->revision != 0x8090)
693 dib8000_write_word(state, 922, bw->sad_cfg);
696 static void dib8000_reset_pll(struct dib8000_state *state)
698 const struct dibx000_bandwidth_config *pll = state->cfg.pll;
699 u16 clk_cfg1, reg;
701 if (state->revision != 0x8090) {
702 dib8000_write_word(state, 901,
703 (pll->pll_prediv << 8) | (pll->pll_ratio << 0));
705 clk_cfg1 = (1 << 10) | (0 << 9) | (pll->IO_CLK_en_core << 8) |
706 (pll->bypclk_div << 5) | (pll->enable_refdiv << 4) |
707 (1 << 3) | (pll->pll_range << 1) |
708 (pll->pll_reset << 0);
710 dib8000_write_word(state, 902, clk_cfg1);
711 clk_cfg1 = (clk_cfg1 & 0xfff7) | (pll->pll_bypass << 3);
712 dib8000_write_word(state, 902, clk_cfg1);
714 dprintk("clk_cfg1: 0x%04x\n", clk_cfg1);
716 /* smpl_cfg: P_refclksel=2, P_ensmplsel=1 nodivsmpl=1 */
717 if (state->cfg.pll->ADClkSrc == 0)
718 dib8000_write_word(state, 904,
719 (0 << 15) | (0 << 12) | (0 << 10) |
720 (pll->modulo << 8) |
721 (pll->ADClkSrc << 7) | (0 << 1));
722 else if (state->cfg.refclksel != 0)
723 dib8000_write_word(state, 904, (0 << 15) | (1 << 12) |
724 ((state->cfg.refclksel & 0x3) << 10) |
725 (pll->modulo << 8) |
726 (pll->ADClkSrc << 7) | (0 << 1));
727 else
728 dib8000_write_word(state, 904, (0 << 15) | (1 << 12) |
729 (3 << 10) | (pll->modulo << 8) |
730 (pll->ADClkSrc << 7) | (0 << 1));
731 } else {
732 dib8000_write_word(state, 1856, (!pll->pll_reset<<13) |
733 (pll->pll_range<<12) | (pll->pll_ratio<<6) |
734 (pll->pll_prediv));
736 reg = dib8000_read_word(state, 1857);
737 dib8000_write_word(state, 1857, reg|(!pll->pll_bypass<<15));
739 reg = dib8000_read_word(state, 1858); /* Force clk out pll /2 */
740 dib8000_write_word(state, 1858, reg | 1);
742 dib8000_write_word(state, 904, (pll->modulo << 8));
745 dib8000_reset_pll_common(state, pll);
748 static int dib8000_update_pll(struct dvb_frontend *fe,
749 struct dibx000_bandwidth_config *pll, u32 bw, u8 ratio)
751 struct dib8000_state *state = fe->demodulator_priv;
752 u16 reg_1857, reg_1856 = dib8000_read_word(state, 1856);
753 u8 loopdiv, prediv, oldprediv = state->cfg.pll->pll_prediv ;
754 u32 internal, xtal;
756 /* get back old values */
757 prediv = reg_1856 & 0x3f;
758 loopdiv = (reg_1856 >> 6) & 0x3f;
760 if ((pll == NULL) || (pll->pll_prediv == prediv &&
761 pll->pll_ratio == loopdiv))
762 return -EINVAL;
764 dprintk("Updating pll (prediv: old = %d new = %d ; loopdiv : old = %d new = %d)\n", prediv, pll->pll_prediv, loopdiv, pll->pll_ratio);
765 if (state->revision == 0x8090) {
766 reg_1856 &= 0xf000;
767 reg_1857 = dib8000_read_word(state, 1857);
768 /* disable PLL */
769 dib8000_write_word(state, 1857, reg_1857 & ~(1 << 15));
771 dib8000_write_word(state, 1856, reg_1856 |
772 ((pll->pll_ratio & 0x3f) << 6) |
773 (pll->pll_prediv & 0x3f));
775 /* write new system clk into P_sec_len */
776 internal = dib8000_read32(state, 23) / 1000;
777 dprintk("Old Internal = %d\n", internal);
778 xtal = 2 * (internal / loopdiv) * prediv;
779 internal = 1000 * (xtal/pll->pll_prediv) * pll->pll_ratio;
780 dprintk("Xtal = %d , New Fmem = %d New Fdemod = %d, New Fsampling = %d\n", xtal, internal/1000, internal/2000, internal/8000);
781 dprintk("New Internal = %d\n", internal);
783 dib8000_write_word(state, 23,
784 (u16) (((internal / 2) >> 16) & 0xffff));
785 dib8000_write_word(state, 24, (u16) ((internal / 2) & 0xffff));
786 /* enable PLL */
787 dib8000_write_word(state, 1857, reg_1857 | (1 << 15));
789 while (((dib8000_read_word(state, 1856)>>15)&0x1) != 1)
790 dprintk("Waiting for PLL to lock\n");
792 /* verify */
793 reg_1856 = dib8000_read_word(state, 1856);
794 dprintk("PLL Updated with prediv = %d and loopdiv = %d\n",
795 reg_1856&0x3f, (reg_1856>>6)&0x3f);
796 } else {
797 if (bw != state->current_demod_bw) {
798 /** Bandwidth change => force PLL update **/
799 dprintk("PLL: Bandwidth Change %d MHz -> %d MHz (prediv: %d->%d)\n", state->current_demod_bw / 1000, bw / 1000, oldprediv, state->cfg.pll->pll_prediv);
801 if (state->cfg.pll->pll_prediv != oldprediv) {
802 /** Full PLL change only if prediv is changed **/
804 /** full update => bypass and reconfigure **/
805 dprintk("PLL: New Setting for %d MHz Bandwidth (prediv: %d, ratio: %d)\n", bw/1000, state->cfg.pll->pll_prediv, state->cfg.pll->pll_ratio);
806 dib8000_write_word(state, 902, dib8000_read_word(state, 902) | (1<<3)); /* bypass PLL */
807 dib8000_reset_pll(state);
808 dib8000_write_word(state, 898, 0x0004); /* sad */
809 } else
810 ratio = state->cfg.pll->pll_ratio;
812 state->current_demod_bw = bw;
815 if (ratio != 0) {
816 /** ratio update => only change ratio **/
817 dprintk("PLL: Update ratio (prediv: %d, ratio: %d)\n", state->cfg.pll->pll_prediv, ratio);
818 dib8000_write_word(state, 901, (state->cfg.pll->pll_prediv << 8) | (ratio << 0)); /* only the PLL ratio is updated. */
822 return 0;
825 static int dib8000_reset_gpio(struct dib8000_state *st)
827 /* reset the GPIOs */
828 dib8000_write_word(st, 1029, st->cfg.gpio_dir);
829 dib8000_write_word(st, 1030, st->cfg.gpio_val);
831 /* TODO 782 is P_gpio_od */
833 dib8000_write_word(st, 1032, st->cfg.gpio_pwm_pos);
835 dib8000_write_word(st, 1037, st->cfg.pwm_freq_div);
836 return 0;
839 static int dib8000_cfg_gpio(struct dib8000_state *st, u8 num, u8 dir, u8 val)
841 st->cfg.gpio_dir = dib8000_read_word(st, 1029);
842 st->cfg.gpio_dir &= ~(1 << num); /* reset the direction bit */
843 st->cfg.gpio_dir |= (dir & 0x1) << num; /* set the new direction */
844 dib8000_write_word(st, 1029, st->cfg.gpio_dir);
846 st->cfg.gpio_val = dib8000_read_word(st, 1030);
847 st->cfg.gpio_val &= ~(1 << num); /* reset the direction bit */
848 st->cfg.gpio_val |= (val & 0x01) << num; /* set the new value */
849 dib8000_write_word(st, 1030, st->cfg.gpio_val);
851 dprintk("gpio dir: %x: gpio val: %x\n", st->cfg.gpio_dir, st->cfg.gpio_val);
853 return 0;
856 static int dib8000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
858 struct dib8000_state *state = fe->demodulator_priv;
859 return dib8000_cfg_gpio(state, num, dir, val);
862 static const u16 dib8000_defaults[] = {
863 /* auto search configuration - lock0 by default waiting
864 * for cpil_lock; lock1 cpil_lock; lock2 tmcc_sync_lock */
865 3, 7,
866 0x0004,
867 0x0400,
868 0x0814,
870 12, 11,
871 0x001b,
872 0x7740,
873 0x005b,
874 0x8d80,
875 0x01c9,
876 0xc380,
877 0x0000,
878 0x0080,
879 0x0000,
880 0x0090,
881 0x0001,
882 0xd4c0,
884 /*1, 32,
885 0x6680 // P_corm_thres Lock algorithms configuration */
887 11, 80, /* set ADC level to -16 */
888 (1 << 13) - 825 - 117,
889 (1 << 13) - 837 - 117,
890 (1 << 13) - 811 - 117,
891 (1 << 13) - 766 - 117,
892 (1 << 13) - 737 - 117,
893 (1 << 13) - 693 - 117,
894 (1 << 13) - 648 - 117,
895 (1 << 13) - 619 - 117,
896 (1 << 13) - 575 - 117,
897 (1 << 13) - 531 - 117,
898 (1 << 13) - 501 - 117,
900 4, 108,
906 1, 175,
907 0x0410,
908 1, 179,
909 8192, // P_fft_nb_to_cut
911 6, 181,
912 0x2800, // P_coff_corthres_ ( 2k 4k 8k ) 0x2800
913 0x2800,
914 0x2800,
915 0x2800, // P_coff_cpilthres_ ( 2k 4k 8k ) 0x2800
916 0x2800,
917 0x2800,
919 2, 193,
920 0x0666, // P_pha3_thres
921 0x0000, // P_cti_use_cpe, P_cti_use_prog
923 2, 205,
924 0x200f, // P_cspu_regul, P_cspu_win_cut
925 0x000f, // P_des_shift_work
927 5, 215,
928 0x023d, // P_adp_regul_cnt
929 0x00a4, // P_adp_noise_cnt
930 0x00a4, // P_adp_regul_ext
931 0x7ff0, // P_adp_noise_ext
932 0x3ccc, // P_adp_fil
934 1, 230,
935 0x0000, // P_2d_byp_ti_num
937 1, 263,
938 0x800, //P_equal_thres_wgn
940 1, 268,
941 (2 << 9) | 39, // P_equal_ctrl_synchro, P_equal_speedmode
943 1, 270,
944 0x0001, // P_div_lock0_wait
945 1, 285,
946 0x0020, //p_fec_
947 1, 299,
948 0x0062, /* P_smo_mode, P_smo_rs_discard, P_smo_fifo_flush, P_smo_pid_parse, P_smo_error_discard */
950 1, 338,
951 (1 << 12) | // P_ctrl_corm_thres4pre_freq_inh=1
952 (1 << 10) |
953 (0 << 9) | /* P_ctrl_pre_freq_inh=0 */
954 (3 << 5) | /* P_ctrl_pre_freq_step=3 */
955 (1 << 0), /* P_pre_freq_win_len=1 */
960 static u16 dib8000_identify(struct i2c_device *client)
962 u16 value;
964 //because of glitches sometimes
965 value = dib8000_i2c_read16(client, 896);
967 if ((value = dib8000_i2c_read16(client, 896)) != 0x01b3) {
968 dprintk("wrong Vendor ID (read=0x%x)\n", value);
969 return 0;
972 value = dib8000_i2c_read16(client, 897);
973 if (value != 0x8000 && value != 0x8001 &&
974 value != 0x8002 && value != 0x8090) {
975 dprintk("wrong Device ID (%x)\n", value);
976 return 0;
979 switch (value) {
980 case 0x8000:
981 dprintk("found DiB8000A\n");
982 break;
983 case 0x8001:
984 dprintk("found DiB8000B\n");
985 break;
986 case 0x8002:
987 dprintk("found DiB8000C\n");
988 break;
989 case 0x8090:
990 dprintk("found DiB8096P\n");
991 break;
993 return value;
996 static int dib8000_read_unc_blocks(struct dvb_frontend *fe, u32 *unc);
998 static void dib8000_reset_stats(struct dvb_frontend *fe)
1000 struct dib8000_state *state = fe->demodulator_priv;
1001 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
1002 u32 ucb;
1004 memset(&c->strength, 0, sizeof(c->strength));
1005 memset(&c->cnr, 0, sizeof(c->cnr));
1006 memset(&c->post_bit_error, 0, sizeof(c->post_bit_error));
1007 memset(&c->post_bit_count, 0, sizeof(c->post_bit_count));
1008 memset(&c->block_error, 0, sizeof(c->block_error));
1010 c->strength.len = 1;
1011 c->cnr.len = 1;
1012 c->block_error.len = 1;
1013 c->block_count.len = 1;
1014 c->post_bit_error.len = 1;
1015 c->post_bit_count.len = 1;
1017 c->strength.stat[0].scale = FE_SCALE_DECIBEL;
1018 c->strength.stat[0].uvalue = 0;
1020 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1021 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1022 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1023 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1024 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1026 dib8000_read_unc_blocks(fe, &ucb);
1028 state->init_ucb = -ucb;
1029 state->ber_jiffies_stats = 0;
1030 state->per_jiffies_stats = 0;
1031 memset(&state->ber_jiffies_stats_layer, 0,
1032 sizeof(state->ber_jiffies_stats_layer));
1035 static int dib8000_reset(struct dvb_frontend *fe)
1037 struct dib8000_state *state = fe->demodulator_priv;
1039 if ((state->revision = dib8000_identify(&state->i2c)) == 0)
1040 return -EINVAL;
1042 /* sram lead in, rdy */
1043 if (state->revision != 0x8090)
1044 dib8000_write_word(state, 1287, 0x0003);
1046 if (state->revision == 0x8000)
1047 dprintk("error : dib8000 MA not supported\n");
1049 dibx000_reset_i2c_master(&state->i2c_master);
1051 dib8000_set_power_mode(state, DIB8000_POWER_ALL);
1053 /* always leave the VBG voltage on - it consumes almost nothing but takes a long time to start */
1054 dib8000_set_adc_state(state, DIBX000_ADC_OFF);
1056 /* restart all parts */
1057 dib8000_write_word(state, 770, 0xffff);
1058 dib8000_write_word(state, 771, 0xffff);
1059 dib8000_write_word(state, 772, 0xfffc);
1060 dib8000_write_word(state, 898, 0x000c); /* restart sad */
1061 if (state->revision == 0x8090)
1062 dib8000_write_word(state, 1280, 0x0045);
1063 else
1064 dib8000_write_word(state, 1280, 0x004d);
1065 dib8000_write_word(state, 1281, 0x000c);
1067 dib8000_write_word(state, 770, 0x0000);
1068 dib8000_write_word(state, 771, 0x0000);
1069 dib8000_write_word(state, 772, 0x0000);
1070 dib8000_write_word(state, 898, 0x0004); // sad
1071 dib8000_write_word(state, 1280, 0x0000);
1072 dib8000_write_word(state, 1281, 0x0000);
1074 /* drives */
1075 if (state->revision != 0x8090) {
1076 if (state->cfg.drives)
1077 dib8000_write_word(state, 906, state->cfg.drives);
1078 else {
1079 dprintk("using standard PAD-drive-settings, please adjust settings in config-struct to be optimal.\n");
1080 /* min drive SDRAM - not optimal - adjust */
1081 dib8000_write_word(state, 906, 0x2d98);
1085 dib8000_reset_pll(state);
1086 if (state->revision != 0x8090)
1087 dib8000_write_word(state, 898, 0x0004);
1089 if (dib8000_reset_gpio(state) != 0)
1090 dprintk("GPIO reset was not successful.\n");
1092 if ((state->revision != 0x8090) &&
1093 (dib8000_set_output_mode(fe, OUTMODE_HIGH_Z) != 0))
1094 dprintk("OUTPUT_MODE could not be resetted.\n");
1096 state->current_agc = NULL;
1098 // P_iqc_alpha_pha, P_iqc_alpha_amp, P_iqc_dcc_alpha, ...
1099 /* P_iqc_ca2 = 0; P_iqc_impnc_on = 0; P_iqc_mode = 0; */
1100 if (state->cfg.pll->ifreq == 0)
1101 dib8000_write_word(state, 40, 0x0755); /* P_iqc_corr_inh = 0 enable IQcorr block */
1102 else
1103 dib8000_write_word(state, 40, 0x1f55); /* P_iqc_corr_inh = 1 disable IQcorr block */
1106 u16 l = 0, r;
1107 const u16 *n;
1108 n = dib8000_defaults;
1109 l = *n++;
1110 while (l) {
1111 r = *n++;
1112 do {
1113 dib8000_write_word(state, r, *n++);
1114 r++;
1115 } while (--l);
1116 l = *n++;
1120 state->isdbt_cfg_loaded = 0;
1122 //div_cfg override for special configs
1123 if ((state->revision != 8090) && (state->cfg.div_cfg != 0))
1124 dib8000_write_word(state, 903, state->cfg.div_cfg);
1126 /* unforce divstr regardless whether i2c enumeration was done or not */
1127 dib8000_write_word(state, 1285, dib8000_read_word(state, 1285) & ~(1 << 1));
1129 dib8000_set_bandwidth(fe, 6000);
1131 dib8000_set_adc_state(state, DIBX000_SLOW_ADC_ON);
1132 dib8000_sad_calib(state);
1133 if (state->revision != 0x8090)
1134 dib8000_set_adc_state(state, DIBX000_SLOW_ADC_OFF);
1136 /* ber_rs_len = 3 */
1137 dib8000_write_word(state, 285, (dib8000_read_word(state, 285) & ~0x60) | (3 << 5));
1139 dib8000_set_power_mode(state, DIB8000_POWER_INTERFACE_ONLY);
1141 dib8000_reset_stats(fe);
1143 return 0;
1146 static void dib8000_restart_agc(struct dib8000_state *state)
1148 // P_restart_iqc & P_restart_agc
1149 dib8000_write_word(state, 770, 0x0a00);
1150 dib8000_write_word(state, 770, 0x0000);
1153 static int dib8000_update_lna(struct dib8000_state *state)
1155 u16 dyn_gain;
1157 if (state->cfg.update_lna) {
1158 // read dyn_gain here (because it is demod-dependent and not tuner)
1159 dyn_gain = dib8000_read_word(state, 390);
1161 if (state->cfg.update_lna(state->fe[0], dyn_gain)) {
1162 dib8000_restart_agc(state);
1163 return 1;
1166 return 0;
1169 static int dib8000_set_agc_config(struct dib8000_state *state, u8 band)
1171 struct dibx000_agc_config *agc = NULL;
1172 int i;
1173 u16 reg;
1175 if (state->current_band == band && state->current_agc != NULL)
1176 return 0;
1177 state->current_band = band;
1179 for (i = 0; i < state->cfg.agc_config_count; i++)
1180 if (state->cfg.agc[i].band_caps & band) {
1181 agc = &state->cfg.agc[i];
1182 break;
1185 if (agc == NULL) {
1186 dprintk("no valid AGC configuration found for band 0x%02x\n", band);
1187 return -EINVAL;
1190 state->current_agc = agc;
1192 /* AGC */
1193 dib8000_write_word(state, 76, agc->setup);
1194 dib8000_write_word(state, 77, agc->inv_gain);
1195 dib8000_write_word(state, 78, agc->time_stabiliz);
1196 dib8000_write_word(state, 101, (agc->alpha_level << 12) | agc->thlock);
1198 // Demod AGC loop configuration
1199 dib8000_write_word(state, 102, (agc->alpha_mant << 5) | agc->alpha_exp);
1200 dib8000_write_word(state, 103, (agc->beta_mant << 6) | agc->beta_exp);
1202 dprintk("WBD: ref: %d, sel: %d, active: %d, alpha: %d\n",
1203 state->wbd_ref != 0 ? state->wbd_ref : agc->wbd_ref, agc->wbd_sel, !agc->perform_agc_softsplit, agc->wbd_sel);
1205 /* AGC continued */
1206 if (state->wbd_ref != 0)
1207 dib8000_write_word(state, 106, state->wbd_ref);
1208 else // use default
1209 dib8000_write_word(state, 106, agc->wbd_ref);
1211 if (state->revision == 0x8090) {
1212 reg = dib8000_read_word(state, 922) & (0x3 << 2);
1213 dib8000_write_word(state, 922, reg | (agc->wbd_sel << 2));
1216 dib8000_write_word(state, 107, (agc->wbd_alpha << 9) | (agc->perform_agc_softsplit << 8));
1217 dib8000_write_word(state, 108, agc->agc1_max);
1218 dib8000_write_word(state, 109, agc->agc1_min);
1219 dib8000_write_word(state, 110, agc->agc2_max);
1220 dib8000_write_word(state, 111, agc->agc2_min);
1221 dib8000_write_word(state, 112, (agc->agc1_pt1 << 8) | agc->agc1_pt2);
1222 dib8000_write_word(state, 113, (agc->agc1_slope1 << 8) | agc->agc1_slope2);
1223 dib8000_write_word(state, 114, (agc->agc2_pt1 << 8) | agc->agc2_pt2);
1224 dib8000_write_word(state, 115, (agc->agc2_slope1 << 8) | agc->agc2_slope2);
1226 dib8000_write_word(state, 75, agc->agc1_pt3);
1227 if (state->revision != 0x8090)
1228 dib8000_write_word(state, 923,
1229 (dib8000_read_word(state, 923) & 0xffe3) |
1230 (agc->wbd_inv << 4) | (agc->wbd_sel << 2));
1232 return 0;
1235 static void dib8000_pwm_agc_reset(struct dvb_frontend *fe)
1237 struct dib8000_state *state = fe->demodulator_priv;
1238 dib8000_set_adc_state(state, DIBX000_ADC_ON);
1239 dib8000_set_agc_config(state, (unsigned char)(BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000)));
1242 static int dib8000_agc_soft_split(struct dib8000_state *state)
1244 u16 agc, split_offset;
1246 if (!state->current_agc || !state->current_agc->perform_agc_softsplit || state->current_agc->split.max == 0)
1247 return 0;
1249 // n_agc_global
1250 agc = dib8000_read_word(state, 390);
1252 if (agc > state->current_agc->split.min_thres)
1253 split_offset = state->current_agc->split.min;
1254 else if (agc < state->current_agc->split.max_thres)
1255 split_offset = state->current_agc->split.max;
1256 else
1257 split_offset = state->current_agc->split.max *
1258 (agc - state->current_agc->split.min_thres) /
1259 (state->current_agc->split.max_thres - state->current_agc->split.min_thres);
1261 dprintk("AGC split_offset: %d\n", split_offset);
1263 // P_agc_force_split and P_agc_split_offset
1264 dib8000_write_word(state, 107, (dib8000_read_word(state, 107) & 0xff00) | split_offset);
1265 return 5000;
1268 static int dib8000_agc_startup(struct dvb_frontend *fe)
1270 struct dib8000_state *state = fe->demodulator_priv;
1271 enum frontend_tune_state *tune_state = &state->tune_state;
1272 int ret = 0;
1273 u16 reg;
1274 u32 upd_demod_gain_period = 0x8000;
1276 switch (*tune_state) {
1277 case CT_AGC_START:
1278 // set power-up level: interf+analog+AGC
1280 if (state->revision != 0x8090)
1281 dib8000_set_adc_state(state, DIBX000_ADC_ON);
1282 else {
1283 dib8000_set_power_mode(state, DIB8000_POWER_ALL);
1285 reg = dib8000_read_word(state, 1947)&0xff00;
1286 dib8000_write_word(state, 1946,
1287 upd_demod_gain_period & 0xFFFF);
1288 /* bit 14 = enDemodGain */
1289 dib8000_write_word(state, 1947, reg | (1<<14) |
1290 ((upd_demod_gain_period >> 16) & 0xFF));
1292 /* enable adc i & q */
1293 reg = dib8000_read_word(state, 1920);
1294 dib8000_write_word(state, 1920, (reg | 0x3) &
1295 (~(1 << 7)));
1298 if (dib8000_set_agc_config(state, (unsigned char)(BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000))) != 0) {
1299 *tune_state = CT_AGC_STOP;
1300 state->status = FE_STATUS_TUNE_FAILED;
1301 break;
1304 ret = 70;
1305 *tune_state = CT_AGC_STEP_0;
1306 break;
1308 case CT_AGC_STEP_0:
1309 //AGC initialization
1310 if (state->cfg.agc_control)
1311 state->cfg.agc_control(fe, 1);
1313 dib8000_restart_agc(state);
1315 // wait AGC rough lock time
1316 ret = 50;
1317 *tune_state = CT_AGC_STEP_1;
1318 break;
1320 case CT_AGC_STEP_1:
1321 // wait AGC accurate lock time
1322 ret = 70;
1324 if (dib8000_update_lna(state))
1325 // wait only AGC rough lock time
1326 ret = 50;
1327 else
1328 *tune_state = CT_AGC_STEP_2;
1329 break;
1331 case CT_AGC_STEP_2:
1332 dib8000_agc_soft_split(state);
1334 if (state->cfg.agc_control)
1335 state->cfg.agc_control(fe, 0);
1337 *tune_state = CT_AGC_STOP;
1338 break;
1339 default:
1340 ret = dib8000_agc_soft_split(state);
1341 break;
1343 return ret;
1347 static void dib8096p_host_bus_drive(struct dib8000_state *state, u8 drive)
1349 u16 reg;
1351 drive &= 0x7;
1353 /* drive host bus 2, 3, 4 */
1354 reg = dib8000_read_word(state, 1798) &
1355 ~(0x7 | (0x7 << 6) | (0x7 << 12));
1356 reg |= (drive<<12) | (drive<<6) | drive;
1357 dib8000_write_word(state, 1798, reg);
1359 /* drive host bus 5,6 */
1360 reg = dib8000_read_word(state, 1799) & ~((0x7 << 2) | (0x7 << 8));
1361 reg |= (drive<<8) | (drive<<2);
1362 dib8000_write_word(state, 1799, reg);
1364 /* drive host bus 7, 8, 9 */
1365 reg = dib8000_read_word(state, 1800) &
1366 ~(0x7 | (0x7 << 6) | (0x7 << 12));
1367 reg |= (drive<<12) | (drive<<6) | drive;
1368 dib8000_write_word(state, 1800, reg);
1370 /* drive host bus 10, 11 */
1371 reg = dib8000_read_word(state, 1801) & ~((0x7 << 2) | (0x7 << 8));
1372 reg |= (drive<<8) | (drive<<2);
1373 dib8000_write_word(state, 1801, reg);
1375 /* drive host bus 12, 13, 14 */
1376 reg = dib8000_read_word(state, 1802) &
1377 ~(0x7 | (0x7 << 6) | (0x7 << 12));
1378 reg |= (drive<<12) | (drive<<6) | drive;
1379 dib8000_write_word(state, 1802, reg);
1382 static u32 dib8096p_calcSyncFreq(u32 P_Kin, u32 P_Kout,
1383 u32 insertExtSynchro, u32 syncSize)
1385 u32 quantif = 3;
1386 u32 nom = (insertExtSynchro * P_Kin+syncSize);
1387 u32 denom = P_Kout;
1388 u32 syncFreq = ((nom << quantif) / denom);
1390 if ((syncFreq & ((1 << quantif) - 1)) != 0)
1391 syncFreq = (syncFreq >> quantif) + 1;
1392 else
1393 syncFreq = (syncFreq >> quantif);
1395 if (syncFreq != 0)
1396 syncFreq = syncFreq - 1;
1398 return syncFreq;
1401 static void dib8096p_cfg_DibTx(struct dib8000_state *state, u32 P_Kin,
1402 u32 P_Kout, u32 insertExtSynchro, u32 synchroMode,
1403 u32 syncWord, u32 syncSize)
1405 dprintk("Configure DibStream Tx\n");
1407 dib8000_write_word(state, 1615, 1);
1408 dib8000_write_word(state, 1603, P_Kin);
1409 dib8000_write_word(state, 1605, P_Kout);
1410 dib8000_write_word(state, 1606, insertExtSynchro);
1411 dib8000_write_word(state, 1608, synchroMode);
1412 dib8000_write_word(state, 1609, (syncWord >> 16) & 0xffff);
1413 dib8000_write_word(state, 1610, syncWord & 0xffff);
1414 dib8000_write_word(state, 1612, syncSize);
1415 dib8000_write_word(state, 1615, 0);
1418 static void dib8096p_cfg_DibRx(struct dib8000_state *state, u32 P_Kin,
1419 u32 P_Kout, u32 synchroMode, u32 insertExtSynchro,
1420 u32 syncWord, u32 syncSize, u32 dataOutRate)
1422 u32 syncFreq;
1424 dprintk("Configure DibStream Rx synchroMode = %d\n", synchroMode);
1426 if ((P_Kin != 0) && (P_Kout != 0)) {
1427 syncFreq = dib8096p_calcSyncFreq(P_Kin, P_Kout,
1428 insertExtSynchro, syncSize);
1429 dib8000_write_word(state, 1542, syncFreq);
1432 dib8000_write_word(state, 1554, 1);
1433 dib8000_write_word(state, 1536, P_Kin);
1434 dib8000_write_word(state, 1537, P_Kout);
1435 dib8000_write_word(state, 1539, synchroMode);
1436 dib8000_write_word(state, 1540, (syncWord >> 16) & 0xffff);
1437 dib8000_write_word(state, 1541, syncWord & 0xffff);
1438 dib8000_write_word(state, 1543, syncSize);
1439 dib8000_write_word(state, 1544, dataOutRate);
1440 dib8000_write_word(state, 1554, 0);
1443 static void dib8096p_enMpegMux(struct dib8000_state *state, int onoff)
1445 u16 reg_1287;
1447 reg_1287 = dib8000_read_word(state, 1287);
1449 switch (onoff) {
1450 case 1:
1451 reg_1287 &= ~(1 << 8);
1452 break;
1453 case 0:
1454 reg_1287 |= (1 << 8);
1455 break;
1458 dib8000_write_word(state, 1287, reg_1287);
1461 static void dib8096p_configMpegMux(struct dib8000_state *state,
1462 u16 pulseWidth, u16 enSerialMode, u16 enSerialClkDiv2)
1464 u16 reg_1287;
1466 dprintk("Enable Mpeg mux\n");
1468 dib8096p_enMpegMux(state, 0);
1470 /* If the input mode is MPEG do not divide the serial clock */
1471 if ((enSerialMode == 1) && (state->input_mode_mpeg == 1))
1472 enSerialClkDiv2 = 0;
1474 reg_1287 = ((pulseWidth & 0x1f) << 3) |
1475 ((enSerialMode & 0x1) << 2) | (enSerialClkDiv2 & 0x1);
1476 dib8000_write_word(state, 1287, reg_1287);
1478 dib8096p_enMpegMux(state, 1);
1481 static void dib8096p_setDibTxMux(struct dib8000_state *state, int mode)
1483 u16 reg_1288 = dib8000_read_word(state, 1288) & ~(0x7 << 7);
1485 switch (mode) {
1486 case MPEG_ON_DIBTX:
1487 dprintk("SET MPEG ON DIBSTREAM TX\n");
1488 dib8096p_cfg_DibTx(state, 8, 5, 0, 0, 0, 0);
1489 reg_1288 |= (1 << 9); break;
1490 case DIV_ON_DIBTX:
1491 dprintk("SET DIV_OUT ON DIBSTREAM TX\n");
1492 dib8096p_cfg_DibTx(state, 5, 5, 0, 0, 0, 0);
1493 reg_1288 |= (1 << 8); break;
1494 case ADC_ON_DIBTX:
1495 dprintk("SET ADC_OUT ON DIBSTREAM TX\n");
1496 dib8096p_cfg_DibTx(state, 20, 5, 10, 0, 0, 0);
1497 reg_1288 |= (1 << 7); break;
1498 default:
1499 break;
1501 dib8000_write_word(state, 1288, reg_1288);
1504 static void dib8096p_setHostBusMux(struct dib8000_state *state, int mode)
1506 u16 reg_1288 = dib8000_read_word(state, 1288) & ~(0x7 << 4);
1508 switch (mode) {
1509 case DEMOUT_ON_HOSTBUS:
1510 dprintk("SET DEM OUT OLD INTERF ON HOST BUS\n");
1511 dib8096p_enMpegMux(state, 0);
1512 reg_1288 |= (1 << 6);
1513 break;
1514 case DIBTX_ON_HOSTBUS:
1515 dprintk("SET DIBSTREAM TX ON HOST BUS\n");
1516 dib8096p_enMpegMux(state, 0);
1517 reg_1288 |= (1 << 5);
1518 break;
1519 case MPEG_ON_HOSTBUS:
1520 dprintk("SET MPEG MUX ON HOST BUS\n");
1521 reg_1288 |= (1 << 4);
1522 break;
1523 default:
1524 break;
1526 dib8000_write_word(state, 1288, reg_1288);
1529 static int dib8096p_set_diversity_in(struct dvb_frontend *fe, int onoff)
1531 struct dib8000_state *state = fe->demodulator_priv;
1532 u16 reg_1287;
1534 switch (onoff) {
1535 case 0: /* only use the internal way - not the diversity input */
1536 dprintk("%s mode OFF : by default Enable Mpeg INPUT\n",
1537 __func__);
1538 /* outputRate = 8 */
1539 dib8096p_cfg_DibRx(state, 8, 5, 0, 0, 0, 8, 0);
1541 /* Do not divide the serial clock of MPEG MUX in
1542 SERIAL MODE in case input mode MPEG is used */
1543 reg_1287 = dib8000_read_word(state, 1287);
1544 /* enSerialClkDiv2 == 1 ? */
1545 if ((reg_1287 & 0x1) == 1) {
1546 /* force enSerialClkDiv2 = 0 */
1547 reg_1287 &= ~0x1;
1548 dib8000_write_word(state, 1287, reg_1287);
1550 state->input_mode_mpeg = 1;
1551 break;
1552 case 1: /* both ways */
1553 case 2: /* only the diversity input */
1554 dprintk("%s ON : Enable diversity INPUT\n", __func__);
1555 dib8096p_cfg_DibRx(state, 5, 5, 0, 0, 0, 0, 0);
1556 state->input_mode_mpeg = 0;
1557 break;
1560 dib8000_set_diversity_in(state->fe[0], onoff);
1561 return 0;
1564 static int dib8096p_set_output_mode(struct dvb_frontend *fe, int mode)
1566 struct dib8000_state *state = fe->demodulator_priv;
1567 u16 outreg, smo_mode, fifo_threshold;
1568 u8 prefer_mpeg_mux_use = 1;
1569 int ret = 0;
1571 state->output_mode = mode;
1572 dib8096p_host_bus_drive(state, 1);
1574 fifo_threshold = 1792;
1575 smo_mode = (dib8000_read_word(state, 299) & 0x0050) | (1 << 1);
1576 outreg = dib8000_read_word(state, 1286) &
1577 ~((1 << 10) | (0x7 << 6) | (1 << 1));
1579 switch (mode) {
1580 case OUTMODE_HIGH_Z:
1581 outreg = 0;
1582 break;
1584 case OUTMODE_MPEG2_SERIAL:
1585 if (prefer_mpeg_mux_use) {
1586 dprintk("dib8096P setting output mode TS_SERIAL using Mpeg Mux\n");
1587 dib8096p_configMpegMux(state, 3, 1, 1);
1588 dib8096p_setHostBusMux(state, MPEG_ON_HOSTBUS);
1589 } else {/* Use Smooth block */
1590 dprintk("dib8096P setting output mode TS_SERIAL using Smooth bloc\n");
1591 dib8096p_setHostBusMux(state,
1592 DEMOUT_ON_HOSTBUS);
1593 outreg |= (2 << 6) | (0 << 1);
1595 break;
1597 case OUTMODE_MPEG2_PAR_GATED_CLK:
1598 if (prefer_mpeg_mux_use) {
1599 dprintk("dib8096P setting output mode TS_PARALLEL_GATED using Mpeg Mux\n");
1600 dib8096p_configMpegMux(state, 2, 0, 0);
1601 dib8096p_setHostBusMux(state, MPEG_ON_HOSTBUS);
1602 } else { /* Use Smooth block */
1603 dprintk("dib8096P setting output mode TS_PARALLEL_GATED using Smooth block\n");
1604 dib8096p_setHostBusMux(state,
1605 DEMOUT_ON_HOSTBUS);
1606 outreg |= (0 << 6);
1608 break;
1610 case OUTMODE_MPEG2_PAR_CONT_CLK: /* Using Smooth block only */
1611 dprintk("dib8096P setting output mode TS_PARALLEL_CONT using Smooth block\n");
1612 dib8096p_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
1613 outreg |= (1 << 6);
1614 break;
1616 case OUTMODE_MPEG2_FIFO:
1617 /* Using Smooth block because not supported
1618 by new Mpeg Mux bloc */
1619 dprintk("dib8096P setting output mode TS_FIFO using Smooth block\n");
1620 dib8096p_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
1621 outreg |= (5 << 6);
1622 smo_mode |= (3 << 1);
1623 fifo_threshold = 512;
1624 break;
1626 case OUTMODE_DIVERSITY:
1627 dprintk("dib8096P setting output mode MODE_DIVERSITY\n");
1628 dib8096p_setDibTxMux(state, DIV_ON_DIBTX);
1629 dib8096p_setHostBusMux(state, DIBTX_ON_HOSTBUS);
1630 break;
1632 case OUTMODE_ANALOG_ADC:
1633 dprintk("dib8096P setting output mode MODE_ANALOG_ADC\n");
1634 dib8096p_setDibTxMux(state, ADC_ON_DIBTX);
1635 dib8096p_setHostBusMux(state, DIBTX_ON_HOSTBUS);
1636 break;
1639 if (mode != OUTMODE_HIGH_Z)
1640 outreg |= (1<<10);
1642 dprintk("output_mpeg2_in_188_bytes = %d\n",
1643 state->cfg.output_mpeg2_in_188_bytes);
1644 if (state->cfg.output_mpeg2_in_188_bytes)
1645 smo_mode |= (1 << 5);
1647 ret |= dib8000_write_word(state, 299, smo_mode);
1648 /* synchronous fread */
1649 ret |= dib8000_write_word(state, 299 + 1, fifo_threshold);
1650 ret |= dib8000_write_word(state, 1286, outreg);
1652 return ret;
1655 static int map_addr_to_serpar_number(struct i2c_msg *msg)
1657 if (msg->buf[0] <= 15)
1658 msg->buf[0] -= 1;
1659 else if (msg->buf[0] == 17)
1660 msg->buf[0] = 15;
1661 else if (msg->buf[0] == 16)
1662 msg->buf[0] = 17;
1663 else if (msg->buf[0] == 19)
1664 msg->buf[0] = 16;
1665 else if (msg->buf[0] >= 21 && msg->buf[0] <= 25)
1666 msg->buf[0] -= 3;
1667 else if (msg->buf[0] == 28)
1668 msg->buf[0] = 23;
1669 else if (msg->buf[0] == 99)
1670 msg->buf[0] = 99;
1671 else
1672 return -EINVAL;
1673 return 0;
1676 static int dib8096p_tuner_write_serpar(struct i2c_adapter *i2c_adap,
1677 struct i2c_msg msg[], int num)
1679 struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1680 u8 n_overflow = 1;
1681 u16 i = 1000;
1682 u16 serpar_num = msg[0].buf[0];
1684 while (n_overflow == 1 && i) {
1685 n_overflow = (dib8000_read_word(state, 1984) >> 1) & 0x1;
1686 i--;
1687 if (i == 0)
1688 dprintk("Tuner ITF: write busy (overflow)\n");
1690 dib8000_write_word(state, 1985, (1 << 6) | (serpar_num & 0x3f));
1691 dib8000_write_word(state, 1986, (msg[0].buf[1] << 8) | msg[0].buf[2]);
1693 return num;
1696 static int dib8096p_tuner_read_serpar(struct i2c_adapter *i2c_adap,
1697 struct i2c_msg msg[], int num)
1699 struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1700 u8 n_overflow = 1, n_empty = 1;
1701 u16 i = 1000;
1702 u16 serpar_num = msg[0].buf[0];
1703 u16 read_word;
1705 while (n_overflow == 1 && i) {
1706 n_overflow = (dib8000_read_word(state, 1984) >> 1) & 0x1;
1707 i--;
1708 if (i == 0)
1709 dprintk("TunerITF: read busy (overflow)\n");
1711 dib8000_write_word(state, 1985, (0<<6) | (serpar_num&0x3f));
1713 i = 1000;
1714 while (n_empty == 1 && i) {
1715 n_empty = dib8000_read_word(state, 1984)&0x1;
1716 i--;
1717 if (i == 0)
1718 dprintk("TunerITF: read busy (empty)\n");
1721 read_word = dib8000_read_word(state, 1987);
1722 msg[1].buf[0] = (read_word >> 8) & 0xff;
1723 msg[1].buf[1] = (read_word) & 0xff;
1725 return num;
1728 static int dib8096p_tuner_rw_serpar(struct i2c_adapter *i2c_adap,
1729 struct i2c_msg msg[], int num)
1731 if (map_addr_to_serpar_number(&msg[0]) == 0) {
1732 if (num == 1) /* write */
1733 return dib8096p_tuner_write_serpar(i2c_adap, msg, 1);
1734 else /* read */
1735 return dib8096p_tuner_read_serpar(i2c_adap, msg, 2);
1737 return num;
1740 static int dib8096p_rw_on_apb(struct i2c_adapter *i2c_adap,
1741 struct i2c_msg msg[], int num, u16 apb_address)
1743 struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1744 u16 word;
1746 if (num == 1) { /* write */
1747 dib8000_write_word(state, apb_address,
1748 ((msg[0].buf[1] << 8) | (msg[0].buf[2])));
1749 } else {
1750 word = dib8000_read_word(state, apb_address);
1751 msg[1].buf[0] = (word >> 8) & 0xff;
1752 msg[1].buf[1] = (word) & 0xff;
1754 return num;
1757 static int dib8096p_tuner_xfer(struct i2c_adapter *i2c_adap,
1758 struct i2c_msg msg[], int num)
1760 struct dib8000_state *state = i2c_get_adapdata(i2c_adap);
1761 u16 apb_address = 0, word;
1762 int i = 0;
1764 switch (msg[0].buf[0]) {
1765 case 0x12:
1766 apb_address = 1920;
1767 break;
1768 case 0x14:
1769 apb_address = 1921;
1770 break;
1771 case 0x24:
1772 apb_address = 1922;
1773 break;
1774 case 0x1a:
1775 apb_address = 1923;
1776 break;
1777 case 0x22:
1778 apb_address = 1924;
1779 break;
1780 case 0x33:
1781 apb_address = 1926;
1782 break;
1783 case 0x34:
1784 apb_address = 1927;
1785 break;
1786 case 0x35:
1787 apb_address = 1928;
1788 break;
1789 case 0x36:
1790 apb_address = 1929;
1791 break;
1792 case 0x37:
1793 apb_address = 1930;
1794 break;
1795 case 0x38:
1796 apb_address = 1931;
1797 break;
1798 case 0x39:
1799 apb_address = 1932;
1800 break;
1801 case 0x2a:
1802 apb_address = 1935;
1803 break;
1804 case 0x2b:
1805 apb_address = 1936;
1806 break;
1807 case 0x2c:
1808 apb_address = 1937;
1809 break;
1810 case 0x2d:
1811 apb_address = 1938;
1812 break;
1813 case 0x2e:
1814 apb_address = 1939;
1815 break;
1816 case 0x2f:
1817 apb_address = 1940;
1818 break;
1819 case 0x30:
1820 apb_address = 1941;
1821 break;
1822 case 0x31:
1823 apb_address = 1942;
1824 break;
1825 case 0x32:
1826 apb_address = 1943;
1827 break;
1828 case 0x3e:
1829 apb_address = 1944;
1830 break;
1831 case 0x3f:
1832 apb_address = 1945;
1833 break;
1834 case 0x40:
1835 apb_address = 1948;
1836 break;
1837 case 0x25:
1838 apb_address = 936;
1839 break;
1840 case 0x26:
1841 apb_address = 937;
1842 break;
1843 case 0x27:
1844 apb_address = 938;
1845 break;
1846 case 0x28:
1847 apb_address = 939;
1848 break;
1849 case 0x1d:
1850 /* get sad sel request */
1851 i = ((dib8000_read_word(state, 921) >> 12)&0x3);
1852 word = dib8000_read_word(state, 924+i);
1853 msg[1].buf[0] = (word >> 8) & 0xff;
1854 msg[1].buf[1] = (word) & 0xff;
1855 return num;
1856 case 0x1f:
1857 if (num == 1) { /* write */
1858 word = (u16) ((msg[0].buf[1] << 8) |
1859 msg[0].buf[2]);
1860 /* in the VGAMODE Sel are located on bit 0/1 */
1861 word &= 0x3;
1862 word = (dib8000_read_word(state, 921) &
1863 ~(3<<12)) | (word<<12);
1864 /* Set the proper input */
1865 dib8000_write_word(state, 921, word);
1866 return num;
1870 if (apb_address != 0) /* R/W acces via APB */
1871 return dib8096p_rw_on_apb(i2c_adap, msg, num, apb_address);
1872 else /* R/W access via SERPAR */
1873 return dib8096p_tuner_rw_serpar(i2c_adap, msg, num);
1875 return 0;
1878 static u32 dib8096p_i2c_func(struct i2c_adapter *adapter)
1880 return I2C_FUNC_I2C;
1883 static const struct i2c_algorithm dib8096p_tuner_xfer_algo = {
1884 .master_xfer = dib8096p_tuner_xfer,
1885 .functionality = dib8096p_i2c_func,
1888 static struct i2c_adapter *dib8096p_get_i2c_tuner(struct dvb_frontend *fe)
1890 struct dib8000_state *st = fe->demodulator_priv;
1891 return &st->dib8096p_tuner_adap;
1894 static int dib8096p_tuner_sleep(struct dvb_frontend *fe, int onoff)
1896 struct dib8000_state *state = fe->demodulator_priv;
1897 u16 en_cur_state;
1899 dprintk("sleep dib8096p: %d\n", onoff);
1901 en_cur_state = dib8000_read_word(state, 1922);
1903 /* LNAs and MIX are ON and therefore it is a valid configuration */
1904 if (en_cur_state > 0xff)
1905 state->tuner_enable = en_cur_state ;
1907 if (onoff)
1908 en_cur_state &= 0x00ff;
1909 else {
1910 if (state->tuner_enable != 0)
1911 en_cur_state = state->tuner_enable;
1914 dib8000_write_word(state, 1922, en_cur_state);
1916 return 0;
1919 static const s32 lut_1000ln_mant[] =
1921 908, 7003, 7090, 7170, 7244, 7313, 7377, 7438, 7495, 7549, 7600
1924 static s32 dib8000_get_adc_power(struct dvb_frontend *fe, u8 mode)
1926 struct dib8000_state *state = fe->demodulator_priv;
1927 u32 ix = 0, tmp_val = 0, exp = 0, mant = 0;
1928 s32 val;
1930 val = dib8000_read32(state, 384);
1931 if (mode) {
1932 tmp_val = val;
1933 while (tmp_val >>= 1)
1934 exp++;
1935 mant = (val * 1000 / (1<<exp));
1936 ix = (u8)((mant-1000)/100); /* index of the LUT */
1937 val = (lut_1000ln_mant[ix] + 693*(exp-20) - 6908);
1938 val = (val*256)/1000;
1940 return val;
1943 static int dib8090p_get_dc_power(struct dvb_frontend *fe, u8 IQ)
1945 struct dib8000_state *state = fe->demodulator_priv;
1946 int val = 0;
1948 switch (IQ) {
1949 case 1:
1950 val = dib8000_read_word(state, 403);
1951 break;
1952 case 0:
1953 val = dib8000_read_word(state, 404);
1954 break;
1956 if (val & 0x200)
1957 val -= 1024;
1959 return val;
1962 static void dib8000_update_timf(struct dib8000_state *state)
1964 u32 timf = state->timf = dib8000_read32(state, 435);
1966 dib8000_write_word(state, 29, (u16) (timf >> 16));
1967 dib8000_write_word(state, 30, (u16) (timf & 0xffff));
1968 dprintk("Updated timing frequency: %d (default: %d)\n", state->timf, state->timf_default);
1971 static u32 dib8000_ctrl_timf(struct dvb_frontend *fe, uint8_t op, uint32_t timf)
1973 struct dib8000_state *state = fe->demodulator_priv;
1975 switch (op) {
1976 case DEMOD_TIMF_SET:
1977 state->timf = timf;
1978 break;
1979 case DEMOD_TIMF_UPDATE:
1980 dib8000_update_timf(state);
1981 break;
1982 case DEMOD_TIMF_GET:
1983 break;
1985 dib8000_set_bandwidth(state->fe[0], 6000);
1987 return state->timf;
1990 static const u16 adc_target_16dB[11] = {
1991 7250, 7238, 7264, 7309, 7338, 7382, 7427, 7456, 7500, 7544, 7574
1994 static const u8 permu_seg[] = { 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12 };
1996 static u16 dib8000_set_layer(struct dib8000_state *state, u8 layer_index, u16 max_constellation)
1998 u8 cr, constellation, time_intlv;
1999 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2001 switch (c->layer[layer_index].modulation) {
2002 case DQPSK:
2003 constellation = 0;
2004 break;
2005 case QPSK:
2006 constellation = 1;
2007 break;
2008 case QAM_16:
2009 constellation = 2;
2010 break;
2011 case QAM_64:
2012 default:
2013 constellation = 3;
2014 break;
2017 switch (c->layer[layer_index].fec) {
2018 case FEC_1_2:
2019 cr = 1;
2020 break;
2021 case FEC_2_3:
2022 cr = 2;
2023 break;
2024 case FEC_3_4:
2025 cr = 3;
2026 break;
2027 case FEC_5_6:
2028 cr = 5;
2029 break;
2030 case FEC_7_8:
2031 default:
2032 cr = 7;
2033 break;
2036 time_intlv = fls(c->layer[layer_index].interleaving);
2037 if (time_intlv > 3 && !(time_intlv == 4 && c->isdbt_sb_mode == 1))
2038 time_intlv = 0;
2040 dib8000_write_word(state, 2 + layer_index, (constellation << 10) | ((c->layer[layer_index].segment_count & 0xf) << 6) | (cr << 3) | time_intlv);
2041 if (c->layer[layer_index].segment_count > 0) {
2042 switch (max_constellation) {
2043 case DQPSK:
2044 case QPSK:
2045 if (c->layer[layer_index].modulation == QAM_16 || c->layer[layer_index].modulation == QAM_64)
2046 max_constellation = c->layer[layer_index].modulation;
2047 break;
2048 case QAM_16:
2049 if (c->layer[layer_index].modulation == QAM_64)
2050 max_constellation = c->layer[layer_index].modulation;
2051 break;
2055 return max_constellation;
2058 static const u16 adp_Q64[4] = {0x0148, 0xfff0, 0x00a4, 0xfff8}; /* P_adp_regul_cnt 0.04, P_adp_noise_cnt -0.002, P_adp_regul_ext 0.02, P_adp_noise_ext -0.001 */
2059 static const u16 adp_Q16[4] = {0x023d, 0xffdf, 0x00a4, 0xfff0}; /* P_adp_regul_cnt 0.07, P_adp_noise_cnt -0.004, P_adp_regul_ext 0.02, P_adp_noise_ext -0.002 */
2060 static const u16 adp_Qdefault[4] = {0x099a, 0xffae, 0x0333, 0xfff8}; /* P_adp_regul_cnt 0.3, P_adp_noise_cnt -0.01, P_adp_regul_ext 0.1, P_adp_noise_ext -0.002 */
2061 static u16 dib8000_adp_fine_tune(struct dib8000_state *state, u16 max_constellation)
2063 u16 i, ana_gain = 0;
2064 const u16 *adp;
2066 /* channel estimation fine configuration */
2067 switch (max_constellation) {
2068 case QAM_64:
2069 ana_gain = 0x7;
2070 adp = &adp_Q64[0];
2071 break;
2072 case QAM_16:
2073 ana_gain = 0x7;
2074 adp = &adp_Q16[0];
2075 break;
2076 default:
2077 ana_gain = 0;
2078 adp = &adp_Qdefault[0];
2079 break;
2082 for (i = 0; i < 4; i++)
2083 dib8000_write_word(state, 215 + i, adp[i]);
2085 return ana_gain;
2088 static void dib8000_update_ana_gain(struct dib8000_state *state, u16 ana_gain)
2090 u16 i;
2092 dib8000_write_word(state, 116, ana_gain);
2094 /* update ADC target depending on ana_gain */
2095 if (ana_gain) { /* set -16dB ADC target for ana_gain=-1 */
2096 for (i = 0; i < 10; i++)
2097 dib8000_write_word(state, 80 + i, adc_target_16dB[i]);
2098 } else { /* set -22dB ADC target for ana_gain=0 */
2099 for (i = 0; i < 10; i++)
2100 dib8000_write_word(state, 80 + i, adc_target_16dB[i] - 355);
2104 static void dib8000_load_ana_fe_coefs(struct dib8000_state *state, const s16 *ana_fe)
2106 u16 mode = 0;
2108 if (state->isdbt_cfg_loaded == 0)
2109 for (mode = 0; mode < 24; mode++)
2110 dib8000_write_word(state, 117 + mode, ana_fe[mode]);
2113 static const u16 lut_prbs_2k[14] = {
2114 0, 0x423, 0x009, 0x5C7, 0x7A6, 0x3D8, 0x527, 0x7FF, 0x79B, 0x3D6, 0x3A2, 0x53B, 0x2F4, 0x213
2116 static const u16 lut_prbs_4k[14] = {
2117 0, 0x208, 0x0C3, 0x7B9, 0x423, 0x5C7, 0x3D8, 0x7FF, 0x3D6, 0x53B, 0x213, 0x029, 0x0D0, 0x48E
2119 static const u16 lut_prbs_8k[14] = {
2120 0, 0x740, 0x069, 0x7DD, 0x208, 0x7B9, 0x5C7, 0x7FF, 0x53B, 0x029, 0x48E, 0x4C4, 0x367, 0x684
2123 static u16 dib8000_get_init_prbs(struct dib8000_state *state, u16 subchannel)
2125 int sub_channel_prbs_group = 0;
2127 sub_channel_prbs_group = (subchannel / 3) + 1;
2128 dprintk("sub_channel_prbs_group = %d , subchannel =%d prbs = 0x%04x\n", sub_channel_prbs_group, subchannel, lut_prbs_8k[sub_channel_prbs_group]);
2130 switch (state->fe[0]->dtv_property_cache.transmission_mode) {
2131 case TRANSMISSION_MODE_2K:
2132 return lut_prbs_2k[sub_channel_prbs_group];
2133 case TRANSMISSION_MODE_4K:
2134 return lut_prbs_4k[sub_channel_prbs_group];
2135 default:
2136 case TRANSMISSION_MODE_8K:
2137 return lut_prbs_8k[sub_channel_prbs_group];
2141 static void dib8000_set_13seg_channel(struct dib8000_state *state)
2143 u16 i;
2144 u16 coff_pow = 0x2800;
2146 state->seg_mask = 0x1fff; /* All 13 segments enabled */
2148 /* ---- COFF ---- Carloff, the most robust --- */
2149 if (state->isdbt_cfg_loaded == 0) { /* if not Sound Broadcasting mode : put default values for 13 segments */
2150 dib8000_write_word(state, 180, (16 << 6) | 9);
2151 dib8000_write_word(state, 187, (4 << 12) | (8 << 5) | 0x2);
2152 coff_pow = 0x2800;
2153 for (i = 0; i < 6; i++)
2154 dib8000_write_word(state, 181+i, coff_pow);
2156 /* P_ctrl_corm_thres4pre_freq_inh=1, P_ctrl_pre_freq_mode_sat=1 */
2157 /* P_ctrl_pre_freq_mode_sat=1, P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 3, P_pre_freq_win_len=1 */
2158 dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (3 << 5) | 1);
2160 /* P_ctrl_pre_freq_win_len=8, P_ctrl_pre_freq_thres_lockin=6 */
2161 dib8000_write_word(state, 340, (8 << 6) | (6 << 0));
2162 /* P_ctrl_pre_freq_thres_lockout=4, P_small_use_tmcc/ac/cp=1 */
2163 dib8000_write_word(state, 341, (4 << 3) | (1 << 2) | (1 << 1) | (1 << 0));
2165 dib8000_write_word(state, 228, 0); /* default value */
2166 dib8000_write_word(state, 265, 31); /* default value */
2167 dib8000_write_word(state, 205, 0x200f); /* init value */
2171 * make the cpil_coff_lock more robust but slower p_coff_winlen
2172 * 6bits; p_coff_thres_lock 6bits (for coff lock if needed)
2175 if (state->cfg.pll->ifreq == 0)
2176 dib8000_write_word(state, 266, ~state->seg_mask | state->seg_diff_mask | 0x40); /* P_equal_noise_seg_inh */
2178 dib8000_load_ana_fe_coefs(state, ana_fe_coeff_13seg);
2181 static void dib8000_set_subchannel_prbs(struct dib8000_state *state, u16 init_prbs)
2183 u16 reg_1;
2185 reg_1 = dib8000_read_word(state, 1);
2186 dib8000_write_word(state, 1, (init_prbs << 2) | (reg_1 & 0x3)); /* ADDR 1 */
2189 static void dib8000_small_fine_tune(struct dib8000_state *state)
2191 u16 i;
2192 const s16 *ncoeff;
2193 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2195 dib8000_write_word(state, 352, state->seg_diff_mask);
2196 dib8000_write_word(state, 353, state->seg_mask);
2198 /* P_small_coef_ext_enable=ISDB-Tsb, P_small_narrow_band=ISDB-Tsb, P_small_last_seg=13, P_small_offset_num_car=5 */
2199 dib8000_write_word(state, 351, (c->isdbt_sb_mode << 9) | (c->isdbt_sb_mode << 8) | (13 << 4) | 5);
2201 if (c->isdbt_sb_mode) {
2202 /* ---- SMALL ---- */
2203 switch (c->transmission_mode) {
2204 case TRANSMISSION_MODE_2K:
2205 if (c->isdbt_partial_reception == 0) { /* 1-seg */
2206 if (c->layer[0].modulation == DQPSK) /* DQPSK */
2207 ncoeff = coeff_2k_sb_1seg_dqpsk;
2208 else /* QPSK or QAM */
2209 ncoeff = coeff_2k_sb_1seg;
2210 } else { /* 3-segments */
2211 if (c->layer[0].modulation == DQPSK) { /* DQPSK on central segment */
2212 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2213 ncoeff = coeff_2k_sb_3seg_0dqpsk_1dqpsk;
2214 else /* QPSK or QAM on external segments */
2215 ncoeff = coeff_2k_sb_3seg_0dqpsk;
2216 } else { /* QPSK or QAM on central segment */
2217 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2218 ncoeff = coeff_2k_sb_3seg_1dqpsk;
2219 else /* QPSK or QAM on external segments */
2220 ncoeff = coeff_2k_sb_3seg;
2223 break;
2224 case TRANSMISSION_MODE_4K:
2225 if (c->isdbt_partial_reception == 0) { /* 1-seg */
2226 if (c->layer[0].modulation == DQPSK) /* DQPSK */
2227 ncoeff = coeff_4k_sb_1seg_dqpsk;
2228 else /* QPSK or QAM */
2229 ncoeff = coeff_4k_sb_1seg;
2230 } else { /* 3-segments */
2231 if (c->layer[0].modulation == DQPSK) { /* DQPSK on central segment */
2232 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2233 ncoeff = coeff_4k_sb_3seg_0dqpsk_1dqpsk;
2234 else /* QPSK or QAM on external segments */
2235 ncoeff = coeff_4k_sb_3seg_0dqpsk;
2236 } else { /* QPSK or QAM on central segment */
2237 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2238 ncoeff = coeff_4k_sb_3seg_1dqpsk;
2239 else /* QPSK or QAM on external segments */
2240 ncoeff = coeff_4k_sb_3seg;
2243 break;
2244 case TRANSMISSION_MODE_AUTO:
2245 case TRANSMISSION_MODE_8K:
2246 default:
2247 if (c->isdbt_partial_reception == 0) { /* 1-seg */
2248 if (c->layer[0].modulation == DQPSK) /* DQPSK */
2249 ncoeff = coeff_8k_sb_1seg_dqpsk;
2250 else /* QPSK or QAM */
2251 ncoeff = coeff_8k_sb_1seg;
2252 } else { /* 3-segments */
2253 if (c->layer[0].modulation == DQPSK) { /* DQPSK on central segment */
2254 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2255 ncoeff = coeff_8k_sb_3seg_0dqpsk_1dqpsk;
2256 else /* QPSK or QAM on external segments */
2257 ncoeff = coeff_8k_sb_3seg_0dqpsk;
2258 } else { /* QPSK or QAM on central segment */
2259 if (c->layer[1].modulation == DQPSK) /* DQPSK on external segments */
2260 ncoeff = coeff_8k_sb_3seg_1dqpsk;
2261 else /* QPSK or QAM on external segments */
2262 ncoeff = coeff_8k_sb_3seg;
2265 break;
2268 for (i = 0; i < 8; i++)
2269 dib8000_write_word(state, 343 + i, ncoeff[i]);
2273 static const u16 coff_thres_1seg[3] = {300, 150, 80};
2274 static const u16 coff_thres_3seg[3] = {350, 300, 250};
2275 static void dib8000_set_sb_channel(struct dib8000_state *state)
2277 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2278 const u16 *coff;
2279 u16 i;
2281 if (c->transmission_mode == TRANSMISSION_MODE_2K || c->transmission_mode == TRANSMISSION_MODE_4K) {
2282 dib8000_write_word(state, 219, dib8000_read_word(state, 219) | 0x1); /* adp_pass =1 */
2283 dib8000_write_word(state, 190, dib8000_read_word(state, 190) | (0x1 << 14)); /* pha3_force_pha_shift = 1 */
2284 } else {
2285 dib8000_write_word(state, 219, dib8000_read_word(state, 219) & 0xfffe); /* adp_pass =0 */
2286 dib8000_write_word(state, 190, dib8000_read_word(state, 190) & 0xbfff); /* pha3_force_pha_shift = 0 */
2289 if (c->isdbt_partial_reception == 1) /* 3-segments */
2290 state->seg_mask = 0x00E0;
2291 else /* 1-segment */
2292 state->seg_mask = 0x0040;
2294 dib8000_write_word(state, 268, (dib8000_read_word(state, 268) & 0xF9FF) | 0x0200);
2296 /* ---- COFF ---- Carloff, the most robust --- */
2297 /* P_coff_cpil_alpha=4, P_coff_inh=0, P_coff_cpil_winlen=64, P_coff_narrow_band=1, P_coff_square_val=1, P_coff_one_seg=~partial_rcpt, P_coff_use_tmcc=1, P_coff_use_ac=1 */
2298 dib8000_write_word(state, 187, (4 << 12) | (0 << 11) | (63 << 5) | (0x3 << 3) | ((~c->isdbt_partial_reception & 1) << 2) | 0x3);
2300 dib8000_write_word(state, 340, (16 << 6) | (8 << 0)); /* P_ctrl_pre_freq_win_len=16, P_ctrl_pre_freq_thres_lockin=8 */
2301 dib8000_write_word(state, 341, (6 << 3) | (1 << 2) | (1 << 1) | (1 << 0));/* P_ctrl_pre_freq_thres_lockout=6, P_small_use_tmcc/ac/cp=1 */
2303 /* Sound Broadcasting mode 1 seg */
2304 if (c->isdbt_partial_reception == 0) {
2305 /* P_coff_winlen=63, P_coff_thres_lock=15, P_coff_one_seg_width = (P_mode == 3) , P_coff_one_seg_sym = (P_mode-1) */
2306 if (state->mode == 3)
2307 dib8000_write_word(state, 180, 0x1fcf | ((state->mode - 1) << 14));
2308 else
2309 dib8000_write_word(state, 180, 0x0fcf | ((state->mode - 1) << 14));
2311 /* P_ctrl_corm_thres4pre_freq_inh=1,P_ctrl_pre_freq_mode_sat=1, P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 5, P_pre_freq_win_len=4 */
2312 dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (5 << 5) | 4);
2313 coff = &coff_thres_1seg[0];
2314 } else { /* Sound Broadcasting mode 3 seg */
2315 dib8000_write_word(state, 180, 0x1fcf | (1 << 14));
2316 /* P_ctrl_corm_thres4pre_freq_inh = 1, P_ctrl_pre_freq_mode_sat=1, P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 4, P_pre_freq_win_len=4 */
2317 dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (4 << 5) | 4);
2318 coff = &coff_thres_3seg[0];
2321 dib8000_write_word(state, 228, 1); /* P_2d_mode_byp=1 */
2322 dib8000_write_word(state, 205, dib8000_read_word(state, 205) & 0xfff0); /* P_cspu_win_cut = 0 */
2324 if (c->isdbt_partial_reception == 0 && c->transmission_mode == TRANSMISSION_MODE_2K)
2325 dib8000_write_word(state, 265, 15); /* P_equal_noise_sel = 15 */
2327 /* Write COFF thres */
2328 for (i = 0 ; i < 3; i++) {
2329 dib8000_write_word(state, 181+i, coff[i]);
2330 dib8000_write_word(state, 184+i, coff[i]);
2334 * make the cpil_coff_lock more robust but slower p_coff_winlen
2335 * 6bits; p_coff_thres_lock 6bits (for coff lock if needed)
2338 dib8000_write_word(state, 266, ~state->seg_mask | state->seg_diff_mask); /* P_equal_noise_seg_inh */
2340 if (c->isdbt_partial_reception == 0)
2341 dib8000_write_word(state, 178, 64); /* P_fft_powrange = 64 */
2342 else
2343 dib8000_write_word(state, 178, 32); /* P_fft_powrange = 32 */
2346 static void dib8000_set_isdbt_common_channel(struct dib8000_state *state, u8 seq, u8 autosearching)
2348 u16 p_cfr_left_edge = 0, p_cfr_right_edge = 0;
2349 u16 tmcc_pow = 0, ana_gain = 0, tmp = 0, i = 0, nbseg_diff = 0 ;
2350 u16 max_constellation = DQPSK;
2351 int init_prbs;
2352 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2354 if (autosearching)
2355 c->isdbt_partial_reception = 1;
2357 /* P_mode */
2358 dib8000_write_word(state, 10, (seq << 4));
2360 /* init mode */
2361 state->mode = fft_to_mode(state);
2363 /* set guard */
2364 tmp = dib8000_read_word(state, 1);
2365 dib8000_write_word(state, 1, (tmp&0xfffc) | (c->guard_interval & 0x3));
2367 dib8000_write_word(state, 274, (dib8000_read_word(state, 274) & 0xffcf) | ((c->isdbt_partial_reception & 1) << 5) | ((c->isdbt_sb_mode & 1) << 4));
2369 /* signal optimization parameter */
2370 if (c->isdbt_partial_reception) {
2371 state->seg_diff_mask = (c->layer[0].modulation == DQPSK) << permu_seg[0];
2372 for (i = 1; i < 3; i++)
2373 nbseg_diff += (c->layer[i].modulation == DQPSK) * c->layer[i].segment_count;
2374 for (i = 0; i < nbseg_diff; i++)
2375 state->seg_diff_mask |= 1 << permu_seg[i+1];
2376 } else {
2377 for (i = 0; i < 3; i++)
2378 nbseg_diff += (c->layer[i].modulation == DQPSK) * c->layer[i].segment_count;
2379 for (i = 0; i < nbseg_diff; i++)
2380 state->seg_diff_mask |= 1 << permu_seg[i];
2383 if (state->seg_diff_mask)
2384 dib8000_write_word(state, 268, (dib8000_read_word(state, 268) & 0xF9FF) | 0x0200);
2385 else
2386 dib8000_write_word(state, 268, (2 << 9) | 39); /*init value */
2388 for (i = 0; i < 3; i++)
2389 max_constellation = dib8000_set_layer(state, i, max_constellation);
2390 if (autosearching == 0) {
2391 state->layer_b_nb_seg = c->layer[1].segment_count;
2392 state->layer_c_nb_seg = c->layer[2].segment_count;
2395 /* WRITE: Mode & Diff mask */
2396 dib8000_write_word(state, 0, (state->mode << 13) | state->seg_diff_mask);
2398 state->differential_constellation = (state->seg_diff_mask != 0);
2400 /* channel estimation fine configuration */
2401 ana_gain = dib8000_adp_fine_tune(state, max_constellation);
2403 /* update ana_gain depending on max constellation */
2404 dib8000_update_ana_gain(state, ana_gain);
2406 /* ---- ANA_FE ---- */
2407 if (c->isdbt_partial_reception) /* 3-segments */
2408 dib8000_load_ana_fe_coefs(state, ana_fe_coeff_3seg);
2409 else
2410 dib8000_load_ana_fe_coefs(state, ana_fe_coeff_1seg); /* 1-segment */
2412 /* TSB or ISDBT ? apply it now */
2413 if (c->isdbt_sb_mode) {
2414 dib8000_set_sb_channel(state);
2415 if (c->isdbt_sb_subchannel < 14)
2416 init_prbs = dib8000_get_init_prbs(state, c->isdbt_sb_subchannel);
2417 else
2418 init_prbs = 0;
2419 } else {
2420 dib8000_set_13seg_channel(state);
2421 init_prbs = 0xfff;
2424 /* SMALL */
2425 dib8000_small_fine_tune(state);
2427 dib8000_set_subchannel_prbs(state, init_prbs);
2429 /* ---- CHAN_BLK ---- */
2430 for (i = 0; i < 13; i++) {
2431 if ((((~state->seg_diff_mask) >> i) & 1) == 1) {
2432 p_cfr_left_edge += (1 << i) * ((i == 0) || ((((state->seg_mask & (~state->seg_diff_mask)) >> (i - 1)) & 1) == 0));
2433 p_cfr_right_edge += (1 << i) * ((i == 12) || ((((state->seg_mask & (~state->seg_diff_mask)) >> (i + 1)) & 1) == 0));
2436 dib8000_write_word(state, 222, p_cfr_left_edge); /* p_cfr_left_edge */
2437 dib8000_write_word(state, 223, p_cfr_right_edge); /* p_cfr_right_edge */
2438 /* "P_cspu_left_edge" & "P_cspu_right_edge" not used => do not care */
2440 dib8000_write_word(state, 189, ~state->seg_mask | state->seg_diff_mask); /* P_lmod4_seg_inh */
2441 dib8000_write_word(state, 192, ~state->seg_mask | state->seg_diff_mask); /* P_pha3_seg_inh */
2442 dib8000_write_word(state, 225, ~state->seg_mask | state->seg_diff_mask); /* P_tac_seg_inh */
2444 if (!autosearching)
2445 dib8000_write_word(state, 288, (~state->seg_mask | state->seg_diff_mask) & 0x1fff); /* P_tmcc_seg_eq_inh */
2446 else
2447 dib8000_write_word(state, 288, 0x1fff); /*disable equalisation of the tmcc when autosearch to be able to find the DQPSK channels. */
2449 dib8000_write_word(state, 211, state->seg_mask & (~state->seg_diff_mask)); /* P_des_seg_enabled */
2450 dib8000_write_word(state, 287, ~state->seg_mask | 0x1000); /* P_tmcc_seg_inh */
2452 dib8000_write_word(state, 178, 32); /* P_fft_powrange = 32 */
2454 /* ---- TMCC ---- */
2455 for (i = 0; i < 3; i++)
2456 tmcc_pow += (((c->layer[i].modulation == DQPSK) * 4 + 1) * c->layer[i].segment_count) ;
2458 /* Quantif of "P_tmcc_dec_thres_?k" is (0, 5+mode, 9); */
2459 /* Threshold is set at 1/4 of max power. */
2460 tmcc_pow *= (1 << (9-2));
2461 dib8000_write_word(state, 290, tmcc_pow); /* P_tmcc_dec_thres_2k */
2462 dib8000_write_word(state, 291, tmcc_pow); /* P_tmcc_dec_thres_4k */
2463 dib8000_write_word(state, 292, tmcc_pow); /* P_tmcc_dec_thres_8k */
2464 /*dib8000_write_word(state, 287, (1 << 13) | 0x1000 ); */
2466 /* ---- PHA3 ---- */
2467 if (state->isdbt_cfg_loaded == 0)
2468 dib8000_write_word(state, 250, 3285); /* p_2d_hspeed_thr0 */
2470 state->isdbt_cfg_loaded = 0;
2473 static u32 dib8000_wait_lock(struct dib8000_state *state, u32 internal,
2474 u32 wait0_ms, u32 wait1_ms, u32 wait2_ms)
2476 u32 value = 0; /* P_search_end0 wait time */
2477 u16 reg = 11; /* P_search_end0 start addr */
2479 for (reg = 11; reg < 16; reg += 2) {
2480 if (reg == 11) {
2481 if (state->revision == 0x8090)
2482 value = internal * wait1_ms;
2483 else
2484 value = internal * wait0_ms;
2485 } else if (reg == 13)
2486 value = internal * wait1_ms;
2487 else if (reg == 15)
2488 value = internal * wait2_ms;
2489 dib8000_write_word(state, reg, (u16)((value >> 16) & 0xffff));
2490 dib8000_write_word(state, (reg + 1), (u16)(value & 0xffff));
2492 return value;
2495 static int dib8000_autosearch_start(struct dvb_frontend *fe)
2497 struct dib8000_state *state = fe->demodulator_priv;
2498 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2499 u8 slist = 0;
2500 u32 value, internal = state->cfg.pll->internal;
2502 if (state->revision == 0x8090)
2503 internal = dib8000_read32(state, 23) / 1000;
2505 if ((state->revision >= 0x8002) &&
2506 (state->autosearch_state == AS_SEARCHING_FFT)) {
2507 dib8000_write_word(state, 37, 0x0065); /* P_ctrl_pha_off_max default values */
2508 dib8000_write_word(state, 116, 0x0000); /* P_ana_gain to 0 */
2510 dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x1fff) | (0 << 13) | (1 << 15)); /* P_mode = 0, P_restart_search=1 */
2511 dib8000_write_word(state, 1, (dib8000_read_word(state, 1) & 0xfffc) | 0); /* P_guard = 0 */
2512 dib8000_write_word(state, 6, 0); /* P_lock0_mask = 0 */
2513 dib8000_write_word(state, 7, 0); /* P_lock1_mask = 0 */
2514 dib8000_write_word(state, 8, 0); /* P_lock2_mask = 0 */
2515 dib8000_write_word(state, 10, (dib8000_read_word(state, 10) & 0x200) | (16 << 4) | (0 << 0)); /* P_search_list=16, P_search_maxtrial=0 */
2517 if (state->revision == 0x8090)
2518 value = dib8000_wait_lock(state, internal, 10, 10, 10); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2519 else
2520 value = dib8000_wait_lock(state, internal, 20, 20, 20); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2522 dib8000_write_word(state, 17, 0);
2523 dib8000_write_word(state, 18, 200); /* P_search_rstst = 200 */
2524 dib8000_write_word(state, 19, 0);
2525 dib8000_write_word(state, 20, 400); /* P_search_rstend = 400 */
2526 dib8000_write_word(state, 21, (value >> 16) & 0xffff); /* P_search_checkst */
2527 dib8000_write_word(state, 22, value & 0xffff);
2529 if (state->revision == 0x8090)
2530 dib8000_write_word(state, 32, (dib8000_read_word(state, 32) & 0xf0ff) | (0 << 8)); /* P_corm_alpha = 0 */
2531 else
2532 dib8000_write_word(state, 32, (dib8000_read_word(state, 32) & 0xf0ff) | (9 << 8)); /* P_corm_alpha = 3 */
2533 dib8000_write_word(state, 355, 2); /* P_search_param_max = 2 */
2535 /* P_search_param_select = (1 | 1<<4 | 1 << 8) */
2536 dib8000_write_word(state, 356, 0);
2537 dib8000_write_word(state, 357, 0x111);
2539 dib8000_write_word(state, 770, (dib8000_read_word(state, 770) & 0xdfff) | (1 << 13)); /* P_restart_ccg = 1 */
2540 dib8000_write_word(state, 770, (dib8000_read_word(state, 770) & 0xdfff) | (0 << 13)); /* P_restart_ccg = 0 */
2541 dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x7ff) | (0 << 15) | (1 << 13)); /* P_restart_search = 0; */
2542 } else if ((state->revision >= 0x8002) &&
2543 (state->autosearch_state == AS_SEARCHING_GUARD)) {
2544 c->transmission_mode = TRANSMISSION_MODE_8K;
2545 c->guard_interval = GUARD_INTERVAL_1_8;
2546 c->inversion = 0;
2547 c->layer[0].modulation = QAM_64;
2548 c->layer[0].fec = FEC_2_3;
2549 c->layer[0].interleaving = 0;
2550 c->layer[0].segment_count = 13;
2552 slist = 16;
2553 c->transmission_mode = state->found_nfft;
2555 dib8000_set_isdbt_common_channel(state, slist, 1);
2557 /* set lock_mask values */
2558 dib8000_write_word(state, 6, 0x4);
2559 if (state->revision == 0x8090)
2560 dib8000_write_word(state, 7, ((1 << 12) | (1 << 11) | (1 << 10)));/* tmcc_dec_lock, tmcc_sync_lock, tmcc_data_lock, tmcc_bch_uncor */
2561 else
2562 dib8000_write_word(state, 7, 0x8);
2563 dib8000_write_word(state, 8, 0x1000);
2565 /* set lock_mask wait time values */
2566 if (state->revision == 0x8090)
2567 dib8000_wait_lock(state, internal, 50, 100, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2568 else
2569 dib8000_wait_lock(state, internal, 50, 200, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2571 dib8000_write_word(state, 355, 3); /* P_search_param_max = 3 */
2573 /* P_search_param_select = 0xf; look for the 4 different guard intervals */
2574 dib8000_write_word(state, 356, 0);
2575 dib8000_write_word(state, 357, 0xf);
2577 value = dib8000_read_word(state, 0);
2578 dib8000_write_word(state, 0, (u16)((1 << 15) | value));
2579 dib8000_read_word(state, 1284); /* reset the INT. n_irq_pending */
2580 dib8000_write_word(state, 0, (u16)value);
2581 } else {
2582 c->inversion = 0;
2583 c->layer[0].modulation = QAM_64;
2584 c->layer[0].fec = FEC_2_3;
2585 c->layer[0].interleaving = 0;
2586 c->layer[0].segment_count = 13;
2587 if (!c->isdbt_sb_mode)
2588 c->layer[0].segment_count = 13;
2590 /* choose the right list, in sb, always do everything */
2591 if (c->isdbt_sb_mode) {
2592 slist = 7;
2593 dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));
2594 } else {
2595 if (c->guard_interval == GUARD_INTERVAL_AUTO) {
2596 if (c->transmission_mode == TRANSMISSION_MODE_AUTO) {
2597 c->transmission_mode = TRANSMISSION_MODE_8K;
2598 c->guard_interval = GUARD_INTERVAL_1_8;
2599 slist = 7;
2600 dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13)); /* P_mode = 1 to have autosearch start ok with mode2 */
2601 } else {
2602 c->guard_interval = GUARD_INTERVAL_1_8;
2603 slist = 3;
2605 } else {
2606 if (c->transmission_mode == TRANSMISSION_MODE_AUTO) {
2607 c->transmission_mode = TRANSMISSION_MODE_8K;
2608 slist = 2;
2609 dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13)); /* P_mode = 1 */
2610 } else
2611 slist = 0;
2614 dprintk("Using list for autosearch : %d\n", slist);
2616 dib8000_set_isdbt_common_channel(state, slist, 1);
2618 /* set lock_mask values */
2619 dib8000_write_word(state, 6, 0x4);
2620 if (state->revision == 0x8090)
2621 dib8000_write_word(state, 7, (1 << 12) | (1 << 11) | (1 << 10));
2622 else
2623 dib8000_write_word(state, 7, 0x8);
2624 dib8000_write_word(state, 8, 0x1000);
2626 /* set lock_mask wait time values */
2627 if (state->revision == 0x8090)
2628 dib8000_wait_lock(state, internal, 50, 200, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2629 else
2630 dib8000_wait_lock(state, internal, 50, 100, 1000); /* time in ms configure P_search_end0 P_search_end1 P_search_end2 */
2632 value = dib8000_read_word(state, 0);
2633 dib8000_write_word(state, 0, (u16)((1 << 15) | value));
2634 dib8000_read_word(state, 1284); /* reset the INT. n_irq_pending */
2635 dib8000_write_word(state, 0, (u16)value);
2637 return 0;
2640 static int dib8000_autosearch_irq(struct dvb_frontend *fe)
2642 struct dib8000_state *state = fe->demodulator_priv;
2643 u16 irq_pending = dib8000_read_word(state, 1284);
2645 if ((state->revision >= 0x8002) &&
2646 (state->autosearch_state == AS_SEARCHING_FFT)) {
2647 if (irq_pending & 0x1) {
2648 dprintk("dib8000_autosearch_irq: max correlation result available\n");
2649 return 3;
2651 } else {
2652 if (irq_pending & 0x1) { /* failed */
2653 dprintk("dib8000_autosearch_irq failed\n");
2654 return 1;
2657 if (irq_pending & 0x2) { /* succeeded */
2658 dprintk("dib8000_autosearch_irq succeeded\n");
2659 return 2;
2663 return 0; // still pending
2666 static void dib8000_viterbi_state(struct dib8000_state *state, u8 onoff)
2668 u16 tmp;
2670 tmp = dib8000_read_word(state, 771);
2671 if (onoff) /* start P_restart_chd : channel_decoder */
2672 dib8000_write_word(state, 771, tmp & 0xfffd);
2673 else /* stop P_restart_chd : channel_decoder */
2674 dib8000_write_word(state, 771, tmp | (1<<1));
2677 static void dib8000_set_dds(struct dib8000_state *state, s32 offset_khz)
2679 s16 unit_khz_dds_val;
2680 u32 abs_offset_khz = ABS(offset_khz);
2681 u32 dds = state->cfg.pll->ifreq & 0x1ffffff;
2682 u8 invert = !!(state->cfg.pll->ifreq & (1 << 25));
2683 u8 ratio;
2685 if (state->revision == 0x8090) {
2686 ratio = 4;
2687 unit_khz_dds_val = (1<<26) / (dib8000_read32(state, 23) / 1000);
2688 if (offset_khz < 0)
2689 dds = (1 << 26) - (abs_offset_khz * unit_khz_dds_val);
2690 else
2691 dds = (abs_offset_khz * unit_khz_dds_val);
2693 if (invert)
2694 dds = (1<<26) - dds;
2695 } else {
2696 ratio = 2;
2697 unit_khz_dds_val = (u16) (67108864 / state->cfg.pll->internal);
2699 if (offset_khz < 0)
2700 unit_khz_dds_val *= -1;
2702 /* IF tuner */
2703 if (invert)
2704 dds -= abs_offset_khz * unit_khz_dds_val;
2705 else
2706 dds += abs_offset_khz * unit_khz_dds_val;
2709 dprintk("setting a DDS frequency offset of %c%dkHz\n", invert ? '-' : ' ', dds / unit_khz_dds_val);
2711 if (abs_offset_khz <= (state->cfg.pll->internal / ratio)) {
2712 /* Max dds offset is the half of the demod freq */
2713 dib8000_write_word(state, 26, invert);
2714 dib8000_write_word(state, 27, (u16)(dds >> 16) & 0x1ff);
2715 dib8000_write_word(state, 28, (u16)(dds & 0xffff));
2719 static void dib8000_set_frequency_offset(struct dib8000_state *state)
2721 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2722 int i;
2723 u32 current_rf;
2724 int total_dds_offset_khz;
2726 if (state->fe[0]->ops.tuner_ops.get_frequency)
2727 state->fe[0]->ops.tuner_ops.get_frequency(state->fe[0], &current_rf);
2728 else
2729 current_rf = c->frequency;
2730 current_rf /= 1000;
2731 total_dds_offset_khz = (int)current_rf - (int)c->frequency / 1000;
2733 if (c->isdbt_sb_mode) {
2734 state->subchannel = c->isdbt_sb_subchannel;
2736 i = dib8000_read_word(state, 26) & 1; /* P_dds_invspec */
2737 dib8000_write_word(state, 26, c->inversion ^ i);
2739 if (state->cfg.pll->ifreq == 0) { /* low if tuner */
2740 if ((c->inversion ^ i) == 0)
2741 dib8000_write_word(state, 26, dib8000_read_word(state, 26) | 1);
2742 } else {
2743 if ((c->inversion ^ i) == 0)
2744 total_dds_offset_khz *= -1;
2748 dprintk("%dkhz tuner offset (frequency = %dHz & current_rf = %dHz) total_dds_offset_hz = %d\n", c->frequency - current_rf, c->frequency, current_rf, total_dds_offset_khz);
2750 /* apply dds offset now */
2751 dib8000_set_dds(state, total_dds_offset_khz);
2754 static u16 LUT_isdbt_symbol_duration[4] = { 26, 101, 63 };
2756 static u32 dib8000_get_symbol_duration(struct dib8000_state *state)
2758 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2759 u16 i;
2761 switch (c->transmission_mode) {
2762 case TRANSMISSION_MODE_2K:
2763 i = 0;
2764 break;
2765 case TRANSMISSION_MODE_4K:
2766 i = 2;
2767 break;
2768 default:
2769 case TRANSMISSION_MODE_AUTO:
2770 case TRANSMISSION_MODE_8K:
2771 i = 1;
2772 break;
2775 return (LUT_isdbt_symbol_duration[i] / (c->bandwidth_hz / 1000)) + 1;
2778 static void dib8000_set_isdbt_loop_params(struct dib8000_state *state, enum param_loop_step loop_step)
2780 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2781 u16 reg_32 = 0, reg_37 = 0;
2783 switch (loop_step) {
2784 case LOOP_TUNE_1:
2785 if (c->isdbt_sb_mode) {
2786 if (c->isdbt_partial_reception == 0) {
2787 reg_32 = ((11 - state->mode) << 12) | (6 << 8) | 0x40; /* P_timf_alpha = (11-P_mode), P_corm_alpha=6, P_corm_thres=0x40 */
2788 reg_37 = (3 << 5) | (0 << 4) | (10 - state->mode); /* P_ctrl_pha_off_max=3 P_ctrl_sfreq_inh =0 P_ctrl_sfreq_step = (10-P_mode) */
2789 } else { /* Sound Broadcasting mode 3 seg */
2790 reg_32 = ((10 - state->mode) << 12) | (6 << 8) | 0x60; /* P_timf_alpha = (10-P_mode), P_corm_alpha=6, P_corm_thres=0x60 */
2791 reg_37 = (3 << 5) | (0 << 4) | (9 - state->mode); /* P_ctrl_pha_off_max=3 P_ctrl_sfreq_inh =0 P_ctrl_sfreq_step = (9-P_mode) */
2793 } else { /* 13-seg start conf offset loop parameters */
2794 reg_32 = ((9 - state->mode) << 12) | (6 << 8) | 0x80; /* P_timf_alpha = (9-P_mode, P_corm_alpha=6, P_corm_thres=0x80 */
2795 reg_37 = (3 << 5) | (0 << 4) | (8 - state->mode); /* P_ctrl_pha_off_max=3 P_ctrl_sfreq_inh =0 P_ctrl_sfreq_step = 9 */
2797 break;
2798 case LOOP_TUNE_2:
2799 if (c->isdbt_sb_mode) {
2800 if (c->isdbt_partial_reception == 0) { /* Sound Broadcasting mode 1 seg */
2801 reg_32 = ((13-state->mode) << 12) | (6 << 8) | 0x40; /* P_timf_alpha = (13-P_mode) , P_corm_alpha=6, P_corm_thres=0x40*/
2802 reg_37 = (12-state->mode) | ((5 + state->mode) << 5);
2803 } else { /* Sound Broadcasting mode 3 seg */
2804 reg_32 = ((12-state->mode) << 12) | (6 << 8) | 0x60; /* P_timf_alpha = (12-P_mode) , P_corm_alpha=6, P_corm_thres=0x60 */
2805 reg_37 = (11-state->mode) | ((5 + state->mode) << 5);
2807 } else { /* 13 seg */
2808 reg_32 = ((11-state->mode) << 12) | (6 << 8) | 0x80; /* P_timf_alpha = 8 , P_corm_alpha=6, P_corm_thres=0x80 */
2809 reg_37 = ((5+state->mode) << 5) | (10 - state->mode);
2811 break;
2813 dib8000_write_word(state, 32, reg_32);
2814 dib8000_write_word(state, 37, reg_37);
2817 static void dib8000_demod_restart(struct dib8000_state *state)
2819 dib8000_write_word(state, 770, 0x4000);
2820 dib8000_write_word(state, 770, 0x0000);
2821 return;
2824 static void dib8000_set_sync_wait(struct dib8000_state *state)
2826 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
2827 u16 sync_wait = 64;
2829 /* P_dvsy_sync_wait - reuse mode */
2830 switch (c->transmission_mode) {
2831 case TRANSMISSION_MODE_8K:
2832 sync_wait = 256;
2833 break;
2834 case TRANSMISSION_MODE_4K:
2835 sync_wait = 128;
2836 break;
2837 default:
2838 case TRANSMISSION_MODE_2K:
2839 sync_wait = 64;
2840 break;
2843 if (state->cfg.diversity_delay == 0)
2844 sync_wait = (sync_wait * (1 << (c->guard_interval)) * 3) / 2 + 48; /* add 50% SFN margin + compensate for one DVSY-fifo */
2845 else
2846 sync_wait = (sync_wait * (1 << (c->guard_interval)) * 3) / 2 + state->cfg.diversity_delay; /* add 50% SFN margin + compensate for DVSY-fifo */
2848 dib8000_write_word(state, 273, (dib8000_read_word(state, 273) & 0x000f) | (sync_wait << 4));
2851 static unsigned long dib8000_get_timeout(struct dib8000_state *state, u32 delay, enum timeout_mode mode)
2853 if (mode == SYMBOL_DEPENDENT_ON)
2854 delay *= state->symbol_duration;
2856 return jiffies + usecs_to_jiffies(delay * 100);
2859 static s32 dib8000_get_status(struct dvb_frontend *fe)
2861 struct dib8000_state *state = fe->demodulator_priv;
2862 return state->status;
2865 static enum frontend_tune_state dib8000_get_tune_state(struct dvb_frontend *fe)
2867 struct dib8000_state *state = fe->demodulator_priv;
2868 return state->tune_state;
2871 static int dib8000_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
2873 struct dib8000_state *state = fe->demodulator_priv;
2875 state->tune_state = tune_state;
2876 return 0;
2879 static int dib8000_tune_restart_from_demod(struct dvb_frontend *fe)
2881 struct dib8000_state *state = fe->demodulator_priv;
2883 state->status = FE_STATUS_TUNE_PENDING;
2884 state->tune_state = CT_DEMOD_START;
2885 return 0;
2888 static u16 dib8000_read_lock(struct dvb_frontend *fe)
2890 struct dib8000_state *state = fe->demodulator_priv;
2892 if (state->revision == 0x8090)
2893 return dib8000_read_word(state, 570);
2894 return dib8000_read_word(state, 568);
2897 static int dib8090p_init_sdram(struct dib8000_state *state)
2899 u16 reg = 0;
2900 dprintk("init sdram\n");
2902 reg = dib8000_read_word(state, 274) & 0xfff0;
2903 dib8000_write_word(state, 274, reg | 0x7); /* P_dintlv_delay_ram = 7 because of MobileSdram */
2905 dib8000_write_word(state, 1803, (7 << 2));
2907 reg = dib8000_read_word(state, 1280);
2908 dib8000_write_word(state, 1280, reg | (1 << 2)); /* force restart P_restart_sdram */
2909 dib8000_write_word(state, 1280, reg); /* release restart P_restart_sdram */
2911 return 0;
2915 * is_manual_mode - Check if TMCC should be used for parameters settings
2916 * @c: struct dvb_frontend_properties
2918 * By default, TMCC table should be used for parameter settings on most
2919 * usercases. However, sometimes it is desirable to lock the demod to
2920 * use the manual parameters.
2922 * On manual mode, the current dib8000_tune state machine is very restrict:
2923 * It requires that both per-layer and per-transponder parameters to be
2924 * properly specified, otherwise the device won't lock.
2926 * Check if all those conditions are properly satisfied before allowing
2927 * the device to use the manual frequency lock mode.
2929 static int is_manual_mode(struct dtv_frontend_properties *c)
2931 int i, n_segs = 0;
2933 /* Use auto mode on DVB-T compat mode */
2934 if (c->delivery_system != SYS_ISDBT)
2935 return 0;
2938 * Transmission mode is only detected on auto mode, currently
2940 if (c->transmission_mode == TRANSMISSION_MODE_AUTO) {
2941 dprintk("transmission mode auto\n");
2942 return 0;
2946 * Guard interval is only detected on auto mode, currently
2948 if (c->guard_interval == GUARD_INTERVAL_AUTO) {
2949 dprintk("guard interval auto\n");
2950 return 0;
2954 * If no layer is enabled, assume auto mode, as at least one
2955 * layer should be enabled
2957 if (!c->isdbt_layer_enabled) {
2958 dprintk("no layer modulation specified\n");
2959 return 0;
2963 * Check if the per-layer parameters aren't auto and
2964 * disable a layer if segment count is 0 or invalid.
2966 for (i = 0; i < 3; i++) {
2967 if (!(c->isdbt_layer_enabled & 1 << i))
2968 continue;
2970 if ((c->layer[i].segment_count > 13) ||
2971 (c->layer[i].segment_count == 0)) {
2972 c->isdbt_layer_enabled &= ~(1 << i);
2973 continue;
2976 n_segs += c->layer[i].segment_count;
2978 if ((c->layer[i].modulation == QAM_AUTO) ||
2979 (c->layer[i].fec == FEC_AUTO)) {
2980 dprintk("layer %c has either modulation or FEC auto\n",
2981 'A' + i);
2982 return 0;
2987 * Userspace specified a wrong number of segments.
2988 * fallback to auto mode.
2990 if (n_segs == 0 || n_segs > 13) {
2991 dprintk("number of segments is invalid\n");
2992 return 0;
2995 /* Everything looks ok for manual mode */
2996 return 1;
2999 static int dib8000_tune(struct dvb_frontend *fe)
3001 struct dib8000_state *state = fe->demodulator_priv;
3002 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
3003 enum frontend_tune_state *tune_state = &state->tune_state;
3005 u16 locks, deeper_interleaver = 0, i;
3006 int ret = 1; /* 1 symbol duration (in 100us unit) delay most of the time */
3008 unsigned long *timeout = &state->timeout;
3009 unsigned long now = jiffies;
3010 #ifdef DIB8000_AGC_FREEZE
3011 u16 agc1, agc2;
3012 #endif
3014 u32 corm[4] = {0, 0, 0, 0};
3015 u8 find_index, max_value;
3017 #if 0
3018 if (*tune_state < CT_DEMOD_STOP)
3019 dprintk("IN: context status = %d, TUNE_STATE %d autosearch step = %u jiffies = %lu\n",
3020 state->channel_parameters_set, *tune_state, state->autosearch_state, now);
3021 #endif
3023 switch (*tune_state) {
3024 case CT_DEMOD_START: /* 30 */
3025 dib8000_reset_stats(fe);
3027 if (state->revision == 0x8090)
3028 dib8090p_init_sdram(state);
3029 state->status = FE_STATUS_TUNE_PENDING;
3030 state->channel_parameters_set = is_manual_mode(c);
3032 dprintk("Tuning channel on %s search mode\n",
3033 state->channel_parameters_set ? "manual" : "auto");
3035 dib8000_viterbi_state(state, 0); /* force chan dec in restart */
3037 /* Layer monitor */
3038 dib8000_write_word(state, 285, dib8000_read_word(state, 285) & 0x60);
3040 dib8000_set_frequency_offset(state);
3041 dib8000_set_bandwidth(fe, c->bandwidth_hz / 1000);
3043 if (state->channel_parameters_set == 0) { /* The channel struct is unknown, search it ! */
3044 #ifdef DIB8000_AGC_FREEZE
3045 if (state->revision != 0x8090) {
3046 state->agc1_max = dib8000_read_word(state, 108);
3047 state->agc1_min = dib8000_read_word(state, 109);
3048 state->agc2_max = dib8000_read_word(state, 110);
3049 state->agc2_min = dib8000_read_word(state, 111);
3050 agc1 = dib8000_read_word(state, 388);
3051 agc2 = dib8000_read_word(state, 389);
3052 dib8000_write_word(state, 108, agc1);
3053 dib8000_write_word(state, 109, agc1);
3054 dib8000_write_word(state, 110, agc2);
3055 dib8000_write_word(state, 111, agc2);
3057 #endif
3058 state->autosearch_state = AS_SEARCHING_FFT;
3059 state->found_nfft = TRANSMISSION_MODE_AUTO;
3060 state->found_guard = GUARD_INTERVAL_AUTO;
3061 *tune_state = CT_DEMOD_SEARCH_NEXT;
3062 } else { /* we already know the channel struct so TUNE only ! */
3063 state->autosearch_state = AS_DONE;
3064 *tune_state = CT_DEMOD_STEP_3;
3066 state->symbol_duration = dib8000_get_symbol_duration(state);
3067 break;
3069 case CT_DEMOD_SEARCH_NEXT: /* 51 */
3070 dib8000_autosearch_start(fe);
3071 if (state->revision == 0x8090)
3072 ret = 50;
3073 else
3074 ret = 15;
3075 *tune_state = CT_DEMOD_STEP_1;
3076 break;
3078 case CT_DEMOD_STEP_1: /* 31 */
3079 switch (dib8000_autosearch_irq(fe)) {
3080 case 1: /* fail */
3081 state->status = FE_STATUS_TUNE_FAILED;
3082 state->autosearch_state = AS_DONE;
3083 *tune_state = CT_DEMOD_STOP; /* else we are done here */
3084 break;
3085 case 2: /* Succes */
3086 state->status = FE_STATUS_FFT_SUCCESS; /* signal to the upper layer, that there was a channel found and the parameters can be read */
3087 *tune_state = CT_DEMOD_STEP_3;
3088 if (state->autosearch_state == AS_SEARCHING_GUARD)
3089 *tune_state = CT_DEMOD_STEP_2;
3090 else
3091 state->autosearch_state = AS_DONE;
3092 break;
3093 case 3: /* Autosearch FFT max correlation endded */
3094 *tune_state = CT_DEMOD_STEP_2;
3095 break;
3097 break;
3099 case CT_DEMOD_STEP_2:
3100 switch (state->autosearch_state) {
3101 case AS_SEARCHING_FFT:
3102 /* searching for the correct FFT */
3103 if (state->revision == 0x8090) {
3104 corm[2] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597));
3105 corm[1] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599));
3106 corm[0] = (dib8000_read_word(state, 600) << 16) | (dib8000_read_word(state, 601));
3107 } else {
3108 corm[2] = (dib8000_read_word(state, 594) << 16) | (dib8000_read_word(state, 595));
3109 corm[1] = (dib8000_read_word(state, 596) << 16) | (dib8000_read_word(state, 597));
3110 corm[0] = (dib8000_read_word(state, 598) << 16) | (dib8000_read_word(state, 599));
3112 /* dprintk("corm fft: %u %u %u\n", corm[0], corm[1], corm[2]); */
3114 max_value = 0;
3115 for (find_index = 1 ; find_index < 3 ; find_index++) {
3116 if (corm[max_value] < corm[find_index])
3117 max_value = find_index ;
3120 switch (max_value) {
3121 case 0:
3122 state->found_nfft = TRANSMISSION_MODE_2K;
3123 break;
3124 case 1:
3125 state->found_nfft = TRANSMISSION_MODE_4K;
3126 break;
3127 case 2:
3128 default:
3129 state->found_nfft = TRANSMISSION_MODE_8K;
3130 break;
3132 /* dprintk("Autosearch FFT has found Mode %d\n", max_value + 1); */
3134 *tune_state = CT_DEMOD_SEARCH_NEXT;
3135 state->autosearch_state = AS_SEARCHING_GUARD;
3136 if (state->revision == 0x8090)
3137 ret = 50;
3138 else
3139 ret = 10;
3140 break;
3141 case AS_SEARCHING_GUARD:
3142 /* searching for the correct guard interval */
3143 if (state->revision == 0x8090)
3144 state->found_guard = dib8000_read_word(state, 572) & 0x3;
3145 else
3146 state->found_guard = dib8000_read_word(state, 570) & 0x3;
3147 /* dprintk("guard interval found=%i\n", state->found_guard); */
3149 *tune_state = CT_DEMOD_STEP_3;
3150 break;
3151 default:
3152 /* the demod should never be in this state */
3153 state->status = FE_STATUS_TUNE_FAILED;
3154 state->autosearch_state = AS_DONE;
3155 *tune_state = CT_DEMOD_STOP; /* else we are done here */
3156 break;
3158 break;
3160 case CT_DEMOD_STEP_3: /* 33 */
3161 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_1);
3162 dib8000_set_isdbt_common_channel(state, 0, 0);/* setting the known channel parameters here */
3163 *tune_state = CT_DEMOD_STEP_4;
3164 break;
3166 case CT_DEMOD_STEP_4: /* (34) */
3167 dib8000_demod_restart(state);
3169 dib8000_set_sync_wait(state);
3170 dib8000_set_diversity_in(state->fe[0], state->diversity_onoff);
3172 locks = (dib8000_read_word(state, 180) >> 6) & 0x3f; /* P_coff_winlen ? */
3173 /* coff should lock over P_coff_winlen ofdm symbols : give 3 times this length to lock */
3174 *timeout = dib8000_get_timeout(state, 2 * locks, SYMBOL_DEPENDENT_ON);
3175 *tune_state = CT_DEMOD_STEP_5;
3176 break;
3178 case CT_DEMOD_STEP_5: /* (35) */
3179 locks = dib8000_read_lock(fe);
3180 if (locks & (0x3 << 11)) { /* coff-lock and off_cpil_lock achieved */
3181 dib8000_update_timf(state); /* we achieved a coff_cpil_lock - it's time to update the timf */
3182 if (!state->differential_constellation) {
3183 /* 2 times lmod4_win_len + 10 symbols (pipe delay after coff + nb to compute a 1st correlation) */
3184 *timeout = dib8000_get_timeout(state, (20 * ((dib8000_read_word(state, 188)>>5)&0x1f)), SYMBOL_DEPENDENT_ON);
3185 *tune_state = CT_DEMOD_STEP_7;
3186 } else {
3187 *tune_state = CT_DEMOD_STEP_8;
3189 } else if (time_after(now, *timeout)) {
3190 *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */
3192 break;
3194 case CT_DEMOD_STEP_6: /* (36) if there is an input (diversity) */
3195 if ((state->fe[1] != NULL) && (state->output_mode != OUTMODE_DIVERSITY)) {
3196 /* if there is a diversity fe in input and this fe is has not already failled : wait here until this this fe has succedeed or failled */
3197 if (dib8000_get_status(state->fe[1]) <= FE_STATUS_STD_SUCCESS) /* Something is locked on the input fe */
3198 *tune_state = CT_DEMOD_STEP_8; /* go for mpeg */
3199 else if (dib8000_get_status(state->fe[1]) >= FE_STATUS_TUNE_TIME_TOO_SHORT) { /* fe in input failled also, break the current one */
3200 *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */
3201 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3202 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3203 state->status = FE_STATUS_TUNE_FAILED;
3205 } else {
3206 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3207 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3208 *tune_state = CT_DEMOD_STOP; /* else we are done here ; step 8 will close the loops and exit */
3209 state->status = FE_STATUS_TUNE_FAILED;
3211 break;
3213 case CT_DEMOD_STEP_7: /* 37 */
3214 locks = dib8000_read_lock(fe);
3215 if (locks & (1<<10)) { /* lmod4_lock */
3216 ret = 14; /* wait for 14 symbols */
3217 *tune_state = CT_DEMOD_STEP_8;
3218 } else if (time_after(now, *timeout))
3219 *tune_state = CT_DEMOD_STEP_6; /* goto check for diversity input connection */
3220 break;
3222 case CT_DEMOD_STEP_8: /* 38 */
3223 dib8000_viterbi_state(state, 1); /* start viterbi chandec */
3224 dib8000_set_isdbt_loop_params(state, LOOP_TUNE_2);
3226 /* mpeg will never lock on this condition because init_prbs is not set : search for it !*/
3227 if (c->isdbt_sb_mode
3228 && c->isdbt_sb_subchannel < 14
3229 && !state->differential_constellation) {
3230 state->subchannel = 0;
3231 *tune_state = CT_DEMOD_STEP_11;
3232 } else {
3233 *tune_state = CT_DEMOD_STEP_9;
3234 state->status = FE_STATUS_LOCKED;
3236 break;
3238 case CT_DEMOD_STEP_9: /* 39 */
3239 if ((state->revision == 0x8090) || ((dib8000_read_word(state, 1291) >> 9) & 0x1)) { /* fe capable of deinterleaving : esram */
3240 /* defines timeout for mpeg lock depending on interleaver length of longest layer */
3241 for (i = 0; i < 3; i++) {
3242 if (c->layer[i].interleaving >= deeper_interleaver) {
3243 dprintk("layer%i: time interleaver = %d\n", i, c->layer[i].interleaving);
3244 if (c->layer[i].segment_count > 0) { /* valid layer */
3245 deeper_interleaver = c->layer[0].interleaving;
3246 state->longest_intlv_layer = i;
3251 if (deeper_interleaver == 0)
3252 locks = 2; /* locks is the tmp local variable name */
3253 else if (deeper_interleaver == 3)
3254 locks = 8;
3255 else
3256 locks = 2 * deeper_interleaver;
3258 if (state->diversity_onoff != 0) /* because of diversity sync */
3259 locks *= 2;
3261 *timeout = now + msecs_to_jiffies(200 * locks); /* give the mpeg lock 800ms if sram is present */
3262 dprintk("Deeper interleaver mode = %d on layer %d : timeout mult factor = %d => will use timeout = %ld\n",
3263 deeper_interleaver, state->longest_intlv_layer, locks, *timeout);
3265 *tune_state = CT_DEMOD_STEP_10;
3266 } else
3267 *tune_state = CT_DEMOD_STOP;
3268 break;
3270 case CT_DEMOD_STEP_10: /* 40 */
3271 locks = dib8000_read_lock(fe);
3272 if (locks&(1<<(7-state->longest_intlv_layer))) { /* mpeg lock : check the longest one */
3273 dprintk("ISDB-T layer locks: Layer A %s, Layer B %s, Layer C %s\n",
3274 c->layer[0].segment_count ? (locks >> 7) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3275 c->layer[1].segment_count ? (locks >> 6) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3276 c->layer[2].segment_count ? (locks >> 5) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled");
3277 if (c->isdbt_sb_mode
3278 && c->isdbt_sb_subchannel < 14
3279 && !state->differential_constellation)
3280 /* signal to the upper layer, that there was a channel found and the parameters can be read */
3281 state->status = FE_STATUS_DEMOD_SUCCESS;
3282 else
3283 state->status = FE_STATUS_DATA_LOCKED;
3284 *tune_state = CT_DEMOD_STOP;
3285 } else if (time_after(now, *timeout)) {
3286 if (c->isdbt_sb_mode
3287 && c->isdbt_sb_subchannel < 14
3288 && !state->differential_constellation) { /* continue to try init prbs autosearch */
3289 state->subchannel += 3;
3290 *tune_state = CT_DEMOD_STEP_11;
3291 } else { /* we are done mpeg of the longest interleaver xas not locking but let's try if an other layer has locked in the same time */
3292 if (locks & (0x7 << 5)) {
3293 dprintk("Not all ISDB-T layers locked in %d ms: Layer A %s, Layer B %s, Layer C %s\n",
3294 jiffies_to_msecs(now - *timeout),
3295 c->layer[0].segment_count ? (locks >> 7) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3296 c->layer[1].segment_count ? (locks >> 6) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled",
3297 c->layer[2].segment_count ? (locks >> 5) & 0x1 ? "locked" : "NOT LOCKED" : "not enabled");
3299 state->status = FE_STATUS_DATA_LOCKED;
3300 } else
3301 state->status = FE_STATUS_TUNE_FAILED;
3302 *tune_state = CT_DEMOD_STOP;
3305 break;
3307 case CT_DEMOD_STEP_11: /* 41 : init prbs autosearch */
3308 if (state->subchannel <= 41) {
3309 dib8000_set_subchannel_prbs(state, dib8000_get_init_prbs(state, state->subchannel));
3310 *tune_state = CT_DEMOD_STEP_9;
3311 } else {
3312 *tune_state = CT_DEMOD_STOP;
3313 state->status = FE_STATUS_TUNE_FAILED;
3315 break;
3317 default:
3318 break;
3321 /* tuning is finished - cleanup the demod */
3322 switch (*tune_state) {
3323 case CT_DEMOD_STOP: /* (42) */
3324 #ifdef DIB8000_AGC_FREEZE
3325 if ((state->revision != 0x8090) && (state->agc1_max != 0)) {
3326 dib8000_write_word(state, 108, state->agc1_max);
3327 dib8000_write_word(state, 109, state->agc1_min);
3328 dib8000_write_word(state, 110, state->agc2_max);
3329 dib8000_write_word(state, 111, state->agc2_min);
3330 state->agc1_max = 0;
3331 state->agc1_min = 0;
3332 state->agc2_max = 0;
3333 state->agc2_min = 0;
3335 #endif
3336 ret = 0;
3337 break;
3338 default:
3339 break;
3342 if ((ret > 0) && (*tune_state > CT_DEMOD_STEP_3))
3343 return ret * state->symbol_duration;
3344 if ((ret > 0) && (ret < state->symbol_duration))
3345 return state->symbol_duration; /* at least one symbol */
3346 return ret;
3349 static int dib8000_wakeup(struct dvb_frontend *fe)
3351 struct dib8000_state *state = fe->demodulator_priv;
3352 u8 index_frontend;
3353 int ret;
3355 dib8000_set_power_mode(state, DIB8000_POWER_ALL);
3356 dib8000_set_adc_state(state, DIBX000_ADC_ON);
3357 if (dib8000_set_adc_state(state, DIBX000_SLOW_ADC_ON) != 0)
3358 dprintk("could not start Slow ADC\n");
3360 if (state->revision == 0x8090)
3361 dib8000_sad_calib(state);
3363 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3364 ret = state->fe[index_frontend]->ops.init(state->fe[index_frontend]);
3365 if (ret < 0)
3366 return ret;
3369 return 0;
3372 static int dib8000_sleep(struct dvb_frontend *fe)
3374 struct dib8000_state *state = fe->demodulator_priv;
3375 u8 index_frontend;
3376 int ret;
3378 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3379 ret = state->fe[index_frontend]->ops.sleep(state->fe[index_frontend]);
3380 if (ret < 0)
3381 return ret;
3384 if (state->revision != 0x8090)
3385 dib8000_set_output_mode(fe, OUTMODE_HIGH_Z);
3386 dib8000_set_power_mode(state, DIB8000_POWER_INTERFACE_ONLY);
3387 return dib8000_set_adc_state(state, DIBX000_SLOW_ADC_OFF) | dib8000_set_adc_state(state, DIBX000_ADC_OFF);
3390 static int dib8000_read_status(struct dvb_frontend *fe, enum fe_status *stat);
3392 static int dib8000_get_frontend(struct dvb_frontend *fe,
3393 struct dtv_frontend_properties *c)
3395 struct dib8000_state *state = fe->demodulator_priv;
3396 u16 i, val = 0;
3397 enum fe_status stat = 0;
3398 u8 index_frontend, sub_index_frontend;
3400 c->bandwidth_hz = 6000000;
3403 * If called to early, get_frontend makes dib8000_tune to either
3404 * not lock or not sync. This causes dvbv5-scan/dvbv5-zap to fail.
3405 * So, let's just return if frontend 0 has not locked.
3407 dib8000_read_status(fe, &stat);
3408 if (!(stat & FE_HAS_SYNC))
3409 return 0;
3411 dprintk("dib8000_get_frontend: TMCC lock\n");
3412 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3413 state->fe[index_frontend]->ops.read_status(state->fe[index_frontend], &stat);
3414 if (stat&FE_HAS_SYNC) {
3415 dprintk("TMCC lock on the slave%i\n", index_frontend);
3416 /* synchronize the cache with the other frontends */
3417 state->fe[index_frontend]->ops.get_frontend(state->fe[index_frontend], c);
3418 for (sub_index_frontend = 0; (sub_index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[sub_index_frontend] != NULL); sub_index_frontend++) {
3419 if (sub_index_frontend != index_frontend) {
3420 state->fe[sub_index_frontend]->dtv_property_cache.isdbt_sb_mode = state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode;
3421 state->fe[sub_index_frontend]->dtv_property_cache.inversion = state->fe[index_frontend]->dtv_property_cache.inversion;
3422 state->fe[sub_index_frontend]->dtv_property_cache.transmission_mode = state->fe[index_frontend]->dtv_property_cache.transmission_mode;
3423 state->fe[sub_index_frontend]->dtv_property_cache.guard_interval = state->fe[index_frontend]->dtv_property_cache.guard_interval;
3424 state->fe[sub_index_frontend]->dtv_property_cache.isdbt_partial_reception = state->fe[index_frontend]->dtv_property_cache.isdbt_partial_reception;
3425 for (i = 0; i < 3; i++) {
3426 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].segment_count = state->fe[index_frontend]->dtv_property_cache.layer[i].segment_count;
3427 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].interleaving = state->fe[index_frontend]->dtv_property_cache.layer[i].interleaving;
3428 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].fec = state->fe[index_frontend]->dtv_property_cache.layer[i].fec;
3429 state->fe[sub_index_frontend]->dtv_property_cache.layer[i].modulation = state->fe[index_frontend]->dtv_property_cache.layer[i].modulation;
3433 return 0;
3437 c->isdbt_sb_mode = dib8000_read_word(state, 508) & 0x1;
3439 if (state->revision == 0x8090)
3440 val = dib8000_read_word(state, 572);
3441 else
3442 val = dib8000_read_word(state, 570);
3443 c->inversion = (val & 0x40) >> 6;
3444 switch ((val & 0x30) >> 4) {
3445 case 1:
3446 c->transmission_mode = TRANSMISSION_MODE_2K;
3447 dprintk("dib8000_get_frontend: transmission mode 2K\n");
3448 break;
3449 case 2:
3450 c->transmission_mode = TRANSMISSION_MODE_4K;
3451 dprintk("dib8000_get_frontend: transmission mode 4K\n");
3452 break;
3453 case 3:
3454 default:
3455 c->transmission_mode = TRANSMISSION_MODE_8K;
3456 dprintk("dib8000_get_frontend: transmission mode 8K\n");
3457 break;
3460 switch (val & 0x3) {
3461 case 0:
3462 c->guard_interval = GUARD_INTERVAL_1_32;
3463 dprintk("dib8000_get_frontend: Guard Interval = 1/32\n");
3464 break;
3465 case 1:
3466 c->guard_interval = GUARD_INTERVAL_1_16;
3467 dprintk("dib8000_get_frontend: Guard Interval = 1/16\n");
3468 break;
3469 case 2:
3470 dprintk("dib8000_get_frontend: Guard Interval = 1/8\n");
3471 c->guard_interval = GUARD_INTERVAL_1_8;
3472 break;
3473 case 3:
3474 dprintk("dib8000_get_frontend: Guard Interval = 1/4\n");
3475 c->guard_interval = GUARD_INTERVAL_1_4;
3476 break;
3479 val = dib8000_read_word(state, 505);
3480 c->isdbt_partial_reception = val & 1;
3481 dprintk("dib8000_get_frontend: partial_reception = %d\n", c->isdbt_partial_reception);
3483 for (i = 0; i < 3; i++) {
3484 int show;
3486 val = dib8000_read_word(state, 493 + i) & 0x0f;
3487 c->layer[i].segment_count = val;
3489 if (val == 0 || val > 13)
3490 show = 0;
3491 else
3492 show = 1;
3494 if (show)
3495 dprintk("dib8000_get_frontend: Layer %d segments = %d\n",
3496 i, c->layer[i].segment_count);
3498 val = dib8000_read_word(state, 499 + i) & 0x3;
3499 /* Interleaving can be 0, 1, 2 or 4 */
3500 if (val == 3)
3501 val = 4;
3502 c->layer[i].interleaving = val;
3503 if (show)
3504 dprintk("dib8000_get_frontend: Layer %d time_intlv = %d\n",
3505 i, c->layer[i].interleaving);
3507 val = dib8000_read_word(state, 481 + i);
3508 switch (val & 0x7) {
3509 case 1:
3510 c->layer[i].fec = FEC_1_2;
3511 if (show)
3512 dprintk("dib8000_get_frontend: Layer %d Code Rate = 1/2\n", i);
3513 break;
3514 case 2:
3515 c->layer[i].fec = FEC_2_3;
3516 if (show)
3517 dprintk("dib8000_get_frontend: Layer %d Code Rate = 2/3\n", i);
3518 break;
3519 case 3:
3520 c->layer[i].fec = FEC_3_4;
3521 if (show)
3522 dprintk("dib8000_get_frontend: Layer %d Code Rate = 3/4\n", i);
3523 break;
3524 case 5:
3525 c->layer[i].fec = FEC_5_6;
3526 if (show)
3527 dprintk("dib8000_get_frontend: Layer %d Code Rate = 5/6\n", i);
3528 break;
3529 default:
3530 c->layer[i].fec = FEC_7_8;
3531 if (show)
3532 dprintk("dib8000_get_frontend: Layer %d Code Rate = 7/8\n", i);
3533 break;
3536 val = dib8000_read_word(state, 487 + i);
3537 switch (val & 0x3) {
3538 case 0:
3539 c->layer[i].modulation = DQPSK;
3540 if (show)
3541 dprintk("dib8000_get_frontend: Layer %d DQPSK\n", i);
3542 break;
3543 case 1:
3544 c->layer[i].modulation = QPSK;
3545 if (show)
3546 dprintk("dib8000_get_frontend: Layer %d QPSK\n", i);
3547 break;
3548 case 2:
3549 c->layer[i].modulation = QAM_16;
3550 if (show)
3551 dprintk("dib8000_get_frontend: Layer %d QAM16\n", i);
3552 break;
3553 case 3:
3554 default:
3555 c->layer[i].modulation = QAM_64;
3556 if (show)
3557 dprintk("dib8000_get_frontend: Layer %d QAM64\n", i);
3558 break;
3562 /* synchronize the cache with the other frontends */
3563 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3564 state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode = c->isdbt_sb_mode;
3565 state->fe[index_frontend]->dtv_property_cache.inversion = c->inversion;
3566 state->fe[index_frontend]->dtv_property_cache.transmission_mode = c->transmission_mode;
3567 state->fe[index_frontend]->dtv_property_cache.guard_interval = c->guard_interval;
3568 state->fe[index_frontend]->dtv_property_cache.isdbt_partial_reception = c->isdbt_partial_reception;
3569 for (i = 0; i < 3; i++) {
3570 state->fe[index_frontend]->dtv_property_cache.layer[i].segment_count = c->layer[i].segment_count;
3571 state->fe[index_frontend]->dtv_property_cache.layer[i].interleaving = c->layer[i].interleaving;
3572 state->fe[index_frontend]->dtv_property_cache.layer[i].fec = c->layer[i].fec;
3573 state->fe[index_frontend]->dtv_property_cache.layer[i].modulation = c->layer[i].modulation;
3576 return 0;
3579 static int dib8000_set_frontend(struct dvb_frontend *fe)
3581 struct dib8000_state *state = fe->demodulator_priv;
3582 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
3583 int l, i, active, time, time_slave = 0;
3584 u8 exit_condition, index_frontend;
3585 unsigned long delay, callback_time;
3587 if (c->frequency == 0) {
3588 dprintk("dib8000: must at least specify frequency\n");
3589 return 0;
3592 if (c->bandwidth_hz == 0) {
3593 dprintk("dib8000: no bandwidth specified, set to default\n");
3594 c->bandwidth_hz = 6000000;
3597 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3598 /* synchronization of the cache */
3599 state->fe[index_frontend]->dtv_property_cache.delivery_system = SYS_ISDBT;
3600 memcpy(&state->fe[index_frontend]->dtv_property_cache, &fe->dtv_property_cache, sizeof(struct dtv_frontend_properties));
3602 /* set output mode and diversity input */
3603 if (state->revision != 0x8090) {
3604 dib8000_set_diversity_in(state->fe[index_frontend], 1);
3605 if (index_frontend != 0)
3606 dib8000_set_output_mode(state->fe[index_frontend],
3607 OUTMODE_DIVERSITY);
3608 else
3609 dib8000_set_output_mode(state->fe[0], OUTMODE_HIGH_Z);
3610 } else {
3611 dib8096p_set_diversity_in(state->fe[index_frontend], 1);
3612 if (index_frontend != 0)
3613 dib8096p_set_output_mode(state->fe[index_frontend],
3614 OUTMODE_DIVERSITY);
3615 else
3616 dib8096p_set_output_mode(state->fe[0], OUTMODE_HIGH_Z);
3619 /* tune the tuner */
3620 if (state->fe[index_frontend]->ops.tuner_ops.set_params)
3621 state->fe[index_frontend]->ops.tuner_ops.set_params(state->fe[index_frontend]);
3623 dib8000_set_tune_state(state->fe[index_frontend], CT_AGC_START);
3626 /* turn off the diversity of the last chip */
3627 if (state->revision != 0x8090)
3628 dib8000_set_diversity_in(state->fe[index_frontend - 1], 0);
3629 else
3630 dib8096p_set_diversity_in(state->fe[index_frontend - 1], 0);
3632 /* start up the AGC */
3633 do {
3634 time = dib8000_agc_startup(state->fe[0]);
3635 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3636 time_slave = dib8000_agc_startup(state->fe[index_frontend]);
3637 if (time == 0)
3638 time = time_slave;
3639 else if ((time_slave != 0) && (time_slave > time))
3640 time = time_slave;
3642 if (time == 0)
3643 break;
3646 * Despite dib8000_agc_startup returns time at a 0.1 ms range,
3647 * the actual sleep time depends on CONFIG_HZ. The worse case
3648 * is when CONFIG_HZ=100. In such case, the minimum granularity
3649 * is 10ms. On some real field tests, the tuner sometimes don't
3650 * lock when this timer is lower than 10ms. So, enforce a 10ms
3651 * granularity.
3653 time = 10 * (time + 99)/100;
3654 usleep_range(time * 1000, (time + 1) * 1000);
3655 exit_condition = 1;
3656 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3657 if (dib8000_get_tune_state(state->fe[index_frontend]) != CT_AGC_STOP) {
3658 exit_condition = 0;
3659 break;
3662 } while (exit_condition == 0);
3664 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
3665 dib8000_set_tune_state(state->fe[index_frontend], CT_DEMOD_START);
3667 active = 1;
3668 do {
3669 callback_time = 0;
3670 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3671 delay = dib8000_tune(state->fe[index_frontend]);
3672 if (delay != 0) {
3673 delay = jiffies + usecs_to_jiffies(100 * delay);
3674 if (!callback_time || delay < callback_time)
3675 callback_time = delay;
3678 /* we are in autosearch */
3679 if (state->channel_parameters_set == 0) { /* searching */
3680 if ((dib8000_get_status(state->fe[index_frontend]) == FE_STATUS_DEMOD_SUCCESS) || (dib8000_get_status(state->fe[index_frontend]) == FE_STATUS_FFT_SUCCESS)) {
3681 dprintk("autosearch succeeded on fe%i\n", index_frontend);
3682 dib8000_get_frontend(state->fe[index_frontend], c); /* we read the channel parameters from the frontend which was successful */
3683 state->channel_parameters_set = 1;
3685 for (l = 0; (l < MAX_NUMBER_OF_FRONTENDS) && (state->fe[l] != NULL); l++) {
3686 if (l != index_frontend) { /* and for all frontend except the successful one */
3687 dprintk("Restarting frontend %d\n", l);
3688 dib8000_tune_restart_from_demod(state->fe[l]);
3690 state->fe[l]->dtv_property_cache.isdbt_sb_mode = state->fe[index_frontend]->dtv_property_cache.isdbt_sb_mode;
3691 state->fe[l]->dtv_property_cache.inversion = state->fe[index_frontend]->dtv_property_cache.inversion;
3692 state->fe[l]->dtv_property_cache.transmission_mode = state->fe[index_frontend]->dtv_property_cache.transmission_mode;
3693 state->fe[l]->dtv_property_cache.guard_interval = state->fe[index_frontend]->dtv_property_cache.guard_interval;
3694 state->fe[l]->dtv_property_cache.isdbt_partial_reception = state->fe[index_frontend]->dtv_property_cache.isdbt_partial_reception;
3695 for (i = 0; i < 3; i++) {
3696 state->fe[l]->dtv_property_cache.layer[i].segment_count = state->fe[index_frontend]->dtv_property_cache.layer[i].segment_count;
3697 state->fe[l]->dtv_property_cache.layer[i].interleaving = state->fe[index_frontend]->dtv_property_cache.layer[i].interleaving;
3698 state->fe[l]->dtv_property_cache.layer[i].fec = state->fe[index_frontend]->dtv_property_cache.layer[i].fec;
3699 state->fe[l]->dtv_property_cache.layer[i].modulation = state->fe[index_frontend]->dtv_property_cache.layer[i].modulation;
3707 /* tuning is done when the master frontend is done (failed or success) */
3708 if (dib8000_get_status(state->fe[0]) == FE_STATUS_TUNE_FAILED ||
3709 dib8000_get_status(state->fe[0]) == FE_STATUS_LOCKED ||
3710 dib8000_get_status(state->fe[0]) == FE_STATUS_DATA_LOCKED) {
3711 active = 0;
3712 /* we need to wait for all frontends to be finished */
3713 for (index_frontend = 0; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3714 if (dib8000_get_tune_state(state->fe[index_frontend]) != CT_DEMOD_STOP)
3715 active = 1;
3717 if (active == 0)
3718 dprintk("tuning done with status %d\n", dib8000_get_status(state->fe[0]));
3721 if ((active == 1) && (callback_time == 0)) {
3722 dprintk("strange callback time something went wrong\n");
3723 active = 0;
3726 while ((active == 1) && (time_before(jiffies, callback_time)))
3727 msleep(100);
3728 } while (active);
3730 /* set output mode */
3731 if (state->revision != 0x8090)
3732 dib8000_set_output_mode(state->fe[0], state->cfg.output_mode);
3733 else {
3734 dib8096p_set_output_mode(state->fe[0], state->cfg.output_mode);
3735 if (state->cfg.enMpegOutput == 0) {
3736 dib8096p_setDibTxMux(state, MPEG_ON_DIBTX);
3737 dib8096p_setHostBusMux(state, DIBTX_ON_HOSTBUS);
3741 return 0;
3744 static int dib8000_get_stats(struct dvb_frontend *fe, enum fe_status stat);
3746 static int dib8000_read_status(struct dvb_frontend *fe, enum fe_status *stat)
3748 struct dib8000_state *state = fe->demodulator_priv;
3749 u16 lock_slave = 0, lock;
3750 u8 index_frontend;
3752 lock = dib8000_read_lock(fe);
3753 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
3754 lock_slave |= dib8000_read_lock(state->fe[index_frontend]);
3756 *stat = 0;
3758 if (((lock >> 13) & 1) || ((lock_slave >> 13) & 1))
3759 *stat |= FE_HAS_SIGNAL;
3761 if (((lock >> 8) & 1) || ((lock_slave >> 8) & 1)) /* Equal */
3762 *stat |= FE_HAS_CARRIER;
3764 if ((((lock >> 1) & 0xf) == 0xf) || (((lock_slave >> 1) & 0xf) == 0xf)) /* TMCC_SYNC */
3765 *stat |= FE_HAS_SYNC;
3767 if ((((lock >> 12) & 1) || ((lock_slave >> 12) & 1)) && ((lock >> 5) & 7)) /* FEC MPEG */
3768 *stat |= FE_HAS_LOCK;
3770 if (((lock >> 12) & 1) || ((lock_slave >> 12) & 1)) {
3771 lock = dib8000_read_word(state, 554); /* Viterbi Layer A */
3772 if (lock & 0x01)
3773 *stat |= FE_HAS_VITERBI;
3775 lock = dib8000_read_word(state, 555); /* Viterbi Layer B */
3776 if (lock & 0x01)
3777 *stat |= FE_HAS_VITERBI;
3779 lock = dib8000_read_word(state, 556); /* Viterbi Layer C */
3780 if (lock & 0x01)
3781 *stat |= FE_HAS_VITERBI;
3783 dib8000_get_stats(fe, *stat);
3785 return 0;
3788 static int dib8000_read_ber(struct dvb_frontend *fe, u32 * ber)
3790 struct dib8000_state *state = fe->demodulator_priv;
3792 /* 13 segments */
3793 if (state->revision == 0x8090)
3794 *ber = (dib8000_read_word(state, 562) << 16) |
3795 dib8000_read_word(state, 563);
3796 else
3797 *ber = (dib8000_read_word(state, 560) << 16) |
3798 dib8000_read_word(state, 561);
3799 return 0;
3802 static int dib8000_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
3804 struct dib8000_state *state = fe->demodulator_priv;
3806 /* packet error on 13 seg */
3807 if (state->revision == 0x8090)
3808 *unc = dib8000_read_word(state, 567);
3809 else
3810 *unc = dib8000_read_word(state, 565);
3811 return 0;
3814 static int dib8000_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
3816 struct dib8000_state *state = fe->demodulator_priv;
3817 u8 index_frontend;
3818 u16 val;
3820 *strength = 0;
3821 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++) {
3822 state->fe[index_frontend]->ops.read_signal_strength(state->fe[index_frontend], &val);
3823 if (val > 65535 - *strength)
3824 *strength = 65535;
3825 else
3826 *strength += val;
3829 val = 65535 - dib8000_read_word(state, 390);
3830 if (val > 65535 - *strength)
3831 *strength = 65535;
3832 else
3833 *strength += val;
3834 return 0;
3837 static u32 dib8000_get_snr(struct dvb_frontend *fe)
3839 struct dib8000_state *state = fe->demodulator_priv;
3840 u32 n, s, exp;
3841 u16 val;
3843 if (state->revision != 0x8090)
3844 val = dib8000_read_word(state, 542);
3845 else
3846 val = dib8000_read_word(state, 544);
3847 n = (val >> 6) & 0xff;
3848 exp = (val & 0x3f);
3849 if ((exp & 0x20) != 0)
3850 exp -= 0x40;
3851 n <<= exp+16;
3853 if (state->revision != 0x8090)
3854 val = dib8000_read_word(state, 543);
3855 else
3856 val = dib8000_read_word(state, 545);
3857 s = (val >> 6) & 0xff;
3858 exp = (val & 0x3f);
3859 if ((exp & 0x20) != 0)
3860 exp -= 0x40;
3861 s <<= exp+16;
3863 if (n > 0) {
3864 u32 t = (s/n) << 16;
3865 return t + ((s << 16) - n*t) / n;
3867 return 0xffffffff;
3870 static int dib8000_read_snr(struct dvb_frontend *fe, u16 * snr)
3872 struct dib8000_state *state = fe->demodulator_priv;
3873 u8 index_frontend;
3874 u32 snr_master;
3876 snr_master = dib8000_get_snr(fe);
3877 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL); index_frontend++)
3878 snr_master += dib8000_get_snr(state->fe[index_frontend]);
3880 if ((snr_master >> 16) != 0) {
3881 snr_master = 10*intlog10(snr_master>>16);
3882 *snr = snr_master / ((1 << 24) / 10);
3884 else
3885 *snr = 0;
3887 return 0;
3890 struct per_layer_regs {
3891 u16 lock, ber, per;
3894 static const struct per_layer_regs per_layer_regs[] = {
3895 { 554, 560, 562 },
3896 { 555, 576, 578 },
3897 { 556, 581, 583 },
3900 struct linear_segments {
3901 unsigned x;
3902 signed y;
3906 * Table to estimate signal strength in dBm.
3907 * This table was empirically determinated by measuring the signal
3908 * strength generated by a DTA-2111 RF generator directly connected into
3909 * a dib8076 device (a PixelView PV-D231U stick), using a good quality
3910 * 3 meters RC6 cable and good RC6 connectors.
3911 * The real value can actually be different on other devices, depending
3912 * on several factors, like if LNA is enabled or not, if diversity is
3913 * enabled, type of connectors, etc.
3914 * Yet, it is better to use this measure in dB than a random non-linear
3915 * percentage value, especially for antenna adjustments.
3916 * On my tests, the precision of the measure using this table is about
3917 * 0.5 dB, with sounds reasonable enough.
3919 static struct linear_segments strength_to_db_table[] = {
3920 { 55953, 108500 }, /* -22.5 dBm */
3921 { 55394, 108000 },
3922 { 53834, 107000 },
3923 { 52863, 106000 },
3924 { 52239, 105000 },
3925 { 52012, 104000 },
3926 { 51803, 103000 },
3927 { 51566, 102000 },
3928 { 51356, 101000 },
3929 { 51112, 100000 },
3930 { 50869, 99000 },
3931 { 50600, 98000 },
3932 { 50363, 97000 },
3933 { 50117, 96000 }, /* -35 dBm */
3934 { 49889, 95000 },
3935 { 49680, 94000 },
3936 { 49493, 93000 },
3937 { 49302, 92000 },
3938 { 48929, 91000 },
3939 { 48416, 90000 },
3940 { 48035, 89000 },
3941 { 47593, 88000 },
3942 { 47282, 87000 },
3943 { 46953, 86000 },
3944 { 46698, 85000 },
3945 { 45617, 84000 },
3946 { 44773, 83000 },
3947 { 43845, 82000 },
3948 { 43020, 81000 },
3949 { 42010, 80000 }, /* -51 dBm */
3950 { 0, 0 },
3953 static u32 interpolate_value(u32 value, struct linear_segments *segments,
3954 unsigned len)
3956 u64 tmp64;
3957 u32 dx;
3958 s32 dy;
3959 int i, ret;
3961 if (value >= segments[0].x)
3962 return segments[0].y;
3963 if (value < segments[len-1].x)
3964 return segments[len-1].y;
3966 for (i = 1; i < len - 1; i++) {
3967 /* If value is identical, no need to interpolate */
3968 if (value == segments[i].x)
3969 return segments[i].y;
3970 if (value > segments[i].x)
3971 break;
3974 /* Linear interpolation between the two (x,y) points */
3975 dy = segments[i - 1].y - segments[i].y;
3976 dx = segments[i - 1].x - segments[i].x;
3978 tmp64 = value - segments[i].x;
3979 tmp64 *= dy;
3980 do_div(tmp64, dx);
3981 ret = segments[i].y + tmp64;
3983 return ret;
3986 static u32 dib8000_get_time_us(struct dvb_frontend *fe, int layer)
3988 struct dib8000_state *state = fe->demodulator_priv;
3989 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
3990 int ini_layer, end_layer, i;
3991 u64 time_us, tmp64;
3992 u32 tmp, denom;
3993 int guard, rate_num, rate_denum = 1, bits_per_symbol, nsegs;
3994 int interleaving = 0, fft_div;
3996 if (layer >= 0) {
3997 ini_layer = layer;
3998 end_layer = layer + 1;
3999 } else {
4000 ini_layer = 0;
4001 end_layer = 3;
4004 switch (c->guard_interval) {
4005 case GUARD_INTERVAL_1_4:
4006 guard = 4;
4007 break;
4008 case GUARD_INTERVAL_1_8:
4009 guard = 8;
4010 break;
4011 case GUARD_INTERVAL_1_16:
4012 guard = 16;
4013 break;
4014 default:
4015 case GUARD_INTERVAL_1_32:
4016 guard = 32;
4017 break;
4020 switch (c->transmission_mode) {
4021 case TRANSMISSION_MODE_2K:
4022 fft_div = 4;
4023 break;
4024 case TRANSMISSION_MODE_4K:
4025 fft_div = 2;
4026 break;
4027 default:
4028 case TRANSMISSION_MODE_8K:
4029 fft_div = 1;
4030 break;
4033 denom = 0;
4034 for (i = ini_layer; i < end_layer; i++) {
4035 nsegs = c->layer[i].segment_count;
4036 if (nsegs == 0 || nsegs > 13)
4037 continue;
4039 switch (c->layer[i].modulation) {
4040 case DQPSK:
4041 case QPSK:
4042 bits_per_symbol = 2;
4043 break;
4044 case QAM_16:
4045 bits_per_symbol = 4;
4046 break;
4047 default:
4048 case QAM_64:
4049 bits_per_symbol = 6;
4050 break;
4053 switch (c->layer[i].fec) {
4054 case FEC_1_2:
4055 rate_num = 1;
4056 rate_denum = 2;
4057 break;
4058 case FEC_2_3:
4059 rate_num = 2;
4060 rate_denum = 3;
4061 break;
4062 case FEC_3_4:
4063 rate_num = 3;
4064 rate_denum = 4;
4065 break;
4066 case FEC_5_6:
4067 rate_num = 5;
4068 rate_denum = 6;
4069 break;
4070 default:
4071 case FEC_7_8:
4072 rate_num = 7;
4073 rate_denum = 8;
4074 break;
4077 interleaving = c->layer[i].interleaving;
4079 denom += bits_per_symbol * rate_num * fft_div * nsegs * 384;
4082 /* If all goes wrong, wait for 1s for the next stats */
4083 if (!denom)
4084 return 0;
4086 /* Estimate the period for the total bit rate */
4087 time_us = rate_denum * (1008 * 1562500L);
4088 tmp64 = time_us;
4089 do_div(tmp64, guard);
4090 time_us = time_us + tmp64;
4091 time_us += denom / 2;
4092 do_div(time_us, denom);
4094 tmp = 1008 * 96 * interleaving;
4095 time_us += tmp + tmp / guard;
4097 return time_us;
4100 static int dib8000_get_stats(struct dvb_frontend *fe, enum fe_status stat)
4102 struct dib8000_state *state = fe->demodulator_priv;
4103 struct dtv_frontend_properties *c = &state->fe[0]->dtv_property_cache;
4104 int i;
4105 int show_per_stats = 0;
4106 u32 time_us = 0, snr, val;
4107 u64 blocks;
4108 s32 db;
4109 u16 strength;
4111 /* Get Signal strength */
4112 dib8000_read_signal_strength(fe, &strength);
4113 val = strength;
4114 db = interpolate_value(val,
4115 strength_to_db_table,
4116 ARRAY_SIZE(strength_to_db_table)) - 131000;
4117 c->strength.stat[0].svalue = db;
4119 /* UCB/BER/CNR measures require lock */
4120 if (!(stat & FE_HAS_LOCK)) {
4121 c->cnr.len = 1;
4122 c->block_count.len = 1;
4123 c->block_error.len = 1;
4124 c->post_bit_error.len = 1;
4125 c->post_bit_count.len = 1;
4126 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4127 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4128 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4129 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4130 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
4131 return 0;
4134 /* Check if time for stats was elapsed */
4135 if (time_after(jiffies, state->per_jiffies_stats)) {
4136 state->per_jiffies_stats = jiffies + msecs_to_jiffies(1000);
4138 /* Get SNR */
4139 snr = dib8000_get_snr(fe);
4140 for (i = 1; i < MAX_NUMBER_OF_FRONTENDS; i++) {
4141 if (state->fe[i])
4142 snr += dib8000_get_snr(state->fe[i]);
4144 snr = snr >> 16;
4146 if (snr) {
4147 snr = 10 * intlog10(snr);
4148 snr = (1000L * snr) >> 24;
4149 } else {
4150 snr = 0;
4152 c->cnr.stat[0].svalue = snr;
4153 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
4155 /* Get UCB measures */
4156 dib8000_read_unc_blocks(fe, &val);
4157 if (val < state->init_ucb)
4158 state->init_ucb += 0x100000000LL;
4160 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
4161 c->block_error.stat[0].uvalue = val + state->init_ucb;
4163 /* Estimate the number of packets based on bitrate */
4164 if (!time_us)
4165 time_us = dib8000_get_time_us(fe, -1);
4167 if (time_us) {
4168 blocks = 1250000ULL * 1000000ULL;
4169 do_div(blocks, time_us * 8 * 204);
4170 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
4171 c->block_count.stat[0].uvalue += blocks;
4174 show_per_stats = 1;
4177 /* Get post-BER measures */
4178 if (time_after(jiffies, state->ber_jiffies_stats)) {
4179 time_us = dib8000_get_time_us(fe, -1);
4180 state->ber_jiffies_stats = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
4182 dprintk("Next all layers stats available in %u us.\n", time_us);
4184 dib8000_read_ber(fe, &val);
4185 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
4186 c->post_bit_error.stat[0].uvalue += val;
4188 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
4189 c->post_bit_count.stat[0].uvalue += 100000000;
4192 if (state->revision < 0x8002)
4193 return 0;
4195 c->block_error.len = 4;
4196 c->post_bit_error.len = 4;
4197 c->post_bit_count.len = 4;
4199 for (i = 0; i < 3; i++) {
4200 unsigned nsegs = c->layer[i].segment_count;
4202 if (nsegs == 0 || nsegs > 13)
4203 continue;
4205 time_us = 0;
4207 if (time_after(jiffies, state->ber_jiffies_stats_layer[i])) {
4208 time_us = dib8000_get_time_us(fe, i);
4210 state->ber_jiffies_stats_layer[i] = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
4211 dprintk("Next layer %c stats will be available in %u us\n",
4212 'A' + i, time_us);
4214 val = dib8000_read_word(state, per_layer_regs[i].ber);
4215 c->post_bit_error.stat[1 + i].scale = FE_SCALE_COUNTER;
4216 c->post_bit_error.stat[1 + i].uvalue += val;
4218 c->post_bit_count.stat[1 + i].scale = FE_SCALE_COUNTER;
4219 c->post_bit_count.stat[1 + i].uvalue += 100000000;
4222 if (show_per_stats) {
4223 val = dib8000_read_word(state, per_layer_regs[i].per);
4225 c->block_error.stat[1 + i].scale = FE_SCALE_COUNTER;
4226 c->block_error.stat[1 + i].uvalue += val;
4228 if (!time_us)
4229 time_us = dib8000_get_time_us(fe, i);
4230 if (time_us) {
4231 blocks = 1250000ULL * 1000000ULL;
4232 do_div(blocks, time_us * 8 * 204);
4233 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
4234 c->block_count.stat[0].uvalue += blocks;
4238 return 0;
4241 static int dib8000_set_slave_frontend(struct dvb_frontend *fe, struct dvb_frontend *fe_slave)
4243 struct dib8000_state *state = fe->demodulator_priv;
4244 u8 index_frontend = 1;
4246 while ((index_frontend < MAX_NUMBER_OF_FRONTENDS) && (state->fe[index_frontend] != NULL))
4247 index_frontend++;
4248 if (index_frontend < MAX_NUMBER_OF_FRONTENDS) {
4249 dprintk("set slave fe %p to index %i\n", fe_slave, index_frontend);
4250 state->fe[index_frontend] = fe_slave;
4251 return 0;
4254 dprintk("too many slave frontend\n");
4255 return -ENOMEM;
4258 static struct dvb_frontend *dib8000_get_slave_frontend(struct dvb_frontend *fe, int slave_index)
4260 struct dib8000_state *state = fe->demodulator_priv;
4262 if (slave_index >= MAX_NUMBER_OF_FRONTENDS)
4263 return NULL;
4264 return state->fe[slave_index];
4267 static int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods,
4268 u8 default_addr, u8 first_addr, u8 is_dib8096p)
4270 int k = 0, ret = 0;
4271 u8 new_addr = 0;
4272 struct i2c_device client = {.adap = host };
4274 client.i2c_write_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL);
4275 if (!client.i2c_write_buffer) {
4276 dprintk("%s: not enough memory\n", __func__);
4277 return -ENOMEM;
4279 client.i2c_read_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL);
4280 if (!client.i2c_read_buffer) {
4281 dprintk("%s: not enough memory\n", __func__);
4282 ret = -ENOMEM;
4283 goto error_memory_read;
4285 client.i2c_buffer_lock = kzalloc(sizeof(struct mutex), GFP_KERNEL);
4286 if (!client.i2c_buffer_lock) {
4287 dprintk("%s: not enough memory\n", __func__);
4288 ret = -ENOMEM;
4289 goto error_memory_lock;
4291 mutex_init(client.i2c_buffer_lock);
4293 for (k = no_of_demods - 1; k >= 0; k--) {
4294 /* designated i2c address */
4295 new_addr = first_addr + (k << 1);
4297 client.addr = new_addr;
4298 if (!is_dib8096p)
4299 dib8000_i2c_write16(&client, 1287, 0x0003); /* sram lead in, rdy */
4300 if (dib8000_identify(&client) == 0) {
4301 /* sram lead in, rdy */
4302 if (!is_dib8096p)
4303 dib8000_i2c_write16(&client, 1287, 0x0003);
4304 client.addr = default_addr;
4305 if (dib8000_identify(&client) == 0) {
4306 dprintk("#%d: not identified\n", k);
4307 ret = -EINVAL;
4308 goto error;
4312 /* start diversity to pull_down div_str - just for i2c-enumeration */
4313 dib8000_i2c_write16(&client, 1286, (1 << 10) | (4 << 6));
4315 /* set new i2c address and force divstart */
4316 dib8000_i2c_write16(&client, 1285, (new_addr << 2) | 0x2);
4317 client.addr = new_addr;
4318 dib8000_identify(&client);
4320 dprintk("IC %d initialized (to i2c_address 0x%x)\n", k, new_addr);
4323 for (k = 0; k < no_of_demods; k++) {
4324 new_addr = first_addr | (k << 1);
4325 client.addr = new_addr;
4327 // unforce divstr
4328 dib8000_i2c_write16(&client, 1285, new_addr << 2);
4330 /* deactivate div - it was just for i2c-enumeration */
4331 dib8000_i2c_write16(&client, 1286, 0);
4334 error:
4335 kfree(client.i2c_buffer_lock);
4336 error_memory_lock:
4337 kfree(client.i2c_read_buffer);
4338 error_memory_read:
4339 kfree(client.i2c_write_buffer);
4341 return ret;
4344 static int dib8000_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
4346 tune->min_delay_ms = 1000;
4347 tune->step_size = 0;
4348 tune->max_drift = 0;
4349 return 0;
4352 static void dib8000_release(struct dvb_frontend *fe)
4354 struct dib8000_state *st = fe->demodulator_priv;
4355 u8 index_frontend;
4357 for (index_frontend = 1; (index_frontend < MAX_NUMBER_OF_FRONTENDS) && (st->fe[index_frontend] != NULL); index_frontend++)
4358 dvb_frontend_detach(st->fe[index_frontend]);
4360 dibx000_exit_i2c_master(&st->i2c_master);
4361 i2c_del_adapter(&st->dib8096p_tuner_adap);
4362 kfree(st->fe[0]);
4363 kfree(st);
4366 static struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating)
4368 struct dib8000_state *st = fe->demodulator_priv;
4369 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
4372 static int dib8000_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
4374 struct dib8000_state *st = fe->demodulator_priv;
4375 u16 val = dib8000_read_word(st, 299) & 0xffef;
4376 val |= (onoff & 0x1) << 4;
4378 dprintk("pid filter enabled %d\n", onoff);
4379 return dib8000_write_word(st, 299, val);
4382 static int dib8000_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
4384 struct dib8000_state *st = fe->demodulator_priv;
4385 dprintk("Index %x, PID %d, OnOff %d\n", id, pid, onoff);
4386 return dib8000_write_word(st, 305 + id, onoff ? (1 << 13) | pid : 0);
4389 static const struct dvb_frontend_ops dib8000_ops = {
4390 .delsys = { SYS_ISDBT },
4391 .info = {
4392 .name = "DiBcom 8000 ISDB-T",
4393 .frequency_min = 44250000,
4394 .frequency_max = 867250000,
4395 .frequency_stepsize = 62500,
4396 .caps = FE_CAN_INVERSION_AUTO |
4397 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
4398 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
4399 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
4400 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
4403 .release = dib8000_release,
4405 .init = dib8000_wakeup,
4406 .sleep = dib8000_sleep,
4408 .set_frontend = dib8000_set_frontend,
4409 .get_tune_settings = dib8000_fe_get_tune_settings,
4410 .get_frontend = dib8000_get_frontend,
4412 .read_status = dib8000_read_status,
4413 .read_ber = dib8000_read_ber,
4414 .read_signal_strength = dib8000_read_signal_strength,
4415 .read_snr = dib8000_read_snr,
4416 .read_ucblocks = dib8000_read_unc_blocks,
4419 static struct dvb_frontend *dib8000_init(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg)
4421 struct dvb_frontend *fe;
4422 struct dib8000_state *state;
4424 dprintk("dib8000_init\n");
4426 state = kzalloc(sizeof(struct dib8000_state), GFP_KERNEL);
4427 if (state == NULL)
4428 return NULL;
4429 fe = kzalloc(sizeof(struct dvb_frontend), GFP_KERNEL);
4430 if (fe == NULL)
4431 goto error;
4433 memcpy(&state->cfg, cfg, sizeof(struct dib8000_config));
4434 state->i2c.adap = i2c_adap;
4435 state->i2c.addr = i2c_addr;
4436 state->i2c.i2c_write_buffer = state->i2c_write_buffer;
4437 state->i2c.i2c_read_buffer = state->i2c_read_buffer;
4438 mutex_init(&state->i2c_buffer_lock);
4439 state->i2c.i2c_buffer_lock = &state->i2c_buffer_lock;
4440 state->gpio_val = cfg->gpio_val;
4441 state->gpio_dir = cfg->gpio_dir;
4443 /* Ensure the output mode remains at the previous default if it's
4444 * not specifically set by the caller.
4446 if ((state->cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (state->cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
4447 state->cfg.output_mode = OUTMODE_MPEG2_FIFO;
4449 state->fe[0] = fe;
4450 fe->demodulator_priv = state;
4451 memcpy(&state->fe[0]->ops, &dib8000_ops, sizeof(struct dvb_frontend_ops));
4453 state->timf_default = cfg->pll->timf;
4455 if (dib8000_identify(&state->i2c) == 0)
4456 goto error;
4458 dibx000_init_i2c_master(&state->i2c_master, DIB8000, state->i2c.adap, state->i2c.addr);
4460 /* init 8096p tuner adapter */
4461 strncpy(state->dib8096p_tuner_adap.name, "DiB8096P tuner interface",
4462 sizeof(state->dib8096p_tuner_adap.name));
4463 state->dib8096p_tuner_adap.algo = &dib8096p_tuner_xfer_algo;
4464 state->dib8096p_tuner_adap.algo_data = NULL;
4465 state->dib8096p_tuner_adap.dev.parent = state->i2c.adap->dev.parent;
4466 i2c_set_adapdata(&state->dib8096p_tuner_adap, state);
4467 i2c_add_adapter(&state->dib8096p_tuner_adap);
4469 dib8000_reset(fe);
4471 dib8000_write_word(state, 285, (dib8000_read_word(state, 285) & ~0x60) | (3 << 5)); /* ber_rs_len = 3 */
4472 state->current_demod_bw = 6000;
4474 return fe;
4476 error:
4477 kfree(state);
4478 return NULL;
4481 void *dib8000_attach(struct dib8000_ops *ops)
4483 if (!ops)
4484 return NULL;
4486 ops->pwm_agc_reset = dib8000_pwm_agc_reset;
4487 ops->get_dc_power = dib8090p_get_dc_power;
4488 ops->set_gpio = dib8000_set_gpio;
4489 ops->get_slave_frontend = dib8000_get_slave_frontend;
4490 ops->set_tune_state = dib8000_set_tune_state;
4491 ops->pid_filter_ctrl = dib8000_pid_filter_ctrl;
4492 ops->get_adc_power = dib8000_get_adc_power;
4493 ops->update_pll = dib8000_update_pll;
4494 ops->tuner_sleep = dib8096p_tuner_sleep;
4495 ops->get_tune_state = dib8000_get_tune_state;
4496 ops->get_i2c_tuner = dib8096p_get_i2c_tuner;
4497 ops->set_slave_frontend = dib8000_set_slave_frontend;
4498 ops->pid_filter = dib8000_pid_filter;
4499 ops->ctrl_timf = dib8000_ctrl_timf;
4500 ops->init = dib8000_init;
4501 ops->get_i2c_master = dib8000_get_i2c_master;
4502 ops->i2c_enumeration = dib8000_i2c_enumeration;
4503 ops->set_wbd_ref = dib8000_set_wbd_ref;
4505 return ops;
4507 EXPORT_SYMBOL(dib8000_attach);
4509 MODULE_AUTHOR("Olivier Grenie <Olivier.Grenie@parrot.com, Patrick Boettcher <patrick.boettcher@posteo.de>");
4510 MODULE_DESCRIPTION("Driver for the DiBcom 8000 ISDB-T demodulator");
4511 MODULE_LICENSE("GPL");