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