?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / media / dvb-frontends / dib7000p.c
blob90ace707a80d7eb9660e0d1d8bcfa78c38a94cc6
1 /*
2 * Linux-DVB Driver for DiBcom's second generation DiB7000P (PC).
3 *
4 * Copyright (C) 2005-7 DiBcom (http://www.dibcom.fr/)
5 *
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 */
10
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
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>
18
19 #include <media/dvb_math.h>
20 #include <media/dvb_frontend.h>
21
22 #include "dib7000p.h"
23
24 static int debug;
25 module_param(debug, int, 0644);
26 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
27
28 static int buggy_sfn_workaround;
29 module_param(buggy_sfn_workaround, int, 0644);
30 MODULE_PARM_DESC(buggy_sfn_workaround, "Enable work-around for buggy SFNs (default: 0)");
31
32 #define dprintk(fmt, arg...) do { \
33 if (debug) \
34 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
35 __func__, ##arg); \
36 } while (0)
37
38 struct i2c_device {
39 struct i2c_adapter *i2c_adap;
40 u8 i2c_addr;
41 };
42
43 struct dib7000p_state {
44 struct dvb_frontend demod;
45 struct dib7000p_config cfg;
46
47 u8 i2c_addr;
48 struct i2c_adapter *i2c_adap;
49
50 struct dibx000_i2c_master i2c_master;
51
52 u16 wbd_ref;
53
54 u8 current_band;
55 u32 current_bandwidth;
56 struct dibx000_agc_config *current_agc;
57 u32 timf;
58
59 u8 div_force_off:1;
60 u8 div_state:1;
61 u16 div_sync_wait;
62
63 u8 agc_state;
64
65 u16 gpio_dir;
66 u16 gpio_val;
67
68 u8 sfn_workaround_active:1;
69
70 #define SOC7090 0x7090
71 u16 version;
72
73 u16 tuner_enable;
74 struct i2c_adapter dib7090_tuner_adap;
75
76 /* for the I2C transfer */
77 struct i2c_msg msg[2];
78 u8 i2c_write_buffer[4];
79 u8 i2c_read_buffer[2];
80 struct mutex i2c_buffer_lock;
81
82 u8 input_mode_mpeg;
83
84 /* for DVBv5 stats */
85 s64 old_ucb;
86 unsigned long per_jiffies_stats;
87 unsigned long ber_jiffies_stats;
88 unsigned long get_stats_time;
89 };
90
91 enum dib7000p_power_mode {
92 DIB7000P_POWER_ALL = 0,
93 DIB7000P_POWER_ANALOG_ADC,
94 DIB7000P_POWER_INTERFACE_ONLY,
95 };
96
97 /* dib7090 specific fonctions */
98 static int dib7090_set_output_mode(struct dvb_frontend *fe, int mode);
99 static int dib7090_set_diversity_in(struct dvb_frontend *fe, int onoff);
100 static void dib7090_setDibTxMux(struct dib7000p_state *state, int mode);
101 static void dib7090_setHostBusMux(struct dib7000p_state *state, int mode);
102
103 static u16 dib7000p_read_word(struct dib7000p_state *state, u16 reg)
104 {
105 u16 ret;
106
107 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
108 dprintk("could not acquire lock\n");
109 return 0;
110 }
111
112 state->i2c_write_buffer[0] = reg >> 8;
113 state->i2c_write_buffer[1] = reg & 0xff;
114
115 memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
116 state->msg[0].addr = state->i2c_addr >> 1;
117 state->msg[0].flags = 0;
118 state->msg[0].buf = state->i2c_write_buffer;
119 state->msg[0].len = 2;
120 state->msg[1].addr = state->i2c_addr >> 1;
121 state->msg[1].flags = I2C_M_RD;
122 state->msg[1].buf = state->i2c_read_buffer;
123 state->msg[1].len = 2;
124
125 if (i2c_transfer(state->i2c_adap, state->msg, 2) != 2)
126 dprintk("i2c read error on %d\n", reg);
127
128 ret = (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
129 mutex_unlock(&state->i2c_buffer_lock);
130 return ret;
131 }
132
133 static int dib7000p_write_word(struct dib7000p_state *state, u16 reg, u16 val)
134 {
135 int ret;
136
137 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
138 dprintk("could not acquire lock\n");
139 return -EINVAL;
140 }
141
142 state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
143 state->i2c_write_buffer[1] = reg & 0xff;
144 state->i2c_write_buffer[2] = (val >> 8) & 0xff;
145 state->i2c_write_buffer[3] = val & 0xff;
146
147 memset(&state->msg[0], 0, sizeof(struct i2c_msg));
148 state->msg[0].addr = state->i2c_addr >> 1;
149 state->msg[0].flags = 0;
150 state->msg[0].buf = state->i2c_write_buffer;
151 state->msg[0].len = 4;
152
153 ret = (i2c_transfer(state->i2c_adap, state->msg, 1) != 1 ?
154 -EREMOTEIO : 0);
155 mutex_unlock(&state->i2c_buffer_lock);
156 return ret;
157 }
158
159 static void dib7000p_write_tab(struct dib7000p_state *state, u16 * buf)
160 {
161 u16 l = 0, r, *n;
162 n = buf;
163 l = *n++;
164 while (l) {
165 r = *n++;
166
167 do {
168 dib7000p_write_word(state, r, *n++);
169 r++;
170 } while (--l);
171 l = *n++;
172 }
173 }
174
175 static int dib7000p_set_output_mode(struct dib7000p_state *state, int mode)
176 {
177 int ret = 0;
178 u16 outreg, fifo_threshold, smo_mode;
179
180 outreg = 0;
181 fifo_threshold = 1792;
182 smo_mode = (dib7000p_read_word(state, 235) & 0x0050) | (1 << 1);
183
184 dprintk("setting output mode for demod %p to %d\n", &state->demod, mode);
185
186 switch (mode) {
187 case OUTMODE_MPEG2_PAR_GATED_CLK:
188 outreg = (1 << 10); /* 0x0400 */
189 break;
190 case OUTMODE_MPEG2_PAR_CONT_CLK:
191 outreg = (1 << 10) | (1 << 6); /* 0x0440 */
192 break;
193 case OUTMODE_MPEG2_SERIAL:
194 outreg = (1 << 10) | (2 << 6) | (0 << 1); /* 0x0480 */
195 break;
196 case OUTMODE_DIVERSITY:
197 if (state->cfg.hostbus_diversity)
198 outreg = (1 << 10) | (4 << 6); /* 0x0500 */
199 else
200 outreg = (1 << 11);
201 break;
202 case OUTMODE_MPEG2_FIFO:
203 smo_mode |= (3 << 1);
204 fifo_threshold = 512;
205 outreg = (1 << 10) | (5 << 6);
206 break;
207 case OUTMODE_ANALOG_ADC:
208 outreg = (1 << 10) | (3 << 6);
209 break;
210 case OUTMODE_HIGH_Z:
211 outreg = 0;
212 break;
213 default:
214 dprintk("Unhandled output_mode passed to be set for demod %p\n", &state->demod);
215 break;
216 }
217
218 if (state->cfg.output_mpeg2_in_188_bytes)
219 smo_mode |= (1 << 5);
220
221 ret |= dib7000p_write_word(state, 235, smo_mode);
222 ret |= dib7000p_write_word(state, 236, fifo_threshold); /* synchronous fread */
223 if (state->version != SOC7090)
224 ret |= dib7000p_write_word(state, 1286, outreg); /* P_Div_active */
225
226 return ret;
227 }
228
229 static int dib7000p_set_diversity_in(struct dvb_frontend *demod, int onoff)
230 {
231 struct dib7000p_state *state = demod->demodulator_priv;
232
233 if (state->div_force_off) {
234 dprintk("diversity combination deactivated - forced by COFDM parameters\n");
235 onoff = 0;
236 dib7000p_write_word(state, 207, 0);
237 } else
238 dib7000p_write_word(state, 207, (state->div_sync_wait << 4) | (1 << 2) | (2 << 0));
239
240 state->div_state = (u8) onoff;
241
242 if (onoff) {
243 dib7000p_write_word(state, 204, 6);
244 dib7000p_write_word(state, 205, 16);
245 /* P_dvsy_sync_mode = 0, P_dvsy_sync_enable=1, P_dvcb_comb_mode=2 */
246 } else {
247 dib7000p_write_word(state, 204, 1);
248 dib7000p_write_word(state, 205, 0);
249 }
250
251 return 0;
252 }
253
254 static int dib7000p_set_power_mode(struct dib7000p_state *state, enum dib7000p_power_mode mode)
255 {
256 /* by default everything is powered off */
257 u16 reg_774 = 0x3fff, reg_775 = 0xffff, reg_776 = 0x0007, reg_899 = 0x0003, reg_1280 = (0xfe00) | (dib7000p_read_word(state, 1280) & 0x01ff);
258
259 /* now, depending on the requested mode, we power on */
260 switch (mode) {
261 /* power up everything in the demod */
262 case DIB7000P_POWER_ALL:
263 reg_774 = 0x0000;
264 reg_775 = 0x0000;
265 reg_776 = 0x0;
266 reg_899 = 0x0;
267 if (state->version == SOC7090)
268 reg_1280 &= 0x001f;
269 else
270 reg_1280 &= 0x01ff;
271 break;
272
273 case DIB7000P_POWER_ANALOG_ADC:
274 /* dem, cfg, iqc, sad, agc */
275 reg_774 &= ~((1 << 15) | (1 << 14) | (1 << 11) | (1 << 10) | (1 << 9));
276 /* nud */
277 reg_776 &= ~((1 << 0));
278 /* Dout */
279 if (state->version != SOC7090)
280 reg_1280 &= ~((1 << 11));
281 reg_1280 &= ~(1 << 6);
282 /* fall-through */
283 case DIB7000P_POWER_INTERFACE_ONLY:
284 /* just leave power on the control-interfaces: GPIO and (I2C or SDIO) */
285 /* TODO power up either SDIO or I2C */
286 if (state->version == SOC7090)
287 reg_1280 &= ~((1 << 7) | (1 << 5));
288 else
289 reg_1280 &= ~((1 << 14) | (1 << 13) | (1 << 12) | (1 << 10));
290 break;
291
292 /* TODO following stuff is just converted from the dib7000-driver - check when is used what */
293 }
294
295 dib7000p_write_word(state, 774, reg_774);
296 dib7000p_write_word(state, 775, reg_775);
297 dib7000p_write_word(state, 776, reg_776);
298 dib7000p_write_word(state, 1280, reg_1280);
299 if (state->version != SOC7090)
300 dib7000p_write_word(state, 899, reg_899);
301
302 return 0;
303 }
304
305 static void dib7000p_set_adc_state(struct dib7000p_state *state, enum dibx000_adc_states no)
306 {
307 u16 reg_908 = 0, reg_909 = 0;
308 u16 reg;
309
310 if (state->version != SOC7090) {
311 reg_908 = dib7000p_read_word(state, 908);
312 reg_909 = dib7000p_read_word(state, 909);
313 }
314
315 switch (no) {
316 case DIBX000_SLOW_ADC_ON:
317 if (state->version == SOC7090) {
318 reg = dib7000p_read_word(state, 1925);
319
320 dib7000p_write_word(state, 1925, reg | (1 << 4) | (1 << 2)); /* en_slowAdc = 1 & reset_sladc = 1 */
321
322 reg = dib7000p_read_word(state, 1925); /* read acces to make it works... strange ... */
323 msleep(200);
324 dib7000p_write_word(state, 1925, reg & ~(1 << 4)); /* en_slowAdc = 1 & reset_sladc = 0 */
325
326 reg = dib7000p_read_word(state, 72) & ~((0x3 << 14) | (0x3 << 12));
327 dib7000p_write_word(state, 72, reg | (1 << 14) | (3 << 12) | 524); /* ref = Vin1 => Vbg ; sel = Vin0 or Vin3 ; (Vin2 = Vcm) */
328 } else {
329 reg_909 |= (1 << 1) | (1 << 0);
330 dib7000p_write_word(state, 909, reg_909);
331 reg_909 &= ~(1 << 1);
332 }
333 break;
334
335 case DIBX000_SLOW_ADC_OFF:
336 if (state->version == SOC7090) {
337 reg = dib7000p_read_word(state, 1925);
338 dib7000p_write_word(state, 1925, (reg & ~(1 << 2)) | (1 << 4)); /* reset_sladc = 1 en_slowAdc = 0 */
339 } else
340 reg_909 |= (1 << 1) | (1 << 0);
341 break;
342
343 case DIBX000_ADC_ON:
344 reg_908 &= 0x0fff;
345 reg_909 &= 0x0003;
346 break;
347
348 case DIBX000_ADC_OFF:
349 reg_908 |= (1 << 14) | (1 << 13) | (1 << 12);
350 reg_909 |= (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2);
351 break;
352
353 case DIBX000_VBG_ENABLE:
354 reg_908 &= ~(1 << 15);
355 break;
356
357 case DIBX000_VBG_DISABLE:
358 reg_908 |= (1 << 15);
359 break;
360
361 default:
362 break;
363 }
364
365 // dprintk( "908: %x, 909: %x\n", reg_908, reg_909);
366
367 reg_909 |= (state->cfg.disable_sample_and_hold & 1) << 4;
368 reg_908 |= (state->cfg.enable_current_mirror & 1) << 7;
369
370 if (state->version != SOC7090) {
371 dib7000p_write_word(state, 908, reg_908);
372 dib7000p_write_word(state, 909, reg_909);
373 }
374 }
375
376 static int dib7000p_set_bandwidth(struct dib7000p_state *state, u32 bw)
377 {
378 u32 timf;
379
380 // store the current bandwidth for later use
381 state->current_bandwidth = bw;
382
383 if (state->timf == 0) {
384 dprintk("using default timf\n");
385 timf = state->cfg.bw->timf;
386 } else {
387 dprintk("using updated timf\n");
388 timf = state->timf;
389 }
390
391 timf = timf * (bw / 50) / 160;
392
393 dib7000p_write_word(state, 23, (u16) ((timf >> 16) & 0xffff));
394 dib7000p_write_word(state, 24, (u16) ((timf) & 0xffff));
395
396 return 0;
397 }
398
399 static int dib7000p_sad_calib(struct dib7000p_state *state)
400 {
401 /* internal */
402 dib7000p_write_word(state, 73, (0 << 1) | (0 << 0));
403
404 if (state->version == SOC7090)
405 dib7000p_write_word(state, 74, 2048);
406 else
407 dib7000p_write_word(state, 74, 776);
408
409 /* do the calibration */
410 dib7000p_write_word(state, 73, (1 << 0));
411 dib7000p_write_word(state, 73, (0 << 0));
412
413 msleep(1);
414
415 return 0;
416 }
417
418 static int dib7000p_set_wbd_ref(struct dvb_frontend *demod, u16 value)
419 {
420 struct dib7000p_state *state = demod->demodulator_priv;
421 if (value > 4095)
422 value = 4095;
423 state->wbd_ref = value;
424 return dib7000p_write_word(state, 105, (dib7000p_read_word(state, 105) & 0xf000) | value);
425 }
426
427 static int dib7000p_get_agc_values(struct dvb_frontend *fe,
428 u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd)
429 {
430 struct dib7000p_state *state = fe->demodulator_priv;
431
432 if (agc_global != NULL)
433 *agc_global = dib7000p_read_word(state, 394);
434 if (agc1 != NULL)
435 *agc1 = dib7000p_read_word(state, 392);
436 if (agc2 != NULL)
437 *agc2 = dib7000p_read_word(state, 393);
438 if (wbd != NULL)
439 *wbd = dib7000p_read_word(state, 397);
440
441 return 0;
442 }
443
444 static int dib7000p_set_agc1_min(struct dvb_frontend *fe, u16 v)
445 {
446 struct dib7000p_state *state = fe->demodulator_priv;
447 return dib7000p_write_word(state, 108, v);
448 }
449
450 static void dib7000p_reset_pll(struct dib7000p_state *state)
451 {
452 struct dibx000_bandwidth_config *bw = &state->cfg.bw[0];
453 u16 clk_cfg0;
454
455 if (state->version == SOC7090) {
456 dib7000p_write_word(state, 1856, (!bw->pll_reset << 13) | (bw->pll_range << 12) | (bw->pll_ratio << 6) | (bw->pll_prediv));
457
458 while (((dib7000p_read_word(state, 1856) >> 15) & 0x1) != 1)
459 ;
460
461 dib7000p_write_word(state, 1857, dib7000p_read_word(state, 1857) | (!bw->pll_bypass << 15));
462 } else {
463 /* force PLL bypass */
464 clk_cfg0 = (1 << 15) | ((bw->pll_ratio & 0x3f) << 9) |
465 (bw->modulo << 7) | (bw->ADClkSrc << 6) | (bw->IO_CLK_en_core << 5) | (bw->bypclk_div << 2) | (bw->enable_refdiv << 1) | (0 << 0);
466
467 dib7000p_write_word(state, 900, clk_cfg0);
468
469 /* P_pll_cfg */
470 dib7000p_write_word(state, 903, (bw->pll_prediv << 5) | (((bw->pll_ratio >> 6) & 0x3) << 3) | (bw->pll_range << 1) | bw->pll_reset);
471 clk_cfg0 = (bw->pll_bypass << 15) | (clk_cfg0 & 0x7fff);
472 dib7000p_write_word(state, 900, clk_cfg0);
473 }
474
475 dib7000p_write_word(state, 18, (u16) (((bw->internal * 1000) >> 16) & 0xffff));
476 dib7000p_write_word(state, 19, (u16) ((bw->internal * 1000) & 0xffff));
477 dib7000p_write_word(state, 21, (u16) ((bw->ifreq >> 16) & 0xffff));
478 dib7000p_write_word(state, 22, (u16) ((bw->ifreq) & 0xffff));
479
480 dib7000p_write_word(state, 72, bw->sad_cfg);
481 }
482
483 static u32 dib7000p_get_internal_freq(struct dib7000p_state *state)
484 {
485 u32 internal = (u32) dib7000p_read_word(state, 18) << 16;
486 internal |= (u32) dib7000p_read_word(state, 19);
487 internal /= 1000;
488
489 return internal;
490 }
491
492 static int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw)
493 {
494 struct dib7000p_state *state = fe->demodulator_priv;
495 u16 reg_1857, reg_1856 = dib7000p_read_word(state, 1856);
496 u8 loopdiv, prediv;
497 u32 internal, xtal;
498
499 /* get back old values */
500 prediv = reg_1856 & 0x3f;
501 loopdiv = (reg_1856 >> 6) & 0x3f;
502
503 if ((bw != NULL) && (bw->pll_prediv != prediv || bw->pll_ratio != loopdiv)) {
504 dprintk("Updating pll (prediv: old = %d new = %d ; loopdiv : old = %d new = %d)\n", prediv, bw->pll_prediv, loopdiv, bw->pll_ratio);
505 reg_1856 &= 0xf000;
506 reg_1857 = dib7000p_read_word(state, 1857);
507 dib7000p_write_word(state, 1857, reg_1857 & ~(1 << 15));
508
509 dib7000p_write_word(state, 1856, reg_1856 | ((bw->pll_ratio & 0x3f) << 6) | (bw->pll_prediv & 0x3f));
510
511 /* write new system clk into P_sec_len */
512 internal = dib7000p_get_internal_freq(state);
513 xtal = (internal / loopdiv) * prediv;
514 internal = 1000 * (xtal / bw->pll_prediv) * bw->pll_ratio; /* new internal */
515 dib7000p_write_word(state, 18, (u16) ((internal >> 16) & 0xffff));
516 dib7000p_write_word(state, 19, (u16) (internal & 0xffff));
517
518 dib7000p_write_word(state, 1857, reg_1857 | (1 << 15));
519
520 while (((dib7000p_read_word(state, 1856) >> 15) & 0x1) != 1)
521 dprintk("Waiting for PLL to lock\n");
522
523 return 0;
524 }
525 return -EIO;
526 }
527
528 static int dib7000p_reset_gpio(struct dib7000p_state *st)
529 {
530 /* reset the GPIOs */
531 dprintk("gpio dir: %x: val: %x, pwm_pos: %x\n", st->gpio_dir, st->gpio_val, st->cfg.gpio_pwm_pos);
532
533 dib7000p_write_word(st, 1029, st->gpio_dir);
534 dib7000p_write_word(st, 1030, st->gpio_val);
535
536 /* TODO 1031 is P_gpio_od */
537
538 dib7000p_write_word(st, 1032, st->cfg.gpio_pwm_pos);
539
540 dib7000p_write_word(st, 1037, st->cfg.pwm_freq_div);
541 return 0;
542 }
543
544 static int dib7000p_cfg_gpio(struct dib7000p_state *st, u8 num, u8 dir, u8 val)
545 {
546 st->gpio_dir = dib7000p_read_word(st, 1029);
547 st->gpio_dir &= ~(1 << num); /* reset the direction bit */
548 st->gpio_dir |= (dir & 0x1) << num; /* set the new direction */
549 dib7000p_write_word(st, 1029, st->gpio_dir);
550
551 st->gpio_val = dib7000p_read_word(st, 1030);
552 st->gpio_val &= ~(1 << num); /* reset the direction bit */
553 st->gpio_val |= (val & 0x01) << num; /* set the new value */
554 dib7000p_write_word(st, 1030, st->gpio_val);
555
556 return 0;
557 }
558
559 static int dib7000p_set_gpio(struct dvb_frontend *demod, u8 num, u8 dir, u8 val)
560 {
561 struct dib7000p_state *state = demod->demodulator_priv;
562 return dib7000p_cfg_gpio(state, num, dir, val);
563 }
564
565 static u16 dib7000p_defaults[] = {
566 // auto search configuration
567 3, 2,
568 0x0004,
569 (1<<3)|(1<<11)|(1<<12)|(1<<13),
570 0x0814, /* Equal Lock */
571
572 12, 6,
573 0x001b,
574 0x7740,
575 0x005b,
576 0x8d80,
577 0x01c9,
578 0xc380,
579 0x0000,
580 0x0080,
581 0x0000,
582 0x0090,
583 0x0001,
584 0xd4c0,
585
586 1, 26,
587 0x6680,
588
589 /* set ADC level to -16 */
590 11, 79,
591 (1 << 13) - 825 - 117,
592 (1 << 13) - 837 - 117,
593 (1 << 13) - 811 - 117,
594 (1 << 13) - 766 - 117,
595 (1 << 13) - 737 - 117,
596 (1 << 13) - 693 - 117,
597 (1 << 13) - 648 - 117,
598 (1 << 13) - 619 - 117,
599 (1 << 13) - 575 - 117,
600 (1 << 13) - 531 - 117,
601 (1 << 13) - 501 - 117,
602
603 1, 142,
604 0x0410,
605
606 /* disable power smoothing */
607 8, 145,
608 0,
609 0,
610 0,
611 0,
612 0,
613 0,
614 0,
615 0,
616
617 1, 154,
618 1 << 13,
619
620 1, 168,
621 0x0ccd,
622
623 1, 183,
624 0x200f,
625
626 1, 212,
627 0x169,
628
629 5, 187,
630 0x023d,
631 0x00a4,
632 0x00a4,
633 0x7ff0,
634 0x3ccc,
635
636 1, 198,
637 0x800,
638
639 1, 222,
640 0x0010,
641
642 1, 235,
643 0x0062,
644
645 0,
646 };
647
648 static void dib7000p_reset_stats(struct dvb_frontend *fe);
649
650 static int dib7000p_demod_reset(struct dib7000p_state *state)
651 {
652 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
653
654 if (state->version == SOC7090)
655 dibx000_reset_i2c_master(&state->i2c_master);
656
657 dib7000p_set_adc_state(state, DIBX000_VBG_ENABLE);
658
659 /* restart all parts */
660 dib7000p_write_word(state, 770, 0xffff);
661 dib7000p_write_word(state, 771, 0xffff);
662 dib7000p_write_word(state, 772, 0x001f);
663 dib7000p_write_word(state, 1280, 0x001f - ((1 << 4) | (1 << 3)));
664
665 dib7000p_write_word(state, 770, 0);
666 dib7000p_write_word(state, 771, 0);
667 dib7000p_write_word(state, 772, 0);
668 dib7000p_write_word(state, 1280, 0);
669
670 if (state->version != SOC7090) {
671 dib7000p_write_word(state, 898, 0x0003);
672 dib7000p_write_word(state, 898, 0);
673 }
674
675 /* default */
676 dib7000p_reset_pll(state);
677
678 if (dib7000p_reset_gpio(state) != 0)
679 dprintk("GPIO reset was not successful.\n");
680
681 if (state->version == SOC7090) {
682 dib7000p_write_word(state, 899, 0);
683
684 /* impulse noise */
685 dib7000p_write_word(state, 42, (1<<5) | 3); /* P_iqc_thsat_ipc = 1 ; P_iqc_win2 = 3 */
686 dib7000p_write_word(state, 43, 0x2d4); /*-300 fag P_iqc_dect_min = -280 */
687 dib7000p_write_word(state, 44, 300); /* 300 fag P_iqc_dect_min = +280 */
688 dib7000p_write_word(state, 273, (0<<6) | 30);
689 }
690 if (dib7000p_set_output_mode(state, OUTMODE_HIGH_Z) != 0)
691 dprintk("OUTPUT_MODE could not be reset.\n");
692
693 dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_ON);
694 dib7000p_sad_calib(state);
695 dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_OFF);
696
697 /* unforce divstr regardless whether i2c enumeration was done or not */
698 dib7000p_write_word(state, 1285, dib7000p_read_word(state, 1285) & ~(1 << 1));
699
700 dib7000p_set_bandwidth(state, 8000);
701
702 if (state->version == SOC7090) {
703 dib7000p_write_word(state, 36, 0x0755);/* P_iqc_impnc_on =1 & P_iqc_corr_inh = 1 for impulsive noise */
704 } else {
705 if (state->cfg.tuner_is_baseband)
706 dib7000p_write_word(state, 36, 0x0755);
707 else
708 dib7000p_write_word(state, 36, 0x1f55);
709 }
710
711 dib7000p_write_tab(state, dib7000p_defaults);
712 if (state->version != SOC7090) {
713 dib7000p_write_word(state, 901, 0x0006);
714 dib7000p_write_word(state, 902, (3 << 10) | (1 << 6));
715 dib7000p_write_word(state, 905, 0x2c8e);
716 }
717
718 dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
719
720 return 0;
721 }
722
723 static void dib7000p_pll_clk_cfg(struct dib7000p_state *state)
724 {
725 u16 tmp = 0;
726 tmp = dib7000p_read_word(state, 903);
727 dib7000p_write_word(state, 903, (tmp | 0x1));
728 tmp = dib7000p_read_word(state, 900);
729 dib7000p_write_word(state, 900, (tmp & 0x7fff) | (1 << 6));
730 }
731
732 static void dib7000p_restart_agc(struct dib7000p_state *state)
733 {
734 // P_restart_iqc & P_restart_agc
735 dib7000p_write_word(state, 770, (1 << 11) | (1 << 9));
736 dib7000p_write_word(state, 770, 0x0000);
737 }
738
739 static int dib7000p_update_lna(struct dib7000p_state *state)
740 {
741 u16 dyn_gain;
742
743 if (state->cfg.update_lna) {
744 dyn_gain = dib7000p_read_word(state, 394);
745 if (state->cfg.update_lna(&state->demod, dyn_gain)) {
746 dib7000p_restart_agc(state);
747 return 1;
748 }
749 }
750
751 return 0;
752 }
753
754 static int dib7000p_set_agc_config(struct dib7000p_state *state, u8 band)
755 {
756 struct dibx000_agc_config *agc = NULL;
757 int i;
758 if (state->current_band == band && state->current_agc != NULL)
759 return 0;
760 state->current_band = band;
761
762 for (i = 0; i < state->cfg.agc_config_count; i++)
763 if (state->cfg.agc[i].band_caps & band) {
764 agc = &state->cfg.agc[i];
765 break;
766 }
767
768 if (agc == NULL) {
769 dprintk("no valid AGC configuration found for band 0x%02x\n", band);
770 return -EINVAL;
771 }
772
773 state->current_agc = agc;
774
775 /* AGC */
776 dib7000p_write_word(state, 75, agc->setup);
777 dib7000p_write_word(state, 76, agc->inv_gain);
778 dib7000p_write_word(state, 77, agc->time_stabiliz);
779 dib7000p_write_word(state, 100, (agc->alpha_level << 12) | agc->thlock);
780
781 // Demod AGC loop configuration
782 dib7000p_write_word(state, 101, (agc->alpha_mant << 5) | agc->alpha_exp);
783 dib7000p_write_word(state, 102, (agc->beta_mant << 6) | agc->beta_exp);
784
785 /* AGC continued */
786 dprintk("WBD: ref: %d, sel: %d, active: %d, alpha: %d\n",
787 state->wbd_ref != 0 ? state->wbd_ref : agc->wbd_ref, agc->wbd_sel, !agc->perform_agc_softsplit, agc->wbd_sel);
788
789 if (state->wbd_ref != 0)
790 dib7000p_write_word(state, 105, (agc->wbd_inv << 12) | state->wbd_ref);
791 else
792 dib7000p_write_word(state, 105, (agc->wbd_inv << 12) | agc->wbd_ref);
793
794 dib7000p_write_word(state, 106, (agc->wbd_sel << 13) | (agc->wbd_alpha << 9) | (agc->perform_agc_softsplit << 8));
795
796 dib7000p_write_word(state, 107, agc->agc1_max);
797 dib7000p_write_word(state, 108, agc->agc1_min);
798 dib7000p_write_word(state, 109, agc->agc2_max);
799 dib7000p_write_word(state, 110, agc->agc2_min);
800 dib7000p_write_word(state, 111, (agc->agc1_pt1 << 8) | agc->agc1_pt2);
801 dib7000p_write_word(state, 112, agc->agc1_pt3);
802 dib7000p_write_word(state, 113, (agc->agc1_slope1 << 8) | agc->agc1_slope2);
803 dib7000p_write_word(state, 114, (agc->agc2_pt1 << 8) | agc->agc2_pt2);
804 dib7000p_write_word(state, 115, (agc->agc2_slope1 << 8) | agc->agc2_slope2);
805 return 0;
806 }
807
808 static int dib7000p_set_dds(struct dib7000p_state *state, s32 offset_khz)
809 {
810 u32 internal = dib7000p_get_internal_freq(state);
811 s32 unit_khz_dds_val;
812 u32 abs_offset_khz = ABS(offset_khz);
813 u32 dds = state->cfg.bw->ifreq & 0x1ffffff;
814 u8 invert = !!(state->cfg.bw->ifreq & (1 << 25));
815 if (internal == 0) {
816 pr_warn("DIB7000P: dib7000p_get_internal_freq returned 0\n");
817 return -1;
818 }
819 /* 2**26 / Fsampling is the unit 1KHz offset */
820 unit_khz_dds_val = 67108864 / (internal);
821
822 dprintk("setting a frequency offset of %dkHz internal freq = %d invert = %d\n", offset_khz, internal, invert);
823
824 if (offset_khz < 0)
825 unit_khz_dds_val *= -1;
826
827 /* IF tuner */
828 if (invert)
829 dds -= (abs_offset_khz * unit_khz_dds_val); /* /100 because of /100 on the unit_khz_dds_val line calc for better accuracy */
830 else
831 dds += (abs_offset_khz * unit_khz_dds_val);
832
833 if (abs_offset_khz <= (internal / 2)) { /* Max dds offset is the half of the demod freq */
834 dib7000p_write_word(state, 21, (u16) (((dds >> 16) & 0x1ff) | (0 << 10) | (invert << 9)));
835 dib7000p_write_word(state, 22, (u16) (dds & 0xffff));
836 }
837 return 0;
838 }
839
840 static int dib7000p_agc_startup(struct dvb_frontend *demod)
841 {
842 struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
843 struct dib7000p_state *state = demod->demodulator_priv;
844 int ret = -1;
845 u8 *agc_state = &state->agc_state;
846 u8 agc_split;
847 u16 reg;
848 u32 upd_demod_gain_period = 0x1000;
849 s32 frequency_offset = 0;
850
851 switch (state->agc_state) {
852 case 0:
853 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
854 if (state->version == SOC7090) {
855 reg = dib7000p_read_word(state, 0x79b) & 0xff00;
856 dib7000p_write_word(state, 0x79a, upd_demod_gain_period & 0xFFFF); /* lsb */
857 dib7000p_write_word(state, 0x79b, reg | (1 << 14) | ((upd_demod_gain_period >> 16) & 0xFF));
858
859 /* enable adc i & q */
860 reg = dib7000p_read_word(state, 0x780);
861 dib7000p_write_word(state, 0x780, (reg | (0x3)) & (~(1 << 7)));
862 } else {
863 dib7000p_set_adc_state(state, DIBX000_ADC_ON);
864 dib7000p_pll_clk_cfg(state);
865 }
866
867 if (dib7000p_set_agc_config(state, BAND_OF_FREQUENCY(ch->frequency / 1000)) != 0)
868 return -1;
869
870 if (demod->ops.tuner_ops.get_frequency) {
871 u32 frequency_tuner;
872
873 demod->ops.tuner_ops.get_frequency(demod, &frequency_tuner);
874 frequency_offset = (s32)frequency_tuner / 1000 - ch->frequency / 1000;
875 }
876
877 if (dib7000p_set_dds(state, frequency_offset) < 0)
878 return -1;
879
880 ret = 7;
881 (*agc_state)++;
882 break;
883
884 case 1:
885 if (state->cfg.agc_control)
886 state->cfg.agc_control(&state->demod, 1);
887
888 dib7000p_write_word(state, 78, 32768);
889 if (!state->current_agc->perform_agc_softsplit) {
890 /* we are using the wbd - so slow AGC startup */
891 /* force 0 split on WBD and restart AGC */
892 dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (state->current_agc->wbd_alpha << 9) | (1 << 8));
893 (*agc_state)++;
894 ret = 5;
895 } else {
896 /* default AGC startup */
897 (*agc_state) = 4;
898 /* wait AGC rough lock time */
899 ret = 7;
900 }
901
902 dib7000p_restart_agc(state);
903 break;
904
905 case 2: /* fast split search path after 5sec */
906 dib7000p_write_word(state, 75, state->current_agc->setup | (1 << 4)); /* freeze AGC loop */
907 dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (2 << 9) | (0 << 8)); /* fast split search 0.25kHz */
908 (*agc_state)++;
909 ret = 14;
910 break;
911
912 case 3: /* split search ended */
913 agc_split = (u8) dib7000p_read_word(state, 396); /* store the split value for the next time */
914 dib7000p_write_word(state, 78, dib7000p_read_word(state, 394)); /* set AGC gain start value */
915
916 dib7000p_write_word(state, 75, state->current_agc->setup); /* std AGC loop */
917 dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (state->current_agc->wbd_alpha << 9) | agc_split); /* standard split search */
918
919 dib7000p_restart_agc(state);
920
921 dprintk("SPLIT %p: %hd\n", demod, agc_split);
922
923 (*agc_state)++;
924 ret = 5;
925 break;
926
927 case 4: /* LNA startup */
928 ret = 7;
929
930 if (dib7000p_update_lna(state))
931 ret = 5;
932 else
933 (*agc_state)++;
934 break;
935
936 case 5:
937 if (state->cfg.agc_control)
938 state->cfg.agc_control(&state->demod, 0);
939 (*agc_state)++;
940 break;
941 default:
942 break;
943 }
944 return ret;
945 }
946
947 static void dib7000p_update_timf(struct dib7000p_state *state)
948 {
949 u32 timf = (dib7000p_read_word(state, 427) << 16) | dib7000p_read_word(state, 428);
950 state->timf = timf * 160 / (state->current_bandwidth / 50);
951 dib7000p_write_word(state, 23, (u16) (timf >> 16));
952 dib7000p_write_word(state, 24, (u16) (timf & 0xffff));
953 dprintk("updated timf_frequency: %d (default: %d)\n", state->timf, state->cfg.bw->timf);
954
955 }
956
957 static u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf)
958 {
959 struct dib7000p_state *state = fe->demodulator_priv;
960 switch (op) {
961 case DEMOD_TIMF_SET:
962 state->timf = timf;
963 break;
964 case DEMOD_TIMF_UPDATE:
965 dib7000p_update_timf(state);
966 break;
967 case DEMOD_TIMF_GET:
968 break;
969 }
970 dib7000p_set_bandwidth(state, state->current_bandwidth);
971 return state->timf;
972 }
973
974 static void dib7000p_set_channel(struct dib7000p_state *state,
975 struct dtv_frontend_properties *ch, u8 seq)
976 {
977 u16 value, est[4];
978
979 dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
980
981 /* nfft, guard, qam, alpha */
982 value = 0;
983 switch (ch->transmission_mode) {
984 case TRANSMISSION_MODE_2K:
985 value |= (0 << 7);
986 break;
987 case TRANSMISSION_MODE_4K:
988 value |= (2 << 7);
989 break;
990 default:
991 case TRANSMISSION_MODE_8K:
992 value |= (1 << 7);
993 break;
994 }
995 switch (ch->guard_interval) {
996 case GUARD_INTERVAL_1_32:
997 value |= (0 << 5);
998 break;
999 case GUARD_INTERVAL_1_16:
1000 value |= (1 << 5);
1001 break;
1002 case GUARD_INTERVAL_1_4:
1003 value |= (3 << 5);
1004 break;
1005 default:
1006 case GUARD_INTERVAL_1_8:
1007 value |= (2 << 5);
1008 break;
1009 }
1010 switch (ch->modulation) {
1011 case QPSK:
1012 value |= (0 << 3);
1013 break;
1014 case QAM_16:
1015 value |= (1 << 3);
1016 break;
1017 default:
1018 case QAM_64:
1019 value |= (2 << 3);
1020 break;
1021 }
1022 switch (HIERARCHY_1) {
1023 case HIERARCHY_2:
1024 value |= 2;
1025 break;
1026 case HIERARCHY_4:
1027 value |= 4;
1028 break;
1029 default:
1030 case HIERARCHY_1:
1031 value |= 1;
1032 break;
1033 }
1034 dib7000p_write_word(state, 0, value);
1035 dib7000p_write_word(state, 5, (seq << 4) | 1); /* do not force tps, search list 0 */
1036
1037 /* P_dintl_native, P_dintlv_inv, P_hrch, P_code_rate, P_select_hp */
1038 value = 0;
1039 if (1 != 0)
1040 value |= (1 << 6);
1041 if (ch->hierarchy == 1)
1042 value |= (1 << 4);
1043 if (1 == 1)
1044 value |= 1;
1045 switch ((ch->hierarchy == 0 || 1 == 1) ? ch->code_rate_HP : ch->code_rate_LP) {
1046 case FEC_2_3:
1047 value |= (2 << 1);
1048 break;
1049 case FEC_3_4:
1050 value |= (3 << 1);
1051 break;
1052 case FEC_5_6:
1053 value |= (5 << 1);
1054 break;
1055 case FEC_7_8:
1056 value |= (7 << 1);
1057 break;
1058 default:
1059 case FEC_1_2:
1060 value |= (1 << 1);
1061 break;
1062 }
1063 dib7000p_write_word(state, 208, value);
1064
1065 /* offset loop parameters */
1066 dib7000p_write_word(state, 26, 0x6680);
1067 dib7000p_write_word(state, 32, 0x0003);
1068 dib7000p_write_word(state, 29, 0x1273);
1069 dib7000p_write_word(state, 33, 0x0005);
1070
1071 /* P_dvsy_sync_wait */
1072 switch (ch->transmission_mode) {
1073 case TRANSMISSION_MODE_8K:
1074 value = 256;
1075 break;
1076 case TRANSMISSION_MODE_4K:
1077 value = 128;
1078 break;
1079 case TRANSMISSION_MODE_2K:
1080 default:
1081 value = 64;
1082 break;
1083 }
1084 switch (ch->guard_interval) {
1085 case GUARD_INTERVAL_1_16:
1086 value *= 2;
1087 break;
1088 case GUARD_INTERVAL_1_8:
1089 value *= 4;
1090 break;
1091 case GUARD_INTERVAL_1_4:
1092 value *= 8;
1093 break;
1094 default:
1095 case GUARD_INTERVAL_1_32:
1096 value *= 1;
1097 break;
1098 }
1099 if (state->cfg.diversity_delay == 0)
1100 state->div_sync_wait = (value * 3) / 2 + 48;
1101 else
1102 state->div_sync_wait = (value * 3) / 2 + state->cfg.diversity_delay;
1103
1104 /* deactive the possibility of diversity reception if extended interleaver */
1105 state->div_force_off = !1 && ch->transmission_mode != TRANSMISSION_MODE_8K;
1106 dib7000p_set_diversity_in(&state->demod, state->div_state);
1107
1108 /* channel estimation fine configuration */
1109 switch (ch->modulation) {
1110 case QAM_64:
1111 est[0] = 0x0148; /* P_adp_regul_cnt 0.04 */
1112 est[1] = 0xfff0; /* P_adp_noise_cnt -0.002 */
1113 est[2] = 0x00a4; /* P_adp_regul_ext 0.02 */
1114 est[3] = 0xfff8; /* P_adp_noise_ext -0.001 */
1115 break;
1116 case QAM_16:
1117 est[0] = 0x023d; /* P_adp_regul_cnt 0.07 */
1118 est[1] = 0xffdf; /* P_adp_noise_cnt -0.004 */
1119 est[2] = 0x00a4; /* P_adp_regul_ext 0.02 */
1120 est[3] = 0xfff0; /* P_adp_noise_ext -0.002 */
1121 break;
1122 default:
1123 est[0] = 0x099a; /* P_adp_regul_cnt 0.3 */
1124 est[1] = 0xffae; /* P_adp_noise_cnt -0.01 */
1125 est[2] = 0x0333; /* P_adp_regul_ext 0.1 */
1126 est[3] = 0xfff8; /* P_adp_noise_ext -0.002 */
1127 break;
1128 }
1129 for (value = 0; value < 4; value++)
1130 dib7000p_write_word(state, 187 + value, est[value]);
1131 }
1132
1133 static int dib7000p_autosearch_start(struct dvb_frontend *demod)
1134 {
1135 struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
1136 struct dib7000p_state *state = demod->demodulator_priv;
1137 struct dtv_frontend_properties schan;
1138 u32 value, factor;
1139 u32 internal = dib7000p_get_internal_freq(state);
1140
1141 schan = *ch;
1142 schan.modulation = QAM_64;
1143 schan.guard_interval = GUARD_INTERVAL_1_32;
1144 schan.transmission_mode = TRANSMISSION_MODE_8K;
1145 schan.code_rate_HP = FEC_2_3;
1146 schan.code_rate_LP = FEC_3_4;
1147 schan.hierarchy = 0;
1148
1149 dib7000p_set_channel(state, &schan, 7);
1150
1151 factor = BANDWIDTH_TO_KHZ(ch->bandwidth_hz);
1152 if (factor >= 5000) {
1153 if (state->version == SOC7090)
1154 factor = 2;
1155 else
1156 factor = 1;
1157 } else
1158 factor = 6;
1159
1160 value = 30 * internal * factor;
1161 dib7000p_write_word(state, 6, (u16) ((value >> 16) & 0xffff));
1162 dib7000p_write_word(state, 7, (u16) (value & 0xffff));
1163 value = 100 * internal * factor;
1164 dib7000p_write_word(state, 8, (u16) ((value >> 16) & 0xffff));
1165 dib7000p_write_word(state, 9, (u16) (value & 0xffff));
1166 value = 500 * internal * factor;
1167 dib7000p_write_word(state, 10, (u16) ((value >> 16) & 0xffff));
1168 dib7000p_write_word(state, 11, (u16) (value & 0xffff));
1169
1170 value = dib7000p_read_word(state, 0);
1171 dib7000p_write_word(state, 0, (u16) ((1 << 9) | value));
1172 dib7000p_read_word(state, 1284);
1173 dib7000p_write_word(state, 0, (u16) value);
1174
1175 return 0;
1176 }
1177
1178 static int dib7000p_autosearch_is_irq(struct dvb_frontend *demod)
1179 {
1180 struct dib7000p_state *state = demod->demodulator_priv;
1181 u16 irq_pending = dib7000p_read_word(state, 1284);
1182
1183 if (irq_pending & 0x1)
1184 return 1;
1185
1186 if (irq_pending & 0x2)
1187 return 2;
1188
1189 return 0;
1190 }
1191
1192 static void dib7000p_spur_protect(struct dib7000p_state *state, u32 rf_khz, u32 bw)
1193 {
1194 static s16 notch[] = { 16143, 14402, 12238, 9713, 6902, 3888, 759, -2392 };
1195 static u8 sine[] = { 0, 2, 3, 5, 6, 8, 9, 11, 13, 14, 16, 17, 19, 20, 22,
1196 24, 25, 27, 28, 30, 31, 33, 34, 36, 38, 39, 41, 42, 44, 45, 47, 48, 50, 51,
1197 53, 55, 56, 58, 59, 61, 62, 64, 65, 67, 68, 70, 71, 73, 74, 76, 77, 79, 80,
1198 82, 83, 85, 86, 88, 89, 91, 92, 94, 95, 97, 98, 99, 101, 102, 104, 105,
1199 107, 108, 109, 111, 112, 114, 115, 117, 118, 119, 121, 122, 123, 125, 126,
1200 128, 129, 130, 132, 133, 134, 136, 137, 138, 140, 141, 142, 144, 145, 146,
1201 147, 149, 150, 151, 152, 154, 155, 156, 157, 159, 160, 161, 162, 164, 165,
1202 166, 167, 168, 170, 171, 172, 173, 174, 175, 177, 178, 179, 180, 181, 182,
1203 183, 184, 185, 186, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
1204 199, 200, 201, 202, 203, 204, 205, 206, 207, 207, 208, 209, 210, 211, 212,
1205 213, 214, 215, 215, 216, 217, 218, 219, 220, 220, 221, 222, 223, 224, 224,
1206 225, 226, 227, 227, 228, 229, 229, 230, 231, 231, 232, 233, 233, 234, 235,
1207 235, 236, 237, 237, 238, 238, 239, 239, 240, 241, 241, 242, 242, 243, 243,
1208 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 248, 249, 249, 249,
1209 250, 250, 250, 251, 251, 251, 252, 252, 252, 252, 253, 253, 253, 253, 254,
1210 254, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
1211 255, 255, 255, 255, 255, 255
1212 };
1213
1214 u32 xtal = state->cfg.bw->xtal_hz / 1000;
1215 int f_rel = DIV_ROUND_CLOSEST(rf_khz, xtal) * xtal - rf_khz;
1216 int k;
1217 int coef_re[8], coef_im[8];
1218 int bw_khz = bw;
1219 u32 pha;
1220
1221 dprintk("relative position of the Spur: %dk (RF: %dk, XTAL: %dk)\n", f_rel, rf_khz, xtal);
1222
1223 if (f_rel < -bw_khz / 2 || f_rel > bw_khz / 2)
1224 return;
1225
1226 bw_khz /= 100;
1227
1228 dib7000p_write_word(state, 142, 0x0610);
1229
1230 for (k = 0; k < 8; k++) {
1231 pha = ((f_rel * (k + 1) * 112 * 80 / bw_khz) / 1000) & 0x3ff;
1232
1233 if (pha == 0) {
1234 coef_re[k] = 256;
1235 coef_im[k] = 0;
1236 } else if (pha < 256) {
1237 coef_re[k] = sine[256 - (pha & 0xff)];
1238 coef_im[k] = sine[pha & 0xff];
1239 } else if (pha == 256) {
1240 coef_re[k] = 0;
1241 coef_im[k] = 256;
1242 } else if (pha < 512) {
1243 coef_re[k] = -sine[pha & 0xff];
1244 coef_im[k] = sine[256 - (pha & 0xff)];
1245 } else if (pha == 512) {
1246 coef_re[k] = -256;
1247 coef_im[k] = 0;
1248 } else if (pha < 768) {
1249 coef_re[k] = -sine[256 - (pha & 0xff)];
1250 coef_im[k] = -sine[pha & 0xff];
1251 } else if (pha == 768) {
1252 coef_re[k] = 0;
1253 coef_im[k] = -256;
1254 } else {
1255 coef_re[k] = sine[pha & 0xff];
1256 coef_im[k] = -sine[256 - (pha & 0xff)];
1257 }
1258
1259 coef_re[k] *= notch[k];
1260 coef_re[k] += (1 << 14);
1261 if (coef_re[k] >= (1 << 24))
1262 coef_re[k] = (1 << 24) - 1;
1263 coef_re[k] /= (1 << 15);
1264
1265 coef_im[k] *= notch[k];
1266 coef_im[k] += (1 << 14);
1267 if (coef_im[k] >= (1 << 24))
1268 coef_im[k] = (1 << 24) - 1;
1269 coef_im[k] /= (1 << 15);
1270
1271 dprintk("PALF COEF: %d re: %d im: %d\n", k, coef_re[k], coef_im[k]);
1272
1273 dib7000p_write_word(state, 143, (0 << 14) | (k << 10) | (coef_re[k] & 0x3ff));
1274 dib7000p_write_word(state, 144, coef_im[k] & 0x3ff);
1275 dib7000p_write_word(state, 143, (1 << 14) | (k << 10) | (coef_re[k] & 0x3ff));
1276 }
1277 dib7000p_write_word(state, 143, 0);
1278 }
1279
1280 static int dib7000p_tune(struct dvb_frontend *demod)
1281 {
1282 struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
1283 struct dib7000p_state *state = demod->demodulator_priv;
1284 u16 tmp = 0;
1285
1286 if (ch != NULL)
1287 dib7000p_set_channel(state, ch, 0);
1288 else
1289 return -EINVAL;
1290
1291 // restart demod
1292 dib7000p_write_word(state, 770, 0x4000);
1293 dib7000p_write_word(state, 770, 0x0000);
1294 msleep(45);
1295
1296 /* P_ctrl_inh_cor=0, P_ctrl_alpha_cor=4, P_ctrl_inh_isi=0, P_ctrl_alpha_isi=3, P_ctrl_inh_cor4=1, P_ctrl_alpha_cor4=3 */
1297 tmp = (0 << 14) | (4 << 10) | (0 << 9) | (3 << 5) | (1 << 4) | (0x3);
1298 if (state->sfn_workaround_active) {
1299 dprintk("SFN workaround is active\n");
1300 tmp |= (1 << 9);
1301 dib7000p_write_word(state, 166, 0x4000);
1302 } else {
1303 dib7000p_write_word(state, 166, 0x0000);
1304 }
1305 dib7000p_write_word(state, 29, tmp);
1306
1307 // never achieved a lock with that bandwidth so far - wait for osc-freq to update
1308 if (state->timf == 0)
1309 msleep(200);
1310
1311 /* offset loop parameters */
1312
1313 /* P_timf_alpha, P_corm_alpha=6, P_corm_thres=0x80 */
1314 tmp = (6 << 8) | 0x80;
1315 switch (ch->transmission_mode) {
1316 case TRANSMISSION_MODE_2K:
1317 tmp |= (2 << 12);
1318 break;
1319 case TRANSMISSION_MODE_4K:
1320 tmp |= (3 << 12);
1321 break;
1322 default:
1323 case TRANSMISSION_MODE_8K:
1324 tmp |= (4 << 12);
1325 break;
1326 }
1327 dib7000p_write_word(state, 26, tmp); /* timf_a(6xxx) */
1328
1329 /* P_ctrl_freeze_pha_shift=0, P_ctrl_pha_off_max */
1330 tmp = (0 << 4);
1331 switch (ch->transmission_mode) {
1332 case TRANSMISSION_MODE_2K:
1333 tmp |= 0x6;
1334 break;
1335 case TRANSMISSION_MODE_4K:
1336 tmp |= 0x7;
1337 break;
1338 default:
1339 case TRANSMISSION_MODE_8K:
1340 tmp |= 0x8;
1341 break;
1342 }
1343 dib7000p_write_word(state, 32, tmp);
1344
1345 /* P_ctrl_sfreq_inh=0, P_ctrl_sfreq_step */
1346 tmp = (0 << 4);
1347 switch (ch->transmission_mode) {
1348 case TRANSMISSION_MODE_2K:
1349 tmp |= 0x6;
1350 break;
1351 case TRANSMISSION_MODE_4K:
1352 tmp |= 0x7;
1353 break;
1354 default:
1355 case TRANSMISSION_MODE_8K:
1356 tmp |= 0x8;
1357 break;
1358 }
1359 dib7000p_write_word(state, 33, tmp);
1360
1361 tmp = dib7000p_read_word(state, 509);
1362 if (!((tmp >> 6) & 0x1)) {
1363 /* restart the fec */
1364 tmp = dib7000p_read_word(state, 771);
1365 dib7000p_write_word(state, 771, tmp | (1 << 1));
1366 dib7000p_write_word(state, 771, tmp);
1367 msleep(40);
1368 tmp = dib7000p_read_word(state, 509);
1369 }
1370 // we achieved a lock - it's time to update the osc freq
1371 if ((tmp >> 6) & 0x1) {
1372 dib7000p_update_timf(state);
1373 /* P_timf_alpha += 2 */
1374 tmp = dib7000p_read_word(state, 26);
1375 dib7000p_write_word(state, 26, (tmp & ~(0xf << 12)) | ((((tmp >> 12) & 0xf) + 5) << 12));
1376 }
1377
1378 if (state->cfg.spur_protect)
1379 dib7000p_spur_protect(state, ch->frequency / 1000, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
1380
1381 dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
1382
1383 dib7000p_reset_stats(demod);
1384
1385 return 0;
1386 }
1387
1388 static int dib7000p_wakeup(struct dvb_frontend *demod)
1389 {
1390 struct dib7000p_state *state = demod->demodulator_priv;
1391 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
1392 dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_ON);
1393 if (state->version == SOC7090)
1394 dib7000p_sad_calib(state);
1395 return 0;
1396 }
1397
1398 static int dib7000p_sleep(struct dvb_frontend *demod)
1399 {
1400 struct dib7000p_state *state = demod->demodulator_priv;
1401 if (state->version == SOC7090)
1402 return dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
1403 return dib7000p_set_output_mode(state, OUTMODE_HIGH_Z) | dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
1404 }
1405
1406 static int dib7000p_identify(struct dib7000p_state *st)
1407 {
1408 u16 value;
1409 dprintk("checking demod on I2C address: %d (%x)\n", st->i2c_addr, st->i2c_addr);
1410
1411 if ((value = dib7000p_read_word(st, 768)) != 0x01b3) {
1412 dprintk("wrong Vendor ID (read=0x%x)\n", value);
1413 return -EREMOTEIO;
1414 }
1415
1416 if ((value = dib7000p_read_word(st, 769)) != 0x4000) {
1417 dprintk("wrong Device ID (%x)\n", value);
1418 return -EREMOTEIO;
1419 }
1420
1421 return 0;
1422 }
1423
1424 static int dib7000p_get_frontend(struct dvb_frontend *fe,
1425 struct dtv_frontend_properties *fep)
1426 {
1427 struct dib7000p_state *state = fe->demodulator_priv;
1428 u16 tps = dib7000p_read_word(state, 463);
1429
1430 fep->inversion = INVERSION_AUTO;
1431
1432 fep->bandwidth_hz = BANDWIDTH_TO_HZ(state->current_bandwidth);
1433
1434 switch ((tps >> 8) & 0x3) {
1435 case 0:
1436 fep->transmission_mode = TRANSMISSION_MODE_2K;
1437 break;
1438 case 1:
1439 fep->transmission_mode = TRANSMISSION_MODE_8K;
1440 break;
1441 /* case 2: fep->transmission_mode = TRANSMISSION_MODE_4K; break; */
1442 }
1443
1444 switch (tps & 0x3) {
1445 case 0:
1446 fep->guard_interval = GUARD_INTERVAL_1_32;
1447 break;
1448 case 1:
1449 fep->guard_interval = GUARD_INTERVAL_1_16;
1450 break;
1451 case 2:
1452 fep->guard_interval = GUARD_INTERVAL_1_8;
1453 break;
1454 case 3:
1455 fep->guard_interval = GUARD_INTERVAL_1_4;
1456 break;
1457 }
1458
1459 switch ((tps >> 14) & 0x3) {
1460 case 0:
1461 fep->modulation = QPSK;
1462 break;
1463 case 1:
1464 fep->modulation = QAM_16;
1465 break;
1466 case 2:
1467 default:
1468 fep->modulation = QAM_64;
1469 break;
1470 }
1471
1472 /* as long as the frontend_param structure is fixed for hierarchical transmission I refuse to use it */
1473 /* (tps >> 13) & 0x1 == hrch is used, (tps >> 10) & 0x7 == alpha */
1474
1475 fep->hierarchy = HIERARCHY_NONE;
1476 switch ((tps >> 5) & 0x7) {
1477 case 1:
1478 fep->code_rate_HP = FEC_1_2;
1479 break;
1480 case 2:
1481 fep->code_rate_HP = FEC_2_3;
1482 break;
1483 case 3:
1484 fep->code_rate_HP = FEC_3_4;
1485 break;
1486 case 5:
1487 fep->code_rate_HP = FEC_5_6;
1488 break;
1489 case 7:
1490 default:
1491 fep->code_rate_HP = FEC_7_8;
1492 break;
1493
1494 }
1495
1496 switch ((tps >> 2) & 0x7) {
1497 case 1:
1498 fep->code_rate_LP = FEC_1_2;
1499 break;
1500 case 2:
1501 fep->code_rate_LP = FEC_2_3;
1502 break;
1503 case 3:
1504 fep->code_rate_LP = FEC_3_4;
1505 break;
1506 case 5:
1507 fep->code_rate_LP = FEC_5_6;
1508 break;
1509 case 7:
1510 default:
1511 fep->code_rate_LP = FEC_7_8;
1512 break;
1513 }
1514
1515 /* native interleaver: (dib7000p_read_word(state, 464) >> 5) & 0x1 */
1516
1517 return 0;
1518 }
1519
1520 static int dib7000p_set_frontend(struct dvb_frontend *fe)
1521 {
1522 struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
1523 struct dib7000p_state *state = fe->demodulator_priv;
1524 int time, ret;
1525
1526 if (state->version == SOC7090)
1527 dib7090_set_diversity_in(fe, 0);
1528 else
1529 dib7000p_set_output_mode(state, OUTMODE_HIGH_Z);
1530
1531 /* maybe the parameter has been changed */
1532 state->sfn_workaround_active = buggy_sfn_workaround;
1533
1534 if (fe->ops.tuner_ops.set_params)
1535 fe->ops.tuner_ops.set_params(fe);
1536
1537 /* start up the AGC */
1538 state->agc_state = 0;
1539 do {
1540 time = dib7000p_agc_startup(fe);
1541 if (time != -1)
1542 msleep(time);
1543 } while (time != -1);
1544
1545 if (fep->transmission_mode == TRANSMISSION_MODE_AUTO ||
1546 fep->guard_interval == GUARD_INTERVAL_AUTO || fep->modulation == QAM_AUTO || fep->code_rate_HP == FEC_AUTO) {
1547 int i = 800, found;
1548
1549 dib7000p_autosearch_start(fe);
1550 do {
1551 msleep(1);
1552 found = dib7000p_autosearch_is_irq(fe);
1553 } while (found == 0 && i--);
1554
1555 dprintk("autosearch returns: %d\n", found);
1556 if (found == 0 || found == 1)
1557 return 0;
1558
1559 dib7000p_get_frontend(fe, fep);
1560 }
1561
1562 ret = dib7000p_tune(fe);
1563
1564 /* make this a config parameter */
1565 if (state->version == SOC7090) {
1566 dib7090_set_output_mode(fe, state->cfg.output_mode);
1567 if (state->cfg.enMpegOutput == 0) {
1568 dib7090_setDibTxMux(state, MPEG_ON_DIBTX);
1569 dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
1570 }
1571 } else
1572 dib7000p_set_output_mode(state, state->cfg.output_mode);
1573
1574 return ret;
1575 }
1576
1577 static int dib7000p_get_stats(struct dvb_frontend *fe, enum fe_status stat);
1578
1579 static int dib7000p_read_status(struct dvb_frontend *fe, enum fe_status *stat)
1580 {
1581 struct dib7000p_state *state = fe->demodulator_priv;
1582 u16 lock = dib7000p_read_word(state, 509);
1583
1584 *stat = 0;
1585
1586 if (lock & 0x8000)
1587 *stat |= FE_HAS_SIGNAL;
1588 if (lock & 0x3000)
1589 *stat |= FE_HAS_CARRIER;
1590 if (lock & 0x0100)
1591 *stat |= FE_HAS_VITERBI;
1592 if (lock & 0x0010)
1593 *stat |= FE_HAS_SYNC;
1594 if ((lock & 0x0038) == 0x38)
1595 *stat |= FE_HAS_LOCK;
1596
1597 dib7000p_get_stats(fe, *stat);
1598
1599 return 0;
1600 }
1601
1602 static int dib7000p_read_ber(struct dvb_frontend *fe, u32 * ber)
1603 {
1604 struct dib7000p_state *state = fe->demodulator_priv;
1605 *ber = (dib7000p_read_word(state, 500) << 16) | dib7000p_read_word(state, 501);
1606 return 0;
1607 }
1608
1609 static int dib7000p_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
1610 {
1611 struct dib7000p_state *state = fe->demodulator_priv;
1612 *unc = dib7000p_read_word(state, 506);
1613 return 0;
1614 }
1615
1616 static int dib7000p_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
1617 {
1618 struct dib7000p_state *state = fe->demodulator_priv;
1619 u16 val = dib7000p_read_word(state, 394);
1620 *strength = 65535 - val;
1621 return 0;
1622 }
1623
1624 static u32 dib7000p_get_snr(struct dvb_frontend *fe)
1625 {
1626 struct dib7000p_state *state = fe->demodulator_priv;
1627 u16 val;
1628 s32 signal_mant, signal_exp, noise_mant, noise_exp;
1629 u32 result = 0;
1630
1631 val = dib7000p_read_word(state, 479);
1632 noise_mant = (val >> 4) & 0xff;
1633 noise_exp = ((val & 0xf) << 2);
1634 val = dib7000p_read_word(state, 480);
1635 noise_exp += ((val >> 14) & 0x3);
1636 if ((noise_exp & 0x20) != 0)
1637 noise_exp -= 0x40;
1638
1639 signal_mant = (val >> 6) & 0xFF;
1640 signal_exp = (val & 0x3F);
1641 if ((signal_exp & 0x20) != 0)
1642 signal_exp -= 0x40;
1643
1644 if (signal_mant != 0)
1645 result = intlog10(2) * 10 * signal_exp + 10 * intlog10(signal_mant);
1646 else
1647 result = intlog10(2) * 10 * signal_exp - 100;
1648
1649 if (noise_mant != 0)
1650 result -= intlog10(2) * 10 * noise_exp + 10 * intlog10(noise_mant);
1651 else
1652 result -= intlog10(2) * 10 * noise_exp - 100;
1653
1654 return result;
1655 }
1656
1657 static int dib7000p_read_snr(struct dvb_frontend *fe, u16 *snr)
1658 {
1659 u32 result;
1660
1661 result = dib7000p_get_snr(fe);
1662
1663 *snr = result / ((1 << 24) / 10);
1664 return 0;
1665 }
1666
1667 static void dib7000p_reset_stats(struct dvb_frontend *demod)
1668 {
1669 struct dib7000p_state *state = demod->demodulator_priv;
1670 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1671 u32 ucb;
1672
1673 memset(&c->strength, 0, sizeof(c->strength));
1674 memset(&c->cnr, 0, sizeof(c->cnr));
1675 memset(&c->post_bit_error, 0, sizeof(c->post_bit_error));
1676 memset(&c->post_bit_count, 0, sizeof(c->post_bit_count));
1677 memset(&c->block_error, 0, sizeof(c->block_error));
1678
1679 c->strength.len = 1;
1680 c->cnr.len = 1;
1681 c->block_error.len = 1;
1682 c->block_count.len = 1;
1683 c->post_bit_error.len = 1;
1684 c->post_bit_count.len = 1;
1685
1686 c->strength.stat[0].scale = FE_SCALE_DECIBEL;
1687 c->strength.stat[0].uvalue = 0;
1688
1689 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1690 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1691 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1692 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1693 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1694
1695 dib7000p_read_unc_blocks(demod, &ucb);
1696
1697 state->old_ucb = ucb;
1698 state->ber_jiffies_stats = 0;
1699 state->per_jiffies_stats = 0;
1700 }
1701
1702 struct linear_segments {
1703 unsigned x;
1704 signed y;
1705 };
1706
1707 /*
1708 * Table to estimate signal strength in dBm.
1709 * This table should be empirically determinated by measuring the signal
1710 * strength generated by a RF generator directly connected into
1711 * a device.
1712 * This table was determinated by measuring the signal strength generated
1713 * by a DTA-2111 RF generator directly connected into a dib7000p device
1714 * (a Hauppauge Nova-TD stick), using a good quality 3 meters length
1715 * RC6 cable and good RC6 connectors, connected directly to antenna 1.
1716 * As the minimum output power of DTA-2111 is -31dBm, a 16 dBm attenuator
1717 * were used, for the lower power values.
1718 * The real value can actually be on other devices, or even at the
1719 * second antena input, depending on several factors, like if LNA
1720 * is enabled or not, if diversity is enabled, type of connectors, etc.
1721 * Yet, it is better to use this measure in dB than a random non-linear
1722 * percentage value, especially for antenna adjustments.
1723 * On my tests, the precision of the measure using this table is about
1724 * 0.5 dB, with sounds reasonable enough to adjust antennas.
1725 */
1726 #define DB_OFFSET 131000
1727
1728 static struct linear_segments strength_to_db_table[] = {
1729 { 63630, DB_OFFSET - 20500},
1730 { 62273, DB_OFFSET - 21000},
1731 { 60162, DB_OFFSET - 22000},
1732 { 58730, DB_OFFSET - 23000},
1733 { 58294, DB_OFFSET - 24000},
1734 { 57778, DB_OFFSET - 25000},
1735 { 57320, DB_OFFSET - 26000},
1736 { 56779, DB_OFFSET - 27000},
1737 { 56293, DB_OFFSET - 28000},
1738 { 55724, DB_OFFSET - 29000},
1739 { 55145, DB_OFFSET - 30000},
1740 { 54680, DB_OFFSET - 31000},
1741 { 54293, DB_OFFSET - 32000},
1742 { 53813, DB_OFFSET - 33000},
1743 { 53427, DB_OFFSET - 34000},
1744 { 52981, DB_OFFSET - 35000},
1745
1746 { 52636, DB_OFFSET - 36000},
1747 { 52014, DB_OFFSET - 37000},
1748 { 51674, DB_OFFSET - 38000},
1749 { 50692, DB_OFFSET - 39000},
1750 { 49824, DB_OFFSET - 40000},
1751 { 49052, DB_OFFSET - 41000},
1752 { 48436, DB_OFFSET - 42000},
1753 { 47836, DB_OFFSET - 43000},
1754 { 47368, DB_OFFSET - 44000},
1755 { 46468, DB_OFFSET - 45000},
1756 { 45597, DB_OFFSET - 46000},
1757 { 44586, DB_OFFSET - 47000},
1758 { 43667, DB_OFFSET - 48000},
1759 { 42673, DB_OFFSET - 49000},
1760 { 41816, DB_OFFSET - 50000},
1761 { 40876, DB_OFFSET - 51000},
1762 { 0, 0},
1763 };
1764
1765 static u32 interpolate_value(u32 value, struct linear_segments *segments,
1766 unsigned len)
1767 {
1768 u64 tmp64;
1769 u32 dx;
1770 s32 dy;
1771 int i, ret;
1772
1773 if (value >= segments[0].x)
1774 return segments[0].y;
1775 if (value < segments[len-1].x)
1776 return segments[len-1].y;
1777
1778 for (i = 1; i < len - 1; i++) {
1779 /* If value is identical, no need to interpolate */
1780 if (value == segments[i].x)
1781 return segments[i].y;
1782 if (value > segments[i].x)
1783 break;
1784 }
1785
1786 /* Linear interpolation between the two (x,y) points */
1787 dy = segments[i - 1].y - segments[i].y;
1788 dx = segments[i - 1].x - segments[i].x;
1789
1790 tmp64 = value - segments[i].x;
1791 tmp64 *= dy;
1792 do_div(tmp64, dx);
1793 ret = segments[i].y + tmp64;
1794
1795 return ret;
1796 }
1797
1798 /* FIXME: may require changes - this one was borrowed from dib8000 */
1799 static u32 dib7000p_get_time_us(struct dvb_frontend *demod)
1800 {
1801 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1802 u64 time_us, tmp64;
1803 u32 tmp, denom;
1804 int guard, rate_num, rate_denum = 1, bits_per_symbol;
1805 int interleaving = 0, fft_div;
1806
1807 switch (c->guard_interval) {
1808 case GUARD_INTERVAL_1_4:
1809 guard = 4;
1810 break;
1811 case GUARD_INTERVAL_1_8:
1812 guard = 8;
1813 break;
1814 case GUARD_INTERVAL_1_16:
1815 guard = 16;
1816 break;
1817 default:
1818 case GUARD_INTERVAL_1_32:
1819 guard = 32;
1820 break;
1821 }
1822
1823 switch (c->transmission_mode) {
1824 case TRANSMISSION_MODE_2K:
1825 fft_div = 4;
1826 break;
1827 case TRANSMISSION_MODE_4K:
1828 fft_div = 2;
1829 break;
1830 default:
1831 case TRANSMISSION_MODE_8K:
1832 fft_div = 1;
1833 break;
1834 }
1835
1836 switch (c->modulation) {
1837 case DQPSK:
1838 case QPSK:
1839 bits_per_symbol = 2;
1840 break;
1841 case QAM_16:
1842 bits_per_symbol = 4;
1843 break;
1844 default:
1845 case QAM_64:
1846 bits_per_symbol = 6;
1847 break;
1848 }
1849
1850 switch ((c->hierarchy == 0 || 1 == 1) ? c->code_rate_HP : c->code_rate_LP) {
1851 case FEC_1_2:
1852 rate_num = 1;
1853 rate_denum = 2;
1854 break;
1855 case FEC_2_3:
1856 rate_num = 2;
1857 rate_denum = 3;
1858 break;
1859 case FEC_3_4:
1860 rate_num = 3;
1861 rate_denum = 4;
1862 break;
1863 case FEC_5_6:
1864 rate_num = 5;
1865 rate_denum = 6;
1866 break;
1867 default:
1868 case FEC_7_8:
1869 rate_num = 7;
1870 rate_denum = 8;
1871 break;
1872 }
1873
1874 interleaving = interleaving;
1875
1876 denom = bits_per_symbol * rate_num * fft_div * 384;
1877
1878 /* If calculus gets wrong, wait for 1s for the next stats */
1879 if (!denom)
1880 return 0;
1881
1882 /* Estimate the period for the total bit rate */
1883 time_us = rate_denum * (1008 * 1562500L);
1884 tmp64 = time_us;
1885 do_div(tmp64, guard);
1886 time_us = time_us + tmp64;
1887 time_us += denom / 2;
1888 do_div(time_us, denom);
1889
1890 tmp = 1008 * 96 * interleaving;
1891 time_us += tmp + tmp / guard;
1892
1893 return time_us;
1894 }
1895
1896 static int dib7000p_get_stats(struct dvb_frontend *demod, enum fe_status stat)
1897 {
1898 struct dib7000p_state *state = demod->demodulator_priv;
1899 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1900 int show_per_stats = 0;
1901 u32 time_us = 0, val, snr;
1902 u64 blocks, ucb;
1903 s32 db;
1904 u16 strength;
1905
1906 /* Get Signal strength */
1907 dib7000p_read_signal_strength(demod, &strength);
1908 val = strength;
1909 db = interpolate_value(val,
1910 strength_to_db_table,
1911 ARRAY_SIZE(strength_to_db_table)) - DB_OFFSET;
1912 c->strength.stat[0].svalue = db;
1913
1914 /* UCB/BER/CNR measures require lock */
1915 if (!(stat & FE_HAS_LOCK)) {
1916 c->cnr.len = 1;
1917 c->block_count.len = 1;
1918 c->block_error.len = 1;
1919 c->post_bit_error.len = 1;
1920 c->post_bit_count.len = 1;
1921 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1922 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1923 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1924 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1925 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1926 return 0;
1927 }
1928
1929 /* Check if time for stats was elapsed */
1930 if (time_after(jiffies, state->per_jiffies_stats)) {
1931 state->per_jiffies_stats = jiffies + msecs_to_jiffies(1000);
1932
1933 /* Get SNR */
1934 snr = dib7000p_get_snr(demod);
1935 if (snr)
1936 snr = (1000L * snr) >> 24;
1937 else
1938 snr = 0;
1939 c->cnr.stat[0].svalue = snr;
1940 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
1941
1942 /* Get UCB measures */
1943 dib7000p_read_unc_blocks(demod, &val);
1944 ucb = val - state->old_ucb;
1945 if (val < state->old_ucb)
1946 ucb += 0x100000000LL;
1947
1948 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
1949 c->block_error.stat[0].uvalue = ucb;
1950
1951 /* Estimate the number of packets based on bitrate */
1952 if (!time_us)
1953 time_us = dib7000p_get_time_us(demod);
1954
1955 if (time_us) {
1956 blocks = 1250000ULL * 1000000ULL;
1957 do_div(blocks, time_us * 8 * 204);
1958 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
1959 c->block_count.stat[0].uvalue += blocks;
1960 }
1961
1962 show_per_stats = 1;
1963 }
1964
1965 /* Get post-BER measures */
1966 if (time_after(jiffies, state->ber_jiffies_stats)) {
1967 time_us = dib7000p_get_time_us(demod);
1968 state->ber_jiffies_stats = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
1969
1970 dprintk("Next all layers stats available in %u us.\n", time_us);
1971
1972 dib7000p_read_ber(demod, &val);
1973 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
1974 c->post_bit_error.stat[0].uvalue += val;
1975
1976 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
1977 c->post_bit_count.stat[0].uvalue += 100000000;
1978 }
1979
1980 /* Get PER measures */
1981 if (show_per_stats) {
1982 dib7000p_read_unc_blocks(demod, &val);
1983
1984 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
1985 c->block_error.stat[0].uvalue += val;
1986
1987 time_us = dib7000p_get_time_us(demod);
1988 if (time_us) {
1989 blocks = 1250000ULL * 1000000ULL;
1990 do_div(blocks, time_us * 8 * 204);
1991 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
1992 c->block_count.stat[0].uvalue += blocks;
1993 }
1994 }
1995 return 0;
1996 }
1997
1998 static int dib7000p_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
1999 {
2000 tune->min_delay_ms = 1000;
2001 return 0;
2002 }
2003
2004 static void dib7000p_release(struct dvb_frontend *demod)
2005 {
2006 struct dib7000p_state *st = demod->demodulator_priv;
2007 dibx000_exit_i2c_master(&st->i2c_master);
2008 i2c_del_adapter(&st->dib7090_tuner_adap);
2009 kfree(st);
2010 }
2011
2012 static int dib7000pc_detection(struct i2c_adapter *i2c_adap)
2013 {
2014 u8 *tx, *rx;
2015 struct i2c_msg msg[2] = {
2016 {.addr = 18 >> 1, .flags = 0, .len = 2},
2017 {.addr = 18 >> 1, .flags = I2C_M_RD, .len = 2},
2018 };
2019 int ret = 0;
2020
2021 tx = kzalloc(2*sizeof(u8), GFP_KERNEL);
2022 if (!tx)
2023 return -ENOMEM;
2024 rx = kzalloc(2*sizeof(u8), GFP_KERNEL);
2025 if (!rx) {
2026 ret = -ENOMEM;
2027 goto rx_memory_error;
2028 }
2029
2030 msg[0].buf = tx;
2031 msg[1].buf = rx;
2032
2033 tx[0] = 0x03;
2034 tx[1] = 0x00;
2035
2036 if (i2c_transfer(i2c_adap, msg, 2) == 2)
2037 if (rx[0] == 0x01 && rx[1] == 0xb3) {
2038 dprintk("-D- DiB7000PC detected\n");
2039 return 1;
2040 }
2041
2042 msg[0].addr = msg[1].addr = 0x40;
2043
2044 if (i2c_transfer(i2c_adap, msg, 2) == 2)
2045 if (rx[0] == 0x01 && rx[1] == 0xb3) {
2046 dprintk("-D- DiB7000PC detected\n");
2047 return 1;
2048 }
2049
2050 dprintk("-D- DiB7000PC not detected\n");
2051
2052 kfree(rx);
2053 rx_memory_error:
2054 kfree(tx);
2055 return ret;
2056 }
2057
2058 static struct i2c_adapter *dib7000p_get_i2c_master(struct dvb_frontend *demod, enum dibx000_i2c_interface intf, int gating)
2059 {
2060 struct dib7000p_state *st = demod->demodulator_priv;
2061 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
2062 }
2063
2064 static int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
2065 {
2066 struct dib7000p_state *state = fe->demodulator_priv;
2067 u16 val = dib7000p_read_word(state, 235) & 0xffef;
2068 val |= (onoff & 0x1) << 4;
2069 dprintk("PID filter enabled %d\n", onoff);
2070 return dib7000p_write_word(state, 235, val);
2071 }
2072
2073 static int dib7000p_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
2074 {
2075 struct dib7000p_state *state = fe->demodulator_priv;
2076 dprintk("PID filter: index %x, PID %d, OnOff %d\n", id, pid, onoff);
2077 return dib7000p_write_word(state, 241 + id, onoff ? (1 << 13) | pid : 0);
2078 }
2079
2080 static int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[])
2081 {
2082 struct dib7000p_state *dpst;
2083 int k = 0;
2084 u8 new_addr = 0;
2085
2086 dpst = kzalloc(sizeof(struct dib7000p_state), GFP_KERNEL);
2087 if (!dpst)
2088 return -ENOMEM;
2089
2090 dpst->i2c_adap = i2c;
2091 mutex_init(&dpst->i2c_buffer_lock);
2092
2093 for (k = no_of_demods - 1; k >= 0; k--) {
2094 dpst->cfg = cfg[k];
2095
2096 /* designated i2c address */
2097 if (cfg[k].default_i2c_addr != 0)
2098 new_addr = cfg[k].default_i2c_addr + (k << 1);
2099 else
2100 new_addr = (0x40 + k) << 1;
2101 dpst->i2c_addr = new_addr;
2102 dib7000p_write_word(dpst, 1287, 0x0003); /* sram lead in, rdy */
2103 if (dib7000p_identify(dpst) != 0) {
2104 dpst->i2c_addr = default_addr;
2105 dib7000p_write_word(dpst, 1287, 0x0003); /* sram lead in, rdy */
2106 if (dib7000p_identify(dpst) != 0) {
2107 dprintk("DiB7000P #%d: not identified\n", k);
2108 kfree(dpst);
2109 return -EIO;
2110 }
2111 }
2112
2113 /* start diversity to pull_down div_str - just for i2c-enumeration */
2114 dib7000p_set_output_mode(dpst, OUTMODE_DIVERSITY);
2115
2116 /* set new i2c address and force divstart */
2117 dib7000p_write_word(dpst, 1285, (new_addr << 2) | 0x2);
2118
2119 dprintk("IC %d initialized (to i2c_address 0x%x)\n", k, new_addr);
2120 }
2121
2122 for (k = 0; k < no_of_demods; k++) {
2123 dpst->cfg = cfg[k];
2124 if (cfg[k].default_i2c_addr != 0)
2125 dpst->i2c_addr = (cfg[k].default_i2c_addr + k) << 1;
2126 else
2127 dpst->i2c_addr = (0x40 + k) << 1;
2128
2129 // unforce divstr
2130 dib7000p_write_word(dpst, 1285, dpst->i2c_addr << 2);
2131
2132 /* deactivate div - it was just for i2c-enumeration */
2133 dib7000p_set_output_mode(dpst, OUTMODE_HIGH_Z);
2134 }
2135
2136 kfree(dpst);
2137 return 0;
2138 }
2139
2140 static const s32 lut_1000ln_mant[] = {
2141 6908, 6956, 7003, 7047, 7090, 7131, 7170, 7208, 7244, 7279, 7313, 7346, 7377, 7408, 7438, 7467, 7495, 7523, 7549, 7575, 7600
2142 };
2143
2144 static s32 dib7000p_get_adc_power(struct dvb_frontend *fe)
2145 {
2146 struct dib7000p_state *state = fe->demodulator_priv;
2147 u32 tmp_val = 0, exp = 0, mant = 0;
2148 s32 pow_i;
2149 u16 buf[2];
2150 u8 ix = 0;
2151
2152 buf[0] = dib7000p_read_word(state, 0x184);
2153 buf[1] = dib7000p_read_word(state, 0x185);
2154 pow_i = (buf[0] << 16) | buf[1];
2155 dprintk("raw pow_i = %d\n", pow_i);
2156
2157 tmp_val = pow_i;
2158 while (tmp_val >>= 1)
2159 exp++;
2160
2161 mant = (pow_i * 1000 / (1 << exp));
2162 dprintk(" mant = %d exp = %d\n", mant / 1000, exp);
2163
2164 ix = (u8) ((mant - 1000) / 100); /* index of the LUT */
2165 dprintk(" ix = %d\n", ix);
2166
2167 pow_i = (lut_1000ln_mant[ix] + 693 * (exp - 20) - 6908);
2168 pow_i = (pow_i << 8) / 1000;
2169 dprintk(" pow_i = %d\n", pow_i);
2170
2171 return pow_i;
2172 }
2173
2174 static int map_addr_to_serpar_number(struct i2c_msg *msg)
2175 {
2176 if ((msg->buf[0] <= 15))
2177 msg->buf[0] -= 1;
2178 else if (msg->buf[0] == 17)
2179 msg->buf[0] = 15;
2180 else if (msg->buf[0] == 16)
2181 msg->buf[0] = 17;
2182 else if (msg->buf[0] == 19)
2183 msg->buf[0] = 16;
2184 else if (msg->buf[0] >= 21 && msg->buf[0] <= 25)
2185 msg->buf[0] -= 3;
2186 else if (msg->buf[0] == 28)
2187 msg->buf[0] = 23;
2188 else
2189 return -EINVAL;
2190 return 0;
2191 }
2192
2193 static int w7090p_tuner_write_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2194 {
2195 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2196 u8 n_overflow = 1;
2197 u16 i = 1000;
2198 u16 serpar_num = msg[0].buf[0];
2199
2200 while (n_overflow == 1 && i) {
2201 n_overflow = (dib7000p_read_word(state, 1984) >> 1) & 0x1;
2202 i--;
2203 if (i == 0)
2204 dprintk("Tuner ITF: write busy (overflow)\n");
2205 }
2206 dib7000p_write_word(state, 1985, (1 << 6) | (serpar_num & 0x3f));
2207 dib7000p_write_word(state, 1986, (msg[0].buf[1] << 8) | msg[0].buf[2]);
2208
2209 return num;
2210 }
2211
2212 static int w7090p_tuner_read_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2213 {
2214 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2215 u8 n_overflow = 1, n_empty = 1;
2216 u16 i = 1000;
2217 u16 serpar_num = msg[0].buf[0];
2218 u16 read_word;
2219
2220 while (n_overflow == 1 && i) {
2221 n_overflow = (dib7000p_read_word(state, 1984) >> 1) & 0x1;
2222 i--;
2223 if (i == 0)
2224 dprintk("TunerITF: read busy (overflow)\n");
2225 }
2226 dib7000p_write_word(state, 1985, (0 << 6) | (serpar_num & 0x3f));
2227
2228 i = 1000;
2229 while (n_empty == 1 && i) {
2230 n_empty = dib7000p_read_word(state, 1984) & 0x1;
2231 i--;
2232 if (i == 0)
2233 dprintk("TunerITF: read busy (empty)\n");
2234 }
2235 read_word = dib7000p_read_word(state, 1987);
2236 msg[1].buf[0] = (read_word >> 8) & 0xff;
2237 msg[1].buf[1] = (read_word) & 0xff;
2238
2239 return num;
2240 }
2241
2242 static int w7090p_tuner_rw_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2243 {
2244 if (map_addr_to_serpar_number(&msg[0]) == 0) { /* else = Tuner regs to ignore : DIG_CFG, CTRL_RF_LT, PLL_CFG, PWM1_REG, ADCCLK, DIG_CFG_3; SLEEP_EN... */
2245 if (num == 1) { /* write */
2246 return w7090p_tuner_write_serpar(i2c_adap, msg, 1);
2247 } else { /* read */
2248 return w7090p_tuner_read_serpar(i2c_adap, msg, 2);
2249 }
2250 }
2251 return num;
2252 }
2253
2254 static int dib7090p_rw_on_apb(struct i2c_adapter *i2c_adap,
2255 struct i2c_msg msg[], int num, u16 apb_address)
2256 {
2257 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2258 u16 word;
2259
2260 if (num == 1) { /* write */
2261 dib7000p_write_word(state, apb_address, ((msg[0].buf[1] << 8) | (msg[0].buf[2])));
2262 } else {
2263 word = dib7000p_read_word(state, apb_address);
2264 msg[1].buf[0] = (word >> 8) & 0xff;
2265 msg[1].buf[1] = (word) & 0xff;
2266 }
2267
2268 return num;
2269 }
2270
2271 static int dib7090_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2272 {
2273 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2274
2275 u16 apb_address = 0, word;
2276 int i = 0;
2277 switch (msg[0].buf[0]) {
2278 case 0x12:
2279 apb_address = 1920;
2280 break;
2281 case 0x14:
2282 apb_address = 1921;
2283 break;
2284 case 0x24:
2285 apb_address = 1922;
2286 break;
2287 case 0x1a:
2288 apb_address = 1923;
2289 break;
2290 case 0x22:
2291 apb_address = 1924;
2292 break;
2293 case 0x33:
2294 apb_address = 1926;
2295 break;
2296 case 0x34:
2297 apb_address = 1927;
2298 break;
2299 case 0x35:
2300 apb_address = 1928;
2301 break;
2302 case 0x36:
2303 apb_address = 1929;
2304 break;
2305 case 0x37:
2306 apb_address = 1930;
2307 break;
2308 case 0x38:
2309 apb_address = 1931;
2310 break;
2311 case 0x39:
2312 apb_address = 1932;
2313 break;
2314 case 0x2a:
2315 apb_address = 1935;
2316 break;
2317 case 0x2b:
2318 apb_address = 1936;
2319 break;
2320 case 0x2c:
2321 apb_address = 1937;
2322 break;
2323 case 0x2d:
2324 apb_address = 1938;
2325 break;
2326 case 0x2e:
2327 apb_address = 1939;
2328 break;
2329 case 0x2f:
2330 apb_address = 1940;
2331 break;
2332 case 0x30:
2333 apb_address = 1941;
2334 break;
2335 case 0x31:
2336 apb_address = 1942;
2337 break;
2338 case 0x32:
2339 apb_address = 1943;
2340 break;
2341 case 0x3e:
2342 apb_address = 1944;
2343 break;
2344 case 0x3f:
2345 apb_address = 1945;
2346 break;
2347 case 0x40:
2348 apb_address = 1948;
2349 break;
2350 case 0x25:
2351 apb_address = 914;
2352 break;
2353 case 0x26:
2354 apb_address = 915;
2355 break;
2356 case 0x27:
2357 apb_address = 917;
2358 break;
2359 case 0x28:
2360 apb_address = 916;
2361 break;
2362 case 0x1d:
2363 i = ((dib7000p_read_word(state, 72) >> 12) & 0x3);
2364 word = dib7000p_read_word(state, 384 + i);
2365 msg[1].buf[0] = (word >> 8) & 0xff;
2366 msg[1].buf[1] = (word) & 0xff;
2367 return num;
2368 case 0x1f:
2369 if (num == 1) { /* write */
2370 word = (u16) ((msg[0].buf[1] << 8) | msg[0].buf[2]);
2371 word &= 0x3;
2372 word = (dib7000p_read_word(state, 72) & ~(3 << 12)) | (word << 12);
2373 dib7000p_write_word(state, 72, word); /* Set the proper input */
2374 return num;
2375 }
2376 }
2377
2378 if (apb_address != 0) /* R/W acces via APB */
2379 return dib7090p_rw_on_apb(i2c_adap, msg, num, apb_address);
2380 else /* R/W access via SERPAR */
2381 return w7090p_tuner_rw_serpar(i2c_adap, msg, num);
2382
2383 return 0;
2384 }
2385
2386 static u32 dib7000p_i2c_func(struct i2c_adapter *adapter)
2387 {
2388 return I2C_FUNC_I2C;
2389 }
2390
2391 static const struct i2c_algorithm dib7090_tuner_xfer_algo = {
2392 .master_xfer = dib7090_tuner_xfer,
2393 .functionality = dib7000p_i2c_func,
2394 };
2395
2396 static struct i2c_adapter *dib7090_get_i2c_tuner(struct dvb_frontend *fe)
2397 {
2398 struct dib7000p_state *st = fe->demodulator_priv;
2399 return &st->dib7090_tuner_adap;
2400 }
2401
2402 static int dib7090_host_bus_drive(struct dib7000p_state *state, u8 drive)
2403 {
2404 u16 reg;
2405
2406 /* drive host bus 2, 3, 4 */
2407 reg = dib7000p_read_word(state, 1798) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
2408 reg |= (drive << 12) | (drive << 6) | drive;
2409 dib7000p_write_word(state, 1798, reg);
2410
2411 /* drive host bus 5,6 */
2412 reg = dib7000p_read_word(state, 1799) & ~((0x7 << 2) | (0x7 << 8));
2413 reg |= (drive << 8) | (drive << 2);
2414 dib7000p_write_word(state, 1799, reg);
2415
2416 /* drive host bus 7, 8, 9 */
2417 reg = dib7000p_read_word(state, 1800) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
2418 reg |= (drive << 12) | (drive << 6) | drive;
2419 dib7000p_write_word(state, 1800, reg);
2420
2421 /* drive host bus 10, 11 */
2422 reg = dib7000p_read_word(state, 1801) & ~((0x7 << 2) | (0x7 << 8));
2423 reg |= (drive << 8) | (drive << 2);
2424 dib7000p_write_word(state, 1801, reg);
2425
2426 /* drive host bus 12, 13, 14 */
2427 reg = dib7000p_read_word(state, 1802) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
2428 reg |= (drive << 12) | (drive << 6) | drive;
2429 dib7000p_write_word(state, 1802, reg);
2430
2431 return 0;
2432 }
2433
2434 static u32 dib7090_calcSyncFreq(u32 P_Kin, u32 P_Kout, u32 insertExtSynchro, u32 syncSize)
2435 {
2436 u32 quantif = 3;
2437 u32 nom = (insertExtSynchro * P_Kin + syncSize);
2438 u32 denom = P_Kout;
2439 u32 syncFreq = ((nom << quantif) / denom);
2440
2441 if ((syncFreq & ((1 << quantif) - 1)) != 0)
2442 syncFreq = (syncFreq >> quantif) + 1;
2443 else
2444 syncFreq = (syncFreq >> quantif);
2445
2446 if (syncFreq != 0)
2447 syncFreq = syncFreq - 1;
2448
2449 return syncFreq;
2450 }
2451
2452 static int dib7090_cfg_DibTx(struct dib7000p_state *state, u32 P_Kin, u32 P_Kout, u32 insertExtSynchro, u32 synchroMode, u32 syncWord, u32 syncSize)
2453 {
2454 dprintk("Configure DibStream Tx\n");
2455
2456 dib7000p_write_word(state, 1615, 1);
2457 dib7000p_write_word(state, 1603, P_Kin);
2458 dib7000p_write_word(state, 1605, P_Kout);
2459 dib7000p_write_word(state, 1606, insertExtSynchro);
2460 dib7000p_write_word(state, 1608, synchroMode);
2461 dib7000p_write_word(state, 1609, (syncWord >> 16) & 0xffff);
2462 dib7000p_write_word(state, 1610, syncWord & 0xffff);
2463 dib7000p_write_word(state, 1612, syncSize);
2464 dib7000p_write_word(state, 1615, 0);
2465
2466 return 0;
2467 }
2468
2469 static int dib7090_cfg_DibRx(struct dib7000p_state *state, u32 P_Kin, u32 P_Kout, u32 synchroMode, u32 insertExtSynchro, u32 syncWord, u32 syncSize,
2470 u32 dataOutRate)
2471 {
2472 u32 syncFreq;
2473
2474 dprintk("Configure DibStream Rx\n");
2475 if ((P_Kin != 0) && (P_Kout != 0)) {
2476 syncFreq = dib7090_calcSyncFreq(P_Kin, P_Kout, insertExtSynchro, syncSize);
2477 dib7000p_write_word(state, 1542, syncFreq);
2478 }
2479 dib7000p_write_word(state, 1554, 1);
2480 dib7000p_write_word(state, 1536, P_Kin);
2481 dib7000p_write_word(state, 1537, P_Kout);
2482 dib7000p_write_word(state, 1539, synchroMode);
2483 dib7000p_write_word(state, 1540, (syncWord >> 16) & 0xffff);
2484 dib7000p_write_word(state, 1541, syncWord & 0xffff);
2485 dib7000p_write_word(state, 1543, syncSize);
2486 dib7000p_write_word(state, 1544, dataOutRate);
2487 dib7000p_write_word(state, 1554, 0);
2488
2489 return 0;
2490 }
2491
2492 static void dib7090_enMpegMux(struct dib7000p_state *state, int onoff)
2493 {
2494 u16 reg_1287 = dib7000p_read_word(state, 1287);
2495
2496 switch (onoff) {
2497 case 1:
2498 reg_1287 &= ~(1<<7);
2499 break;
2500 case 0:
2501 reg_1287 |= (1<<7);
2502 break;
2503 }
2504
2505 dib7000p_write_word(state, 1287, reg_1287);
2506 }
2507
2508 static void dib7090_configMpegMux(struct dib7000p_state *state,
2509 u16 pulseWidth, u16 enSerialMode, u16 enSerialClkDiv2)
2510 {
2511 dprintk("Enable Mpeg mux\n");
2512
2513 dib7090_enMpegMux(state, 0);
2514
2515 /* If the input mode is MPEG do not divide the serial clock */
2516 if ((enSerialMode == 1) && (state->input_mode_mpeg == 1))
2517 enSerialClkDiv2 = 0;
2518
2519 dib7000p_write_word(state, 1287, ((pulseWidth & 0x1f) << 2)
2520 | ((enSerialMode & 0x1) << 1)
2521 | (enSerialClkDiv2 & 0x1));
2522
2523 dib7090_enMpegMux(state, 1);
2524 }
2525
2526 static void dib7090_setDibTxMux(struct dib7000p_state *state, int mode)
2527 {
2528 u16 reg_1288 = dib7000p_read_word(state, 1288) & ~(0x7 << 7);
2529
2530 switch (mode) {
2531 case MPEG_ON_DIBTX:
2532 dprintk("SET MPEG ON DIBSTREAM TX\n");
2533 dib7090_cfg_DibTx(state, 8, 5, 0, 0, 0, 0);
2534 reg_1288 |= (1<<9);
2535 break;
2536 case DIV_ON_DIBTX:
2537 dprintk("SET DIV_OUT ON DIBSTREAM TX\n");
2538 dib7090_cfg_DibTx(state, 5, 5, 0, 0, 0, 0);
2539 reg_1288 |= (1<<8);
2540 break;
2541 case ADC_ON_DIBTX:
2542 dprintk("SET ADC_OUT ON DIBSTREAM TX\n");
2543 dib7090_cfg_DibTx(state, 20, 5, 10, 0, 0, 0);
2544 reg_1288 |= (1<<7);
2545 break;
2546 default:
2547 break;
2548 }
2549 dib7000p_write_word(state, 1288, reg_1288);
2550 }
2551
2552 static void dib7090_setHostBusMux(struct dib7000p_state *state, int mode)
2553 {
2554 u16 reg_1288 = dib7000p_read_word(state, 1288) & ~(0x7 << 4);
2555
2556 switch (mode) {
2557 case DEMOUT_ON_HOSTBUS:
2558 dprintk("SET DEM OUT OLD INTERF ON HOST BUS\n");
2559 dib7090_enMpegMux(state, 0);
2560 reg_1288 |= (1<<6);
2561 break;
2562 case DIBTX_ON_HOSTBUS:
2563 dprintk("SET DIBSTREAM TX ON HOST BUS\n");
2564 dib7090_enMpegMux(state, 0);
2565 reg_1288 |= (1<<5);
2566 break;
2567 case MPEG_ON_HOSTBUS:
2568 dprintk("SET MPEG MUX ON HOST BUS\n");
2569 reg_1288 |= (1<<4);
2570 break;
2571 default:
2572 break;
2573 }
2574 dib7000p_write_word(state, 1288, reg_1288);
2575 }
2576
2577 static int dib7090_set_diversity_in(struct dvb_frontend *fe, int onoff)
2578 {
2579 struct dib7000p_state *state = fe->demodulator_priv;
2580 u16 reg_1287;
2581
2582 switch (onoff) {
2583 case 0: /* only use the internal way - not the diversity input */
2584 dprintk("%s mode OFF : by default Enable Mpeg INPUT\n", __func__);
2585 dib7090_cfg_DibRx(state, 8, 5, 0, 0, 0, 8, 0);
2586
2587 /* Do not divide the serial clock of MPEG MUX */
2588 /* in SERIAL MODE in case input mode MPEG is used */
2589 reg_1287 = dib7000p_read_word(state, 1287);
2590 /* enSerialClkDiv2 == 1 ? */
2591 if ((reg_1287 & 0x1) == 1) {
2592 /* force enSerialClkDiv2 = 0 */
2593 reg_1287 &= ~0x1;
2594 dib7000p_write_word(state, 1287, reg_1287);
2595 }
2596 state->input_mode_mpeg = 1;
2597 break;
2598 case 1: /* both ways */
2599 case 2: /* only the diversity input */
2600 dprintk("%s ON : Enable diversity INPUT\n", __func__);
2601 dib7090_cfg_DibRx(state, 5, 5, 0, 0, 0, 0, 0);
2602 state->input_mode_mpeg = 0;
2603 break;
2604 }
2605
2606 dib7000p_set_diversity_in(&state->demod, onoff);
2607 return 0;
2608 }
2609
2610 static int dib7090_set_output_mode(struct dvb_frontend *fe, int mode)
2611 {
2612 struct dib7000p_state *state = fe->demodulator_priv;
2613
2614 u16 outreg, smo_mode, fifo_threshold;
2615 u8 prefer_mpeg_mux_use = 1;
2616 int ret = 0;
2617
2618 dib7090_host_bus_drive(state, 1);
2619
2620 fifo_threshold = 1792;
2621 smo_mode = (dib7000p_read_word(state, 235) & 0x0050) | (1 << 1);
2622 outreg = dib7000p_read_word(state, 1286) & ~((1 << 10) | (0x7 << 6) | (1 << 1));
2623
2624 switch (mode) {
2625 case OUTMODE_HIGH_Z:
2626 outreg = 0;
2627 break;
2628
2629 case OUTMODE_MPEG2_SERIAL:
2630 if (prefer_mpeg_mux_use) {
2631 dprintk("setting output mode TS_SERIAL using Mpeg Mux\n");
2632 dib7090_configMpegMux(state, 3, 1, 1);
2633 dib7090_setHostBusMux(state, MPEG_ON_HOSTBUS);
2634 } else {/* Use Smooth block */
2635 dprintk("setting output mode TS_SERIAL using Smooth bloc\n");
2636 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2637 outreg |= (2<<6) | (0 << 1);
2638 }
2639 break;
2640
2641 case OUTMODE_MPEG2_PAR_GATED_CLK:
2642 if (prefer_mpeg_mux_use) {
2643 dprintk("setting output mode TS_PARALLEL_GATED using Mpeg Mux\n");
2644 dib7090_configMpegMux(state, 2, 0, 0);
2645 dib7090_setHostBusMux(state, MPEG_ON_HOSTBUS);
2646 } else { /* Use Smooth block */
2647 dprintk("setting output mode TS_PARALLEL_GATED using Smooth block\n");
2648 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2649 outreg |= (0<<6);
2650 }
2651 break;
2652
2653 case OUTMODE_MPEG2_PAR_CONT_CLK: /* Using Smooth block only */
2654 dprintk("setting output mode TS_PARALLEL_CONT using Smooth block\n");
2655 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2656 outreg |= (1<<6);
2657 break;
2658
2659 case OUTMODE_MPEG2_FIFO: /* Using Smooth block because not supported by new Mpeg Mux bloc */
2660 dprintk("setting output mode TS_FIFO using Smooth block\n");
2661 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2662 outreg |= (5<<6);
2663 smo_mode |= (3 << 1);
2664 fifo_threshold = 512;
2665 break;
2666
2667 case OUTMODE_DIVERSITY:
2668 dprintk("setting output mode MODE_DIVERSITY\n");
2669 dib7090_setDibTxMux(state, DIV_ON_DIBTX);
2670 dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
2671 break;
2672
2673 case OUTMODE_ANALOG_ADC:
2674 dprintk("setting output mode MODE_ANALOG_ADC\n");
2675 dib7090_setDibTxMux(state, ADC_ON_DIBTX);
2676 dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
2677 break;
2678 }
2679 if (mode != OUTMODE_HIGH_Z)
2680 outreg |= (1 << 10);
2681
2682 if (state->cfg.output_mpeg2_in_188_bytes)
2683 smo_mode |= (1 << 5);
2684
2685 ret |= dib7000p_write_word(state, 235, smo_mode);
2686 ret |= dib7000p_write_word(state, 236, fifo_threshold); /* synchronous fread */
2687 ret |= dib7000p_write_word(state, 1286, outreg);
2688
2689 return ret;
2690 }
2691
2692 static int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff)
2693 {
2694 struct dib7000p_state *state = fe->demodulator_priv;
2695 u16 en_cur_state;
2696
2697 dprintk("sleep dib7090: %d\n", onoff);
2698
2699 en_cur_state = dib7000p_read_word(state, 1922);
2700
2701 if (en_cur_state > 0xff)
2702 state->tuner_enable = en_cur_state;
2703
2704 if (onoff)
2705 en_cur_state &= 0x00ff;
2706 else {
2707 if (state->tuner_enable != 0)
2708 en_cur_state = state->tuner_enable;
2709 }
2710
2711 dib7000p_write_word(state, 1922, en_cur_state);
2712
2713 return 0;
2714 }
2715
2716 static int dib7090_get_adc_power(struct dvb_frontend *fe)
2717 {
2718 return dib7000p_get_adc_power(fe);
2719 }
2720
2721 static int dib7090_slave_reset(struct dvb_frontend *fe)
2722 {
2723 struct dib7000p_state *state = fe->demodulator_priv;
2724 u16 reg;
2725
2726 reg = dib7000p_read_word(state, 1794);
2727 dib7000p_write_word(state, 1794, reg | (4 << 12));
2728
2729 dib7000p_write_word(state, 1032, 0xffff);
2730 return 0;
2731 }
2732
2733 static const struct dvb_frontend_ops dib7000p_ops;
2734 static struct dvb_frontend *dib7000p_init(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg)
2735 {
2736 struct dvb_frontend *demod;
2737 struct dib7000p_state *st;
2738 st = kzalloc(sizeof(struct dib7000p_state), GFP_KERNEL);
2739 if (st == NULL)
2740 return NULL;
2741
2742 memcpy(&st->cfg, cfg, sizeof(struct dib7000p_config));
2743 st->i2c_adap = i2c_adap;
2744 st->i2c_addr = i2c_addr;
2745 st->gpio_val = cfg->gpio_val;
2746 st->gpio_dir = cfg->gpio_dir;
2747
2748 /* Ensure the output mode remains at the previous default if it's
2749 * not specifically set by the caller.
2750 */
2751 if ((st->cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (st->cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
2752 st->cfg.output_mode = OUTMODE_MPEG2_FIFO;
2753
2754 demod = &st->demod;
2755 demod->demodulator_priv = st;
2756 memcpy(&st->demod.ops, &dib7000p_ops, sizeof(struct dvb_frontend_ops));
2757 mutex_init(&st->i2c_buffer_lock);
2758
2759 dib7000p_write_word(st, 1287, 0x0003); /* sram lead in, rdy */
2760
2761 if (dib7000p_identify(st) != 0)
2762 goto error;
2763
2764 st->version = dib7000p_read_word(st, 897);
2765
2766 /* FIXME: make sure the dev.parent field is initialized, or else
2767 request_firmware() will hit an OOPS (this should be moved somewhere
2768 more common) */
2769 st->i2c_master.gated_tuner_i2c_adap.dev.parent = i2c_adap->dev.parent;
2770
2771 dibx000_init_i2c_master(&st->i2c_master, DIB7000P, st->i2c_adap, st->i2c_addr);
2772
2773 /* init 7090 tuner adapter */
2774 strncpy(st->dib7090_tuner_adap.name, "DiB7090 tuner interface", sizeof(st->dib7090_tuner_adap.name));
2775 st->dib7090_tuner_adap.algo = &dib7090_tuner_xfer_algo;
2776 st->dib7090_tuner_adap.algo_data = NULL;
2777 st->dib7090_tuner_adap.dev.parent = st->i2c_adap->dev.parent;
2778 i2c_set_adapdata(&st->dib7090_tuner_adap, st);
2779 i2c_add_adapter(&st->dib7090_tuner_adap);
2780
2781 dib7000p_demod_reset(st);
2782
2783 dib7000p_reset_stats(demod);
2784
2785 if (st->version == SOC7090) {
2786 dib7090_set_output_mode(demod, st->cfg.output_mode);
2787 dib7090_set_diversity_in(demod, 0);
2788 }
2789
2790 return demod;
2791
2792 error:
2793 kfree(st);
2794 return NULL;
2795 }
2796
2797 void *dib7000p_attach(struct dib7000p_ops *ops)
2798 {
2799 if (!ops)
2800 return NULL;
2801
2802 ops->slave_reset = dib7090_slave_reset;
2803 ops->get_adc_power = dib7090_get_adc_power;
2804 ops->dib7000pc_detection = dib7000pc_detection;
2805 ops->get_i2c_tuner = dib7090_get_i2c_tuner;
2806 ops->tuner_sleep = dib7090_tuner_sleep;
2807 ops->init = dib7000p_init;
2808 ops->set_agc1_min = dib7000p_set_agc1_min;
2809 ops->set_gpio = dib7000p_set_gpio;
2810 ops->i2c_enumeration = dib7000p_i2c_enumeration;
2811 ops->pid_filter = dib7000p_pid_filter;
2812 ops->pid_filter_ctrl = dib7000p_pid_filter_ctrl;
2813 ops->get_i2c_master = dib7000p_get_i2c_master;
2814 ops->update_pll = dib7000p_update_pll;
2815 ops->ctrl_timf = dib7000p_ctrl_timf;
2816 ops->get_agc_values = dib7000p_get_agc_values;
2817 ops->set_wbd_ref = dib7000p_set_wbd_ref;
2818
2819 return ops;
2820 }
2821 EXPORT_SYMBOL(dib7000p_attach);
2822
2823 static const struct dvb_frontend_ops dib7000p_ops = {
2824 .delsys = { SYS_DVBT },
2825 .info = {
2826 .name = "DiBcom 7000PC",
2827 .frequency_min = 44250000,
2828 .frequency_max = 867250000,
2829 .frequency_stepsize = 62500,
2830 .caps = FE_CAN_INVERSION_AUTO |
2831 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
2832 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
2833 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
2834 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
2835 },
2836
2837 .release = dib7000p_release,
2838
2839 .init = dib7000p_wakeup,
2840 .sleep = dib7000p_sleep,
2841
2842 .set_frontend = dib7000p_set_frontend,
2843 .get_tune_settings = dib7000p_fe_get_tune_settings,
2844 .get_frontend = dib7000p_get_frontend,
2845
2846 .read_status = dib7000p_read_status,
2847 .read_ber = dib7000p_read_ber,
2848 .read_signal_strength = dib7000p_read_signal_strength,
2849 .read_snr = dib7000p_read_snr,
2850 .read_ucblocks = dib7000p_read_unc_blocks,
2851 };
2852
2853 MODULE_AUTHOR("Olivier Grenie <olivie.grenie@parrot.com>");
2854 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2855 MODULE_DESCRIPTION("Driver for the DiBcom 7000PC COFDM demodulator");
2856 MODULE_LICENSE("GPL");
CRIS linux kernel tree