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