Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dib0700_devices.c
Go to the documentation of this file.
1 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
2  *
3  * This program is free software; you can redistribute it and/or modify it
4  * under the terms of the GNU General Public License as published by the Free
5  * Software Foundation, version 2.
6  *
7  * Copyright (C) 2005-9 DiBcom, SA et al
8  */
9 #include "dib0700.h"
10 
11 #include "dib3000mc.h"
12 #include "dib7000m.h"
13 #include "dib7000p.h"
14 #include "dib8000.h"
15 #include "dib9000.h"
16 #include "mt2060.h"
17 #include "mt2266.h"
18 #include "tuner-xc2028.h"
19 #include "xc5000.h"
20 #include "xc4000.h"
21 #include "s5h1411.h"
22 #include "dib0070.h"
23 #include "dib0090.h"
24 #include "lgdt3305.h"
25 #include "mxl5007t.h"
26 
27 static int force_lna_activation;
28 module_param(force_lna_activation, int, 0644);
29 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
30  "if applicable for the device (default: 0=automatic/off).");
31 
32 struct dib0700_adapter_state {
33  int (*set_param_save) (struct dvb_frontend *);
34  const struct firmware *frontend_firmware;
35 };
36 
37 /* Hauppauge Nova-T 500 (aka Bristol)
38  * has a LNA on GPIO0 which is enabled by setting 1 */
39 static struct mt2060_config bristol_mt2060_config[2] = {
40  {
41  .i2c_address = 0x60,
42  .clock_out = 3,
43  }, {
44  .i2c_address = 0x61,
45  }
46 };
47 
48 
49 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
50  .band_caps = BAND_VHF | BAND_UHF,
51  .setup = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
52 
53  .agc1_max = 42598,
54  .agc1_min = 17694,
55  .agc2_max = 45875,
56  .agc2_min = 0,
57 
58  .agc1_pt1 = 0,
59  .agc1_pt2 = 59,
60 
61  .agc1_slope1 = 0,
62  .agc1_slope2 = 69,
63 
64  .agc2_pt1 = 0,
65  .agc2_pt2 = 59,
66 
67  .agc2_slope1 = 111,
68  .agc2_slope2 = 28,
69 };
70 
71 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
72  { .agc = &bristol_dib3000p_mt2060_agc_config,
73  .max_time = 0x196,
74  .ln_adc_level = 0x1cc7,
75  .output_mpeg2_in_188_bytes = 1,
76  },
77  { .agc = &bristol_dib3000p_mt2060_agc_config,
78  .max_time = 0x196,
79  .ln_adc_level = 0x1cc7,
80  .output_mpeg2_in_188_bytes = 1,
81  }
82 };
83 
84 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
85 {
86  struct dib0700_state *st = adap->dev->priv;
87  if (adap->id == 0) {
88  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
89  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
90  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
91  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
92 
93  if (force_lna_activation)
94  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
95  else
96  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
97 
98  if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
99  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
100  return -ENODEV;
101  }
102  }
103  st->mt2060_if1[adap->id] = 1220;
104  return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
105  (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
106 }
107 
108 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
109 {
110  struct i2c_msg msg[2] = {
111  { .addr = 0x50, .flags = 0, .buf = &adrs, .len = 1 },
112  { .addr = 0x50, .flags = I2C_M_RD, .buf = pval, .len = 1 },
113  };
114  if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
115  return 0;
116 }
117 
118 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
119 {
120  struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
121  struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
122  s8 a;
123  int if1=1220;
124  if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
125  adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
126  if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
127  }
128  return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
129  &bristol_mt2060_config[adap->id], if1) == NULL ?
130  -ENODEV : 0;
131 }
132 
133 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
134 
135 /* MT226x */
136 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
137  {
138  BAND_UHF,
139 
140  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
141  * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
142  (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
143  | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
144 
145  1130,
146  21,
147 
148  0,
149  118,
150 
151  0,
152  3530,
153  1,
154  0,
155 
156  65535,
157  33770,
158  65535,
159  23592,
160 
161  0,
162  62,
163  255,
164  64,
165  64,
166  132,
167  192,
168  80,
169  80,
170 
171  17,
172  27,
173  23,
174  51,
175 
176  1,
177  }, {
178  BAND_VHF | BAND_LBAND,
179 
180  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
181  * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
182  (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
183  | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
184 
185  2372,
186  21,
187 
188  0,
189  118,
190 
191  0,
192  3530,
193  1,
194  0,
195 
196  65535,
197  0,
198  65535,
199  23592,
200 
201  0,
202  128,
203  128,
204  128,
205  0,
206  128,
207  253,
208  81,
209  0,
210 
211  17,
212  27,
213  23,
214  51,
215 
216  1,
217  }
218 };
219 
220 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
221  60000, 30000,
222  1, 8, 3, 1, 0,
223  0, 0, 1, 1, 2,
224  (3 << 14) | (1 << 12) | (524 << 0),
225  0,
226  20452225,
227 };
228 
229 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
230  { .output_mpeg2_in_188_bytes = 1,
231  .hostbus_diversity = 1,
232  .tuner_is_baseband = 1,
233 
234  .agc_config_count = 2,
235  .agc = stk7700d_7000p_mt2266_agc_config,
236  .bw = &stk7700d_mt2266_pll_config,
237 
238  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
239  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
240  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
241  },
242  { .output_mpeg2_in_188_bytes = 1,
243  .hostbus_diversity = 1,
244  .tuner_is_baseband = 1,
245 
246  .agc_config_count = 2,
247  .agc = stk7700d_7000p_mt2266_agc_config,
248  .bw = &stk7700d_mt2266_pll_config,
249 
250  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
251  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
252  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
253  }
254 };
255 
256 static struct mt2266_config stk7700d_mt2266_config[2] = {
257  { .i2c_address = 0x60
258  },
259  { .i2c_address = 0x60
260  }
261 };
262 
263 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
264 {
265  if (adap->id == 0) {
266  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
267  msleep(10);
268  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
269  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
270  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
271  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
272  msleep(10);
273  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
274  msleep(10);
275  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
276  stk7700d_dib7000p_mt2266_config)
277  != 0) {
278  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
279  return -ENODEV;
280  }
281  }
282 
283  adap->fe_adap[0].fe =
284  dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
285  0x80 + (adap->id << 1),
286  &stk7700d_dib7000p_mt2266_config[adap->id]);
287 
288  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
289 }
290 
291 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
292 {
293  if (adap->id == 0) {
294  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
295  msleep(10);
296  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
297  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
298  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
299  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
300  msleep(10);
301  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
302  msleep(10);
303  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
304  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
305  stk7700d_dib7000p_mt2266_config)
306  != 0) {
307  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
308  return -ENODEV;
309  }
310  }
311 
312  adap->fe_adap[0].fe =
313  dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
314  0x80 + (adap->id << 1),
315  &stk7700d_dib7000p_mt2266_config[adap->id]);
316 
317  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
318 }
319 
320 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
321 {
322  struct i2c_adapter *tun_i2c;
323  tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
324  return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
325  &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
326 }
327 
328 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
329 static struct dibx000_agc_config xc3028_agc_config = {
330  BAND_VHF | BAND_UHF, /* band_caps */
331 
332  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
333  * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
334  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
335  (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
336  (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
337 
338  712, /* inv_gain */
339  21, /* time_stabiliz */
340 
341  0, /* alpha_level */
342  118, /* thlock */
343 
344  0, /* wbd_inv */
345  2867, /* wbd_ref */
346  0, /* wbd_sel */
347  2, /* wbd_alpha */
348 
349  0, /* agc1_max */
350  0, /* agc1_min */
351  39718, /* agc2_max */
352  9930, /* agc2_min */
353  0, /* agc1_pt1 */
354  0, /* agc1_pt2 */
355  0, /* agc1_pt3 */
356  0, /* agc1_slope1 */
357  0, /* agc1_slope2 */
358  0, /* agc2_pt1 */
359  128, /* agc2_pt2 */
360  29, /* agc2_slope1 */
361  29, /* agc2_slope2 */
362 
363  17, /* alpha_mant */
364  27, /* alpha_exp */
365  23, /* beta_mant */
366  51, /* beta_exp */
367 
368  1, /* perform_agc_softsplit */
369 };
370 
371 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
372 static struct dibx000_bandwidth_config xc3028_bw_config = {
373  60000, 30000, /* internal, sampling */
374  1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
375  0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
376  modulo */
377  (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
378  (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
379  20452225, /* timf */
380  30000000, /* xtal_hz */
381 };
382 
383 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
384  .output_mpeg2_in_188_bytes = 1,
385  .tuner_is_baseband = 1,
386 
387  .agc_config_count = 1,
388  .agc = &xc3028_agc_config,
389  .bw = &xc3028_bw_config,
390 
391  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
392  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
393  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
394 };
395 
396 static int stk7700ph_xc3028_callback(void *ptr, int component,
397  int command, int arg)
398 {
399  struct dvb_usb_adapter *adap = ptr;
400 
401  switch (command) {
402  case XC2028_TUNER_RESET:
403  /* Send the tuner in then out of reset */
404  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 0); msleep(10);
405  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
406  break;
407  case XC2028_RESET_CLK:
408  break;
409  default:
410  err("%s: unknown command %d, arg %d\n", __func__,
411  command, arg);
412  return -EINVAL;
413  }
414  return 0;
415 }
416 
417 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
418  .fname = XC2028_DEFAULT_FIRMWARE,
419  .max_len = 64,
420  .demod = XC3028_FE_DIBCOM52,
421 };
422 
423 static struct xc2028_config stk7700ph_xc3028_config = {
424  .i2c_addr = 0x61,
425  .ctrl = &stk7700ph_xc3028_ctrl,
426 };
427 
428 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
429 {
430  struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
431 
432  if (desc->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
433  desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
434  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
435  else
436  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
437  msleep(20);
438  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
439  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
440  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
441  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
442  msleep(10);
443  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
444  msleep(20);
445  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
446  msleep(10);
447 
448  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
449  &stk7700ph_dib7700_xc3028_config) != 0) {
450  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
451  __func__);
452  return -ENODEV;
453  }
454 
455  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
456  &stk7700ph_dib7700_xc3028_config);
457 
458  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
459 }
460 
461 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
462 {
463  struct i2c_adapter *tun_i2c;
464 
465  tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
466  DIBX000_I2C_INTERFACE_TUNER, 1);
467 
468  stk7700ph_xc3028_config.i2c_adap = tun_i2c;
469 
470  /* FIXME: generalize & move to common area */
471  adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback;
472 
473  return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config)
474  == NULL ? -ENODEV : 0;
475 }
476 
477 #define DEFAULT_RC_INTERVAL 50
478 
479 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
480 
481 /* Number of keypresses to ignore before start repeating */
482 #define RC_REPEAT_DELAY 6
483 
484 /*
485  * This function is used only when firmware is < 1.20 version. Newer
486  * firmwares use bulk mode, with functions implemented at dib0700_core,
487  * at dib0700_rc_urb_completion()
488  */
489 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
490 {
491  u8 key[4];
492  u32 keycode;
493  u8 toggle;
494  int i;
495  struct dib0700_state *st = d->priv;
496 
497  if (st->fw_version >= 0x10200) {
498  /* For 1.20 firmware , We need to keep the RC polling
499  callback so we can reuse the input device setup in
500  dvb-usb-remote.c. However, the actual work is being done
501  in the bulk URB completion handler. */
502  return 0;
503  }
504 
505  i = dib0700_ctrl_rd(d, rc_request, 2, key, 4);
506  if (i <= 0) {
507  err("RC Query Failed");
508  return -1;
509  }
510 
511  /* losing half of KEY_0 events from Philipps rc5 remotes.. */
512  if (key[0] == 0 && key[1] == 0 && key[2] == 0 && key[3] == 0)
513  return 0;
514 
515  /* info("%d: %2X %2X %2X %2X",dvb_usb_dib0700_ir_proto,(int)key[3-2],(int)key[3-3],(int)key[3-1],(int)key[3]); */
516 
517  dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
518 
519  d->last_event = 0;
520  switch (d->props.rc.core.protocol) {
521  case RC_TYPE_NEC:
522  /* NEC protocol sends repeat code as 0 0 0 FF */
523  if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
524  (key[3] == 0xff))
525  keycode = d->last_event;
526  else {
527  keycode = key[3-2] << 8 | key[3-3];
528  d->last_event = keycode;
529  }
530 
531  rc_keydown(d->rc_dev, keycode, 0);
532  break;
533  default:
534  /* RC-5 protocol changes toggle bit on new keypress */
535  keycode = key[3-2] << 8 | key[3-3];
536  toggle = key[3-1];
537  rc_keydown(d->rc_dev, keycode, toggle);
538 
539  break;
540  }
541  return 0;
542 }
543 
544 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
545 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
546  BAND_UHF | BAND_VHF,
547 
548  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
549  * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
550  (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
551  | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
552 
553  712,
554  41,
555 
556  0,
557  118,
558 
559  0,
560  4095,
561  0,
562  0,
563 
564  42598,
565  17694,
566  45875,
567  2621,
568  0,
569  76,
570  139,
571  52,
572  59,
573  107,
574  172,
575  57,
576  70,
577 
578  21,
579  25,
580  28,
581  48,
582 
583  1,
584  { 0,
585  107,
586  51800,
587  24700
588  },
589 };
590 
591 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
592  BAND_UHF | BAND_VHF,
593 
594  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
595  * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
596  (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
597  | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
598 
599  712,
600  41,
601 
602  0,
603  118,
604 
605  0,
606  4095,
607  0,
608  0,
609 
610  42598,
611  16384,
612  42598,
613  0,
614 
615  0,
616  137,
617  255,
618 
619  0,
620  255,
621 
622  0,
623  0,
624 
625  0,
626  41,
627 
628  15,
629  25,
630 
631  28,
632  48,
633 
634  0,
635 };
636 
637 static struct dibx000_bandwidth_config stk7700p_pll_config = {
638  60000, 30000,
639  1, 8, 3, 1, 0,
640  0, 0, 1, 1, 0,
641  (3 << 14) | (1 << 12) | (524 << 0),
642  60258167,
643  20452225,
644  30000000,
645 };
646 
647 static struct dib7000m_config stk7700p_dib7000m_config = {
648  .dvbt_mode = 1,
649  .output_mpeg2_in_188_bytes = 1,
650  .quartz_direct = 1,
651 
652  .agc_config_count = 1,
653  .agc = &stk7700p_7000m_mt2060_agc_config,
654  .bw = &stk7700p_pll_config,
655 
656  .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
657  .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
658  .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
659 };
660 
661 static struct dib7000p_config stk7700p_dib7000p_config = {
662  .output_mpeg2_in_188_bytes = 1,
663 
664  .agc_config_count = 1,
665  .agc = &stk7700p_7000p_mt2060_agc_config,
666  .bw = &stk7700p_pll_config,
667 
668  .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
669  .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
670  .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
671 };
672 
673 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
674 {
675  struct dib0700_state *st = adap->dev->priv;
676  /* unless there is no real power management in DVB - we leave the device on GPIO6 */
677 
678  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
679  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(50);
680 
681  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
682  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
683 
684  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
685  dib0700_ctrl_clock(adap->dev, 72, 1);
686  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
687 
688  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
689 
690  st->mt2060_if1[0] = 1220;
691 
692  if (dib7000pc_detection(&adap->dev->i2c_adap)) {
693  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
694  st->is_dib7000pc = 1;
695  } else
696  adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
697 
698  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
699 }
700 
701 static struct mt2060_config stk7700p_mt2060_config = {
702  0x60
703 };
704 
705 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
706 {
707  struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
708  struct dib0700_state *st = adap->dev->priv;
709  struct i2c_adapter *tun_i2c;
710  s8 a;
711  int if1=1220;
712  if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
713  adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
714  if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
715  }
716  if (st->is_dib7000pc)
717  tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
718  else
719  tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
720 
721  return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config,
722  if1) == NULL ? -ENODEV : 0;
723 }
724 
725 /* DIB7070 generic */
726 static struct dibx000_agc_config dib7070_agc_config = {
727  BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
728  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
729  * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
730  (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
731  | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
732 
733  600,
734  10,
735 
736  0,
737  118,
738 
739  0,
740  3530,
741  1,
742  5,
743 
744  65535,
745  0,
746 
747  65535,
748  0,
749 
750  0,
751  40,
752  183,
753  206,
754  255,
755  72,
756  152,
757  88,
758  90,
759 
760  17,
761  27,
762  23,
763  51,
764 
765  0,
766 };
767 
768 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
769 {
770  deb_info("reset: %d", onoff);
771  return dib7000p_set_gpio(fe, 8, 0, !onoff);
772 }
773 
774 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
775 {
776  deb_info("sleep: %d", onoff);
777  return dib7000p_set_gpio(fe, 9, 0, onoff);
778 }
779 
780 static struct dib0070_config dib7070p_dib0070_config[2] = {
781  {
782  .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
783  .reset = dib7070_tuner_reset,
784  .sleep = dib7070_tuner_sleep,
785  .clock_khz = 12000,
786  .clock_pad_drive = 4,
787  .charge_pump = 2,
788  }, {
789  .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
790  .reset = dib7070_tuner_reset,
791  .sleep = dib7070_tuner_sleep,
792  .clock_khz = 12000,
793  .charge_pump = 2,
794  }
795 };
796 
797 static struct dib0070_config dib7770p_dib0070_config = {
798  .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
799  .reset = dib7070_tuner_reset,
800  .sleep = dib7070_tuner_sleep,
801  .clock_khz = 12000,
802  .clock_pad_drive = 0,
803  .flip_chip = 1,
804  .charge_pump = 2,
805 };
806 
807 static int dib7070_set_param_override(struct dvb_frontend *fe)
808 {
809  struct dtv_frontend_properties *p = &fe->dtv_property_cache;
810  struct dvb_usb_adapter *adap = fe->dvb->priv;
811  struct dib0700_adapter_state *state = adap->priv;
812 
813  u16 offset;
814  u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
815  switch (band) {
816  case BAND_VHF: offset = 950; break;
817  case BAND_UHF:
818  default: offset = 550; break;
819  }
820  deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
821  dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
822  return state->set_param_save(fe);
823 }
824 
825 static int dib7770_set_param_override(struct dvb_frontend *fe)
826 {
827  struct dtv_frontend_properties *p = &fe->dtv_property_cache;
828  struct dvb_usb_adapter *adap = fe->dvb->priv;
829  struct dib0700_adapter_state *state = adap->priv;
830 
831  u16 offset;
832  u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
833  switch (band) {
834  case BAND_VHF:
835  dib7000p_set_gpio(fe, 0, 0, 1);
836  offset = 850;
837  break;
838  case BAND_UHF:
839  default:
840  dib7000p_set_gpio(fe, 0, 0, 0);
841  offset = 250;
842  break;
843  }
844  deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
845  dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
846  return state->set_param_save(fe);
847 }
848 
849 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
850 {
851  struct dib0700_adapter_state *st = adap->priv;
852  struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
853  DIBX000_I2C_INTERFACE_TUNER, 1);
854 
855  if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
856  &dib7770p_dib0070_config) == NULL)
857  return -ENODEV;
858 
859  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
860  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
861  return 0;
862 }
863 
864 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
865 {
866  struct dib0700_adapter_state *st = adap->priv;
867  struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
868 
869  if (adap->id == 0) {
870  if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
871  return -ENODEV;
872  } else {
873  if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
874  return -ENODEV;
875  }
876 
877  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
878  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
879  return 0;
880 }
881 
882 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
883  u16 pid, int onoff)
884 {
885  struct dib0700_state *st = adapter->dev->priv;
886  if (st->is_dib7000pc)
887  return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
888  return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
889 }
890 
891 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
892 {
893  struct dib0700_state *st = adapter->dev->priv;
894  if (st->is_dib7000pc)
895  return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
896  return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
897 }
898 
899 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
900 {
901  return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
902 }
903 
904 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
905 {
906  return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
907 }
908 
909 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
910  60000, 15000,
911  1, 20, 3, 1, 0,
912  0, 0, 1, 1, 2,
913  (3 << 14) | (1 << 12) | (524 << 0),
914  (0 << 25) | 0,
915  20452225,
916  12000000,
917 };
918 
919 static struct dib7000p_config dib7070p_dib7000p_config = {
920  .output_mpeg2_in_188_bytes = 1,
921 
922  .agc_config_count = 1,
923  .agc = &dib7070_agc_config,
924  .bw = &dib7070_bw_config_12_mhz,
925  .tuner_is_baseband = 1,
926  .spur_protect = 1,
927 
928  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
929  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
930  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
931 
932  .hostbus_diversity = 1,
933 };
934 
935 /* STK7070P */
936 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
937 {
938  struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
939  if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
940  p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
941  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
942  else
943  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
944  msleep(10);
945  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
946  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
947  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
948  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
949 
950  dib0700_ctrl_clock(adap->dev, 72, 1);
951 
952  msleep(10);
953  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
954  msleep(10);
955  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
956 
957  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
958  &dib7070p_dib7000p_config) != 0) {
959  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
960  __func__);
961  return -ENODEV;
962  }
963 
964  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
965  &dib7070p_dib7000p_config);
966  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
967 }
968 
969 /* STK7770P */
970 static struct dib7000p_config dib7770p_dib7000p_config = {
971  .output_mpeg2_in_188_bytes = 1,
972 
973  .agc_config_count = 1,
974  .agc = &dib7070_agc_config,
975  .bw = &dib7070_bw_config_12_mhz,
976  .tuner_is_baseband = 1,
977  .spur_protect = 1,
978 
979  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
980  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
981  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
982 
983  .hostbus_diversity = 1,
984  .enable_current_mirror = 1,
985  .disable_sample_and_hold = 0,
986 };
987 
988 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
989 {
990  struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
991  if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
992  p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
993  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
994  else
995  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
996  msleep(10);
997  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
998  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
999  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1000  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1001 
1002  dib0700_ctrl_clock(adap->dev, 72, 1);
1003 
1004  msleep(10);
1005  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1006  msleep(10);
1007  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1008 
1009  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1010  &dib7770p_dib7000p_config) != 0) {
1011  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
1012  __func__);
1013  return -ENODEV;
1014  }
1015 
1016  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1017  &dib7770p_dib7000p_config);
1018  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1019 }
1020 
1021 /* DIB807x generic */
1022 static struct dibx000_agc_config dib807x_agc_config[2] = {
1023  {
1024  BAND_VHF,
1025  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1026  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1027  * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1028  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1029  * P_agc_write=0 */
1030  (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1031  (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1032  (0 << 0), /* setup*/
1033 
1034  600, /* inv_gain*/
1035  10, /* time_stabiliz*/
1036 
1037  0, /* alpha_level*/
1038  118, /* thlock*/
1039 
1040  0, /* wbd_inv*/
1041  3530, /* wbd_ref*/
1042  1, /* wbd_sel*/
1043  5, /* wbd_alpha*/
1044 
1045  65535, /* agc1_max*/
1046  0, /* agc1_min*/
1047 
1048  65535, /* agc2_max*/
1049  0, /* agc2_min*/
1050 
1051  0, /* agc1_pt1*/
1052  40, /* agc1_pt2*/
1053  183, /* agc1_pt3*/
1054  206, /* agc1_slope1*/
1055  255, /* agc1_slope2*/
1056  72, /* agc2_pt1*/
1057  152, /* agc2_pt2*/
1058  88, /* agc2_slope1*/
1059  90, /* agc2_slope2*/
1060 
1061  17, /* alpha_mant*/
1062  27, /* alpha_exp*/
1063  23, /* beta_mant*/
1064  51, /* beta_exp*/
1065 
1066  0, /* perform_agc_softsplit*/
1067  }, {
1068  BAND_UHF,
1069  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1070  * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1071  * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1072  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1073  * P_agc_write=0 */
1074  (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1075  (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1076  (0 << 0), /* setup */
1077 
1078  600, /* inv_gain*/
1079  10, /* time_stabiliz*/
1080 
1081  0, /* alpha_level*/
1082  118, /* thlock*/
1083 
1084  0, /* wbd_inv*/
1085  3530, /* wbd_ref*/
1086  1, /* wbd_sel*/
1087  5, /* wbd_alpha*/
1088 
1089  65535, /* agc1_max*/
1090  0, /* agc1_min*/
1091 
1092  65535, /* agc2_max*/
1093  0, /* agc2_min*/
1094 
1095  0, /* agc1_pt1*/
1096  40, /* agc1_pt2*/
1097  183, /* agc1_pt3*/
1098  206, /* agc1_slope1*/
1099  255, /* agc1_slope2*/
1100  72, /* agc2_pt1*/
1101  152, /* agc2_pt2*/
1102  88, /* agc2_slope1*/
1103  90, /* agc2_slope2*/
1104 
1105  17, /* alpha_mant*/
1106  27, /* alpha_exp*/
1107  23, /* beta_mant*/
1108  51, /* beta_exp*/
1109 
1110  0, /* perform_agc_softsplit*/
1111  }
1112 };
1113 
1114 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1115  60000, 15000, /* internal, sampling*/
1116  1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1117  0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1118  ADClkSrc, modulo */
1119  (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1120  (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1121  18179755, /* timf*/
1122  12000000, /* xtal_hz*/
1123 };
1124 
1125 static struct dib8000_config dib807x_dib8000_config[2] = {
1126  {
1127  .output_mpeg2_in_188_bytes = 1,
1128 
1129  .agc_config_count = 2,
1130  .agc = dib807x_agc_config,
1131  .pll = &dib807x_bw_config_12_mhz,
1132  .tuner_is_baseband = 1,
1133 
1134  .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1135  .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1136  .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1137 
1138  .hostbus_diversity = 1,
1139  .div_cfg = 1,
1140  .agc_control = &dib0070_ctrl_agc_filter,
1141  .output_mode = OUTMODE_MPEG2_FIFO,
1142  .drives = 0x2d98,
1143  }, {
1144  .output_mpeg2_in_188_bytes = 1,
1145 
1146  .agc_config_count = 2,
1147  .agc = dib807x_agc_config,
1148  .pll = &dib807x_bw_config_12_mhz,
1149  .tuner_is_baseband = 1,
1150 
1151  .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1152  .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1153  .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1154 
1155  .hostbus_diversity = 1,
1156  .agc_control = &dib0070_ctrl_agc_filter,
1157  .output_mode = OUTMODE_MPEG2_FIFO,
1158  .drives = 0x2d98,
1159  }
1160 };
1161 
1162 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1163 {
1164  return dib8000_set_gpio(fe, 5, 0, !onoff);
1165 }
1166 
1167 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1168 {
1169  return dib8000_set_gpio(fe, 0, 0, onoff);
1170 }
1171 
1172 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1173  { 240, 7},
1174  { 0xffff, 6},
1175 };
1176 
1177 static struct dib0070_config dib807x_dib0070_config[2] = {
1178  {
1179  .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1180  .reset = dib80xx_tuner_reset,
1181  .sleep = dib80xx_tuner_sleep,
1182  .clock_khz = 12000,
1183  .clock_pad_drive = 4,
1184  .vga_filter = 1,
1185  .force_crystal_mode = 1,
1186  .enable_third_order_filter = 1,
1187  .charge_pump = 0,
1188  .wbd_gain = dib8070_wbd_gain_cfg,
1189  .osc_buffer_state = 0,
1190  .freq_offset_khz_uhf = -100,
1191  .freq_offset_khz_vhf = -100,
1192  }, {
1193  .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1194  .reset = dib80xx_tuner_reset,
1195  .sleep = dib80xx_tuner_sleep,
1196  .clock_khz = 12000,
1197  .clock_pad_drive = 2,
1198  .vga_filter = 1,
1199  .force_crystal_mode = 1,
1200  .enable_third_order_filter = 1,
1201  .charge_pump = 0,
1202  .wbd_gain = dib8070_wbd_gain_cfg,
1203  .osc_buffer_state = 0,
1204  .freq_offset_khz_uhf = -25,
1205  .freq_offset_khz_vhf = -25,
1206  }
1207 };
1208 
1209 static int dib807x_set_param_override(struct dvb_frontend *fe)
1210 {
1211  struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1212  struct dvb_usb_adapter *adap = fe->dvb->priv;
1213  struct dib0700_adapter_state *state = adap->priv;
1214 
1215  u16 offset = dib0070_wbd_offset(fe);
1216  u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1217  switch (band) {
1218  case BAND_VHF:
1219  offset += 750;
1220  break;
1221  case BAND_UHF: /* fall-thru wanted */
1222  default:
1223  offset += 250; break;
1224  }
1225  deb_info("WBD for DiB8000: %d\n", offset);
1226  dib8000_set_wbd_ref(fe, offset);
1227 
1228  return state->set_param_save(fe);
1229 }
1230 
1231 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1232 {
1233  struct dib0700_adapter_state *st = adap->priv;
1234  struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe,
1235  DIBX000_I2C_INTERFACE_TUNER, 1);
1236 
1237  if (adap->id == 0) {
1238  if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1239  &dib807x_dib0070_config[0]) == NULL)
1240  return -ENODEV;
1241  } else {
1242  if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1243  &dib807x_dib0070_config[1]) == NULL)
1244  return -ENODEV;
1245  }
1246 
1247  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1248  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1249  return 0;
1250 }
1251 
1252 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1253  u16 pid, int onoff)
1254 {
1255  return dib8000_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1256 }
1257 
1258 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1259  int onoff)
1260 {
1261  return dib8000_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1262 }
1263 
1264 /* STK807x */
1265 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1266 {
1267  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1268  msleep(10);
1269  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1270  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1271  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1272 
1273  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1274 
1275  dib0700_ctrl_clock(adap->dev, 72, 1);
1276 
1277  msleep(10);
1278  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1279  msleep(10);
1280  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1281 
1282  dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1283  0x80, 0);
1284 
1285  adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1286  &dib807x_dib8000_config[0]);
1287 
1288  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1289 }
1290 
1291 /* STK807xPVR */
1292 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1293 {
1294  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1295  msleep(30);
1296  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1297  msleep(500);
1298  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1299  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1300  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1301 
1302  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1303 
1304  dib0700_ctrl_clock(adap->dev, 72, 1);
1305 
1306  msleep(10);
1307  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1308  msleep(10);
1309  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1310 
1311  /* initialize IC 0 */
1312  dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0);
1313 
1314  adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1315  &dib807x_dib8000_config[0]);
1316 
1317  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1318 }
1319 
1320 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1321 {
1322  /* initialize IC 1 */
1323  dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0);
1324 
1325  adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1326  &dib807x_dib8000_config[1]);
1327 
1328  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1329 }
1330 
1331 /* STK8096GP */
1332 static struct dibx000_agc_config dib8090_agc_config[2] = {
1333  {
1334  BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1335  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1336  * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1337  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1338  (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1339  | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1340 
1341  787,
1342  10,
1343 
1344  0,
1345  118,
1346 
1347  0,
1348  3530,
1349  1,
1350  5,
1351 
1352  65535,
1353  0,
1354 
1355  65535,
1356  0,
1357 
1358  0,
1359  32,
1360  114,
1361  143,
1362  144,
1363  114,
1364  227,
1365  116,
1366  117,
1367 
1368  28,
1369  26,
1370  31,
1371  51,
1372 
1373  0,
1374  },
1375  {
1376  BAND_CBAND,
1377  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1378  * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1379  * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1380  (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1381  | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1382 
1383  787,
1384  10,
1385 
1386  0,
1387  118,
1388 
1389  0,
1390  3530,
1391  1,
1392  5,
1393 
1394  0,
1395  0,
1396 
1397  65535,
1398  0,
1399 
1400  0,
1401  32,
1402  114,
1403  143,
1404  144,
1405  114,
1406  227,
1407  116,
1408  117,
1409 
1410  28,
1411  26,
1412  31,
1413  51,
1414 
1415  0,
1416  }
1417 };
1418 
1419 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1420  54000, 13500,
1421  1, 18, 3, 1, 0,
1422  0, 0, 1, 1, 2,
1423  (3 << 14) | (1 << 12) | (599 << 0),
1424  (0 << 25) | 0,
1425  20199727,
1426  12000000,
1427 };
1428 
1429 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1430 {
1431  return dib8000_get_adc_power(fe, 1);
1432 }
1433 
1434 static struct dib8000_config dib809x_dib8000_config[2] = {
1435  {
1436  .output_mpeg2_in_188_bytes = 1,
1437 
1438  .agc_config_count = 2,
1439  .agc = dib8090_agc_config,
1440  .agc_control = dib0090_dcc_freq,
1441  .pll = &dib8090_pll_config_12mhz,
1442  .tuner_is_baseband = 1,
1443 
1444  .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1445  .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1446  .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1447 
1448  .hostbus_diversity = 1,
1449  .div_cfg = 0x31,
1450  .output_mode = OUTMODE_MPEG2_FIFO,
1451  .drives = 0x2d98,
1452  .diversity_delay = 48,
1453  .refclksel = 3,
1454  }, {
1455  .output_mpeg2_in_188_bytes = 1,
1456 
1457  .agc_config_count = 2,
1458  .agc = dib8090_agc_config,
1459  .agc_control = dib0090_dcc_freq,
1460  .pll = &dib8090_pll_config_12mhz,
1461  .tuner_is_baseband = 1,
1462 
1463  .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1464  .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1465  .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1466 
1467  .hostbus_diversity = 1,
1468  .div_cfg = 0x31,
1469  .output_mode = OUTMODE_DIVERSITY,
1470  .drives = 0x2d08,
1471  .diversity_delay = 1,
1472  .refclksel = 3,
1473  }
1474 };
1475 
1476 static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1477  /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1478  { 120, 0, 500, 0, 500, 4 }, /* CBAND */
1479  { 170, 0, 450, 0, 450, 4 }, /* CBAND */
1480  { 380, 48, 373, 28, 259, 6 }, /* VHF */
1481  { 860, 34, 700, 36, 616, 6 }, /* high UHF */
1482  { 0xFFFF, 34, 700, 36, 616, 6 }, /* default */
1483 };
1484 
1485 static struct dib0090_config dib809x_dib0090_config = {
1486  .io.pll_bypass = 1,
1487  .io.pll_range = 1,
1488  .io.pll_prediv = 1,
1489  .io.pll_loopdiv = 20,
1490  .io.adc_clock_ratio = 8,
1491  .io.pll_int_loop_filt = 0,
1492  .io.clock_khz = 12000,
1493  .reset = dib80xx_tuner_reset,
1494  .sleep = dib80xx_tuner_sleep,
1495  .clkouttobamse = 1,
1496  .analog_output = 1,
1497  .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1498  .use_pwm_agc = 1,
1499  .clkoutdrive = 1,
1500  .get_adc_power = dib8090_get_adc_power,
1501  .freq_offset_khz_uhf = -63,
1502  .freq_offset_khz_vhf = -143,
1503  .wbd = dib8090_wbd_table,
1504  .fref_clock_ratio = 6,
1505 };
1506 
1507 static int dib8096_set_param_override(struct dvb_frontend *fe)
1508 {
1509  struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1510  struct dvb_usb_adapter *adap = fe->dvb->priv;
1511  struct dib0700_adapter_state *state = adap->priv;
1512  u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1513  u16 target;
1514  int ret = 0;
1515  enum frontend_tune_state tune_state = CT_SHUTDOWN;
1516  u16 ltgain, rf_gain_limit;
1517 
1518  ret = state->set_param_save(fe);
1519  if (ret < 0)
1520  return ret;
1521 
1522  target = (dib0090_get_wbd_target(fe) * 8 * 18 / 33 + 1) / 2;
1523  dib8000_set_wbd_ref(fe, target);
1524 
1525 
1526  if (band == BAND_CBAND) {
1527  deb_info("tuning in CBAND - soft-AGC startup\n");
1528  dib0090_set_tune_state(fe, CT_AGC_START);
1529  do {
1530  ret = dib0090_gain_control(fe);
1531  msleep(ret);
1532  tune_state = dib0090_get_tune_state(fe);
1533  if (tune_state == CT_AGC_STEP_0)
1534  dib8000_set_gpio(fe, 6, 0, 1);
1535  else if (tune_state == CT_AGC_STEP_1) {
1536  dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1537  if (rf_gain_limit == 0)
1538  dib8000_set_gpio(fe, 6, 0, 0);
1539  }
1540  } while (tune_state < CT_AGC_STOP);
1541  dib0090_pwm_gain_reset(fe);
1542  dib8000_pwm_agc_reset(fe);
1543  dib8000_set_tune_state(fe, CT_DEMOD_START);
1544  } else {
1545  deb_info("not tuning in CBAND - standard AGC startup\n");
1546  dib0090_pwm_gain_reset(fe);
1547  }
1548 
1549  return 0;
1550 }
1551 
1552 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1553 {
1554  struct dib0700_adapter_state *st = adap->priv;
1555  struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1556 
1557  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1558  return -ENODEV;
1559 
1560  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1561  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1562  return 0;
1563 }
1564 
1565 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1566 {
1567  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1568  msleep(10);
1569  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1570  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1571  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1572 
1573  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1574 
1575  dib0700_ctrl_clock(adap->dev, 72, 1);
1576 
1577  msleep(10);
1578  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1579  msleep(10);
1580  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1581 
1582  dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1583 
1584  adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1585 
1586  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1587 }
1588 
1589 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1590 {
1591  struct dib0700_adapter_state *st = adap->priv;
1592  struct i2c_adapter *tun_i2c;
1593  struct dvb_frontend *fe_slave = dib8000_get_slave_frontend(adap->fe_adap[0].fe, 1);
1594 
1595  if (fe_slave) {
1596  tun_i2c = dib8000_get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1597  if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1598  return -ENODEV;
1599  fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1600  fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1601  }
1602  tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1603  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1604  return -ENODEV;
1605 
1606  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1607  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1608 
1609  return 0;
1610 }
1611 
1612 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1613 {
1614  struct dvb_frontend *fe_slave;
1615 
1616  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1617  msleep(20);
1618  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1619  msleep(1000);
1620  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1621  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1622  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1623 
1624  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1625 
1626  dib0700_ctrl_clock(adap->dev, 72, 1);
1627 
1628  msleep(20);
1629  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1630  msleep(20);
1631  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1632 
1633  dib8000_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
1634 
1635  adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1636  if (adap->fe_adap[0].fe == NULL)
1637  return -ENODEV;
1638 
1639  fe_slave = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1640  dib8000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1641 
1642  return fe_slave == NULL ? -ENODEV : 0;
1643 }
1644 
1645 /* TFE8096P */
1646 static struct dibx000_agc_config dib8096p_agc_config[2] = {
1647  {
1648  .band_caps = BAND_UHF,
1649  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1650  P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1651  P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1652  P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1653  P_agc_write=0 */
1654  .setup = (0 << 15) | (0 << 14) | (5 << 11)
1655  | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1656  | (0 << 4) | (5 << 1) | (0 << 0),
1657 
1658  .inv_gain = 684,
1659  .time_stabiliz = 10,
1660 
1661  .alpha_level = 0,
1662  .thlock = 118,
1663 
1664  .wbd_inv = 0,
1665  .wbd_ref = 1200,
1666  .wbd_sel = 3,
1667  .wbd_alpha = 5,
1668 
1669  .agc1_max = 65535,
1670  .agc1_min = 0,
1671 
1672  .agc2_max = 32767,
1673  .agc2_min = 0,
1674 
1675  .agc1_pt1 = 0,
1676  .agc1_pt2 = 0,
1677  .agc1_pt3 = 105,
1678  .agc1_slope1 = 0,
1679  .agc1_slope2 = 156,
1680  .agc2_pt1 = 105,
1681  .agc2_pt2 = 255,
1682  .agc2_slope1 = 54,
1683  .agc2_slope2 = 0,
1684 
1685  .alpha_mant = 28,
1686  .alpha_exp = 26,
1687  .beta_mant = 31,
1688  .beta_exp = 51,
1689 
1690  .perform_agc_softsplit = 0,
1691  } , {
1692  .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
1693  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1694  P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1695  P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1696  P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1697  P_agc_write=0 */
1698  .setup = (0 << 15) | (0 << 14) | (5 << 11)
1699  | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1700  | (0 << 4) | (5 << 1) | (0 << 0),
1701 
1702  .inv_gain = 732,
1703  .time_stabiliz = 10,
1704 
1705  .alpha_level = 0,
1706  .thlock = 118,
1707 
1708  .wbd_inv = 0,
1709  .wbd_ref = 1200,
1710  .wbd_sel = 3,
1711  .wbd_alpha = 5,
1712 
1713  .agc1_max = 65535,
1714  .agc1_min = 0,
1715 
1716  .agc2_max = 32767,
1717  .agc2_min = 0,
1718 
1719  .agc1_pt1 = 0,
1720  .agc1_pt2 = 0,
1721  .agc1_pt3 = 98,
1722  .agc1_slope1 = 0,
1723  .agc1_slope2 = 167,
1724  .agc2_pt1 = 98,
1725  .agc2_pt2 = 255,
1726  .agc2_slope1 = 52,
1727  .agc2_slope2 = 0,
1728 
1729  .alpha_mant = 28,
1730  .alpha_exp = 26,
1731  .beta_mant = 31,
1732  .beta_exp = 51,
1733 
1734  .perform_agc_softsplit = 0,
1735  }
1736 };
1737 
1738 static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = {
1739  108000, 13500,
1740  1, 9, 1, 0, 0,
1741  0, 0, 0, 0, 2,
1742  (3 << 14) | (1 << 12) | (524 << 0),
1743  (0 << 25) | 0,
1744  20199729,
1745  12000000,
1746 };
1747 
1748 static struct dib8000_config tfe8096p_dib8000_config = {
1749  .output_mpeg2_in_188_bytes = 1,
1750  .hostbus_diversity = 1,
1751  .update_lna = NULL,
1752 
1753  .agc_config_count = 2,
1754  .agc = dib8096p_agc_config,
1755  .pll = &dib8096p_clock_config_12_mhz,
1756 
1757  .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1758  .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1759  .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1760 
1761  .agc_control = NULL,
1762  .diversity_delay = 48,
1763  .output_mode = OUTMODE_MPEG2_FIFO,
1764  .enMpegOutput = 1,
1765 };
1766 
1767 static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
1768  { 380, 81, 850, 64, 540, 4},
1769  { 860, 51, 866, 21, 375, 4},
1770  {1700, 0, 250, 0, 100, 6},
1771  {2600, 0, 250, 0, 100, 6},
1772  { 0xFFFF, 0, 0, 0, 0, 0},
1773 };
1774 
1775 static const struct dib0090_config tfe8096p_dib0090_config = {
1776  .io.clock_khz = 12000,
1777  .io.pll_bypass = 0,
1778  .io.pll_range = 0,
1779  .io.pll_prediv = 3,
1780  .io.pll_loopdiv = 6,
1781  .io.adc_clock_ratio = 0,
1782  .io.pll_int_loop_filt = 0,
1783  .reset = dib8096p_tuner_sleep,
1784  .sleep = dib8096p_tuner_sleep,
1785 
1786  .freq_offset_khz_uhf = -143,
1787  .freq_offset_khz_vhf = -143,
1788 
1789  .get_adc_power = dib8090_get_adc_power,
1790 
1791  .clkouttobamse = 1,
1792  .analog_output = 0,
1793 
1794  .wbd_vhf_offset = 0,
1795  .wbd_cband_offset = 0,
1796  .use_pwm_agc = 1,
1797  .clkoutdrive = 0,
1798 
1799  .fref_clock_ratio = 1,
1800 
1801  .wbd = dib8096p_wbd_table,
1802 
1803  .ls_cfg_pad_drv = 0,
1804  .data_tx_drv = 0,
1805  .low_if = NULL,
1806  .in_soc = 1,
1807  .force_cband_input = 0,
1808 };
1809 
1810 struct dibx090p_adc {
1811  u32 freq; /* RF freq MHz */
1812  u32 timf; /* New Timf */
1813  u32 pll_loopdiv; /* New prediv */
1814  u32 pll_prediv; /* New loopdiv */
1815 };
1816 
1817 struct dibx090p_adc dib8090p_adc_tab[] = {
1818  { 50000, 17043521, 16, 3}, /* 64 MHz */
1819  {878000, 20199729, 9, 1}, /* 60 MHz */
1820  {0xffffffff, 0, 0, 0}, /* 60 MHz */
1821 };
1822 
1823 static int dib8096p_agc_startup(struct dvb_frontend *fe)
1824 {
1825  struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1826  struct dvb_usb_adapter *adap = fe->dvb->priv;
1827  struct dib0700_adapter_state *state = adap->priv;
1828  struct dibx000_bandwidth_config pll;
1829  u16 target;
1830  int better_sampling_freq = 0, ret;
1831  struct dibx090p_adc *adc_table = &dib8090p_adc_tab[0];
1832 
1833  ret = state->set_param_save(fe);
1834  if (ret < 0)
1835  return ret;
1836  memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
1837 
1838  dib0090_pwm_gain_reset(fe);
1839  /* dib0090_get_wbd_target is returning any possible
1840  temperature compensated wbd-target */
1841  target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
1842  dib8000_set_wbd_ref(fe, target);
1843 
1844 
1845  while (p->frequency / 1000 > adc_table->freq) {
1846  better_sampling_freq = 1;
1847  adc_table++;
1848  }
1849 
1850  if ((adc_table->freq != 0xffffffff) && better_sampling_freq) {
1851  pll.pll_ratio = adc_table->pll_loopdiv;
1852  pll.pll_prediv = adc_table->pll_prediv;
1853  dib8000_update_pll(fe, &pll);
1854  dib8000_ctrl_timf(fe, DEMOD_TIMF_SET, adc_table->timf);
1855  }
1856  return 0;
1857 }
1858 
1859 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
1860 {
1861  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1862  msleep(20);
1863  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1864  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1865  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1866 
1867  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1868 
1869  dib0700_ctrl_clock(adap->dev, 72, 1);
1870 
1871  msleep(20);
1872  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1873  msleep(20);
1874  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1875 
1876  dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
1877 
1878  adap->fe_adap[0].fe = dvb_attach(dib8000_attach,
1879  &adap->dev->i2c_adap, 0x80, &tfe8096p_dib8000_config);
1880 
1881  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1882 }
1883 
1884 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
1885 {
1886  struct dib0700_adapter_state *st = adap->priv;
1887  struct i2c_adapter *tun_i2c = dib8096p_get_i2c_tuner(adap->fe_adap[0].fe);
1888 
1889  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
1890  &tfe8096p_dib0090_config) == NULL)
1891  return -ENODEV;
1892 
1893  dib8000_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
1894 
1895  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1896  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
1897  return 0;
1898 }
1899 
1900 /* STK9090M */
1901 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
1902 {
1903  return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1904 }
1905 
1906 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
1907 {
1908  return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1909 }
1910 
1911 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
1912 {
1913  return dib9000_set_gpio(fe, 5, 0, !onoff);
1914 }
1915 
1916 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
1917 {
1918  return dib9000_set_gpio(fe, 0, 0, onoff);
1919 }
1920 
1921 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
1922 {
1923  u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
1924  u8 rb[2];
1925  struct i2c_msg msg[2] = {
1926  {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
1927  {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
1928  };
1929  u8 index_data;
1930 
1931  dibx000_i2c_set_speed(i2c, 250);
1932 
1933  if (i2c_transfer(i2c, msg, 2) != 2)
1934  return -EIO;
1935 
1936  switch (rb[0] << 8 | rb[1]) {
1937  case 0:
1938  deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
1939  return -EIO;
1940  case 1:
1941  deb_info("Found DiB0170 rev2");
1942  break;
1943  case 2:
1944  deb_info("Found DiB0190 rev2");
1945  break;
1946  default:
1947  deb_info("DiB01x0 not found");
1948  return -EIO;
1949  }
1950 
1951  for (index_data = 0; index_data < len; index_data += 2) {
1952  wb[2] = (data[index_data + 1] >> 8) & 0xff;
1953  wb[3] = (data[index_data + 1]) & 0xff;
1954 
1955  if (data[index_data] == 0) {
1956  wb[0] = (data[index_data] >> 8) & 0xff;
1957  wb[1] = (data[index_data]) & 0xff;
1958  msg[0].len = 2;
1959  if (i2c_transfer(i2c, msg, 2) != 2)
1960  return -EIO;
1961  wb[2] |= rb[0];
1962  wb[3] |= rb[1] & ~(3 << 4);
1963  }
1964 
1965  wb[0] = (data[index_data] >> 8)&0xff;
1966  wb[1] = (data[index_data])&0xff;
1967  msg[0].len = 4;
1968  if (i2c_transfer(i2c, &msg[0], 1) != 1)
1969  return -EIO;
1970  }
1971  return 0;
1972 }
1973 
1974 static struct dib9000_config stk9090m_config = {
1975  .output_mpeg2_in_188_bytes = 1,
1976  .output_mode = OUTMODE_MPEG2_FIFO,
1977  .vcxo_timer = 279620,
1978  .timing_frequency = 20452225,
1979  .demod_clock_khz = 60000,
1980  .xtal_clock_khz = 30000,
1981  .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1982  .subband = {
1983  2,
1984  {
1985  { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
1986  { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
1987  { 0 },
1988  },
1989  },
1990  .gpio_function = {
1991  { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
1992  { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
1993  },
1994 };
1995 
1996 static struct dib9000_config nim9090md_config[2] = {
1997  {
1998  .output_mpeg2_in_188_bytes = 1,
1999  .output_mode = OUTMODE_MPEG2_FIFO,
2000  .vcxo_timer = 279620,
2001  .timing_frequency = 20452225,
2002  .demod_clock_khz = 60000,
2003  .xtal_clock_khz = 30000,
2004  .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2005  }, {
2006  .output_mpeg2_in_188_bytes = 1,
2007  .output_mode = OUTMODE_DIVERSITY,
2008  .vcxo_timer = 279620,
2009  .timing_frequency = 20452225,
2010  .demod_clock_khz = 60000,
2011  .xtal_clock_khz = 30000,
2012  .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2013  .subband = {
2014  2,
2015  {
2016  { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
2017  { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
2018  { 0 },
2019  },
2020  },
2021  .gpio_function = {
2022  { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2023  { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2024  },
2025  }
2026 };
2027 
2028 static struct dib0090_config dib9090_dib0090_config = {
2029  .io.pll_bypass = 0,
2030  .io.pll_range = 1,
2031  .io.pll_prediv = 1,
2032  .io.pll_loopdiv = 8,
2033  .io.adc_clock_ratio = 8,
2034  .io.pll_int_loop_filt = 0,
2035  .io.clock_khz = 30000,
2036  .reset = dib90x0_tuner_reset,
2037  .sleep = dib90x0_tuner_sleep,
2038  .clkouttobamse = 0,
2039  .analog_output = 0,
2040  .use_pwm_agc = 0,
2041  .clkoutdrive = 0,
2042  .freq_offset_khz_uhf = 0,
2043  .freq_offset_khz_vhf = 0,
2044 };
2045 
2046 static struct dib0090_config nim9090md_dib0090_config[2] = {
2047  {
2048  .io.pll_bypass = 0,
2049  .io.pll_range = 1,
2050  .io.pll_prediv = 1,
2051  .io.pll_loopdiv = 8,
2052  .io.adc_clock_ratio = 8,
2053  .io.pll_int_loop_filt = 0,
2054  .io.clock_khz = 30000,
2055  .reset = dib90x0_tuner_reset,
2056  .sleep = dib90x0_tuner_sleep,
2057  .clkouttobamse = 1,
2058  .analog_output = 0,
2059  .use_pwm_agc = 0,
2060  .clkoutdrive = 0,
2061  .freq_offset_khz_uhf = 0,
2062  .freq_offset_khz_vhf = 0,
2063  }, {
2064  .io.pll_bypass = 0,
2065  .io.pll_range = 1,
2066  .io.pll_prediv = 1,
2067  .io.pll_loopdiv = 8,
2068  .io.adc_clock_ratio = 8,
2069  .io.pll_int_loop_filt = 0,
2070  .io.clock_khz = 30000,
2071  .reset = dib90x0_tuner_reset,
2072  .sleep = dib90x0_tuner_sleep,
2073  .clkouttobamse = 0,
2074  .analog_output = 0,
2075  .use_pwm_agc = 0,
2076  .clkoutdrive = 0,
2077  .freq_offset_khz_uhf = 0,
2078  .freq_offset_khz_vhf = 0,
2079  }
2080 };
2081 
2082 
2083 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2084 {
2085  struct dib0700_adapter_state *state = adap->priv;
2086  struct dib0700_state *st = adap->dev->priv;
2087  u32 fw_version;
2088 
2089  /* Make use of the new i2c functions from FW 1.20 */
2090  dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2091  if (fw_version >= 0x10200)
2092  st->fw_use_new_i2c_api = 1;
2093  dib0700_set_i2c_speed(adap->dev, 340);
2094 
2095  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2096  msleep(20);
2097  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2098  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2099  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2100  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2101 
2102  dib0700_ctrl_clock(adap->dev, 72, 1);
2103 
2104  msleep(20);
2105  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2106  msleep(20);
2107  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2108 
2109  dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2110 
2111  if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2112  deb_info("%s: Upload failed. (file not found?)\n", __func__);
2113  return -ENODEV;
2114  } else {
2115  deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
2116  }
2117  stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2118  stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2119 
2120  adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2121 
2122  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2123 }
2124 
2125 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2126 {
2127  struct dib0700_adapter_state *state = adap->priv;
2128  struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2129  u16 data_dib190[10] = {
2130  1, 0x1374,
2131  2, 0x01a2,
2132  7, 0x0020,
2133  0, 0x00ef,
2134  8, 0x0486,
2135  };
2136 
2137  if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2138  return -ENODEV;
2139  i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2140  if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2141  return -ENODEV;
2142  dib0700_set_i2c_speed(adap->dev, 1500);
2143  if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2144  return -ENODEV;
2145  release_firmware(state->frontend_firmware);
2146  return 0;
2147 }
2148 
2149 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2150 {
2151  struct dib0700_adapter_state *state = adap->priv;
2152  struct dib0700_state *st = adap->dev->priv;
2153  struct i2c_adapter *i2c;
2154  struct dvb_frontend *fe_slave;
2155  u32 fw_version;
2156 
2157  /* Make use of the new i2c functions from FW 1.20 */
2158  dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2159  if (fw_version >= 0x10200)
2160  st->fw_use_new_i2c_api = 1;
2161  dib0700_set_i2c_speed(adap->dev, 340);
2162 
2163  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2164  msleep(20);
2165  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2166  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2167  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2168  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2169 
2170  dib0700_ctrl_clock(adap->dev, 72, 1);
2171 
2172  msleep(20);
2173  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2174  msleep(20);
2175  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2176 
2177  if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2178  deb_info("%s: Upload failed. (file not found?)\n", __func__);
2179  return -EIO;
2180  } else {
2181  deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
2182  }
2183  nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2184  nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2185  nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2186  nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2187 
2188  dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2189  adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2190 
2191  if (adap->fe_adap[0].fe == NULL)
2192  return -ENODEV;
2193 
2194  i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
2195  dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
2196 
2197  fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2198  dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
2199 
2200  return fe_slave == NULL ? -ENODEV : 0;
2201 }
2202 
2203 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2204 {
2205  struct dib0700_adapter_state *state = adap->priv;
2206  struct i2c_adapter *i2c;
2207  struct dvb_frontend *fe_slave;
2208  u16 data_dib190[10] = {
2209  1, 0x5374,
2210  2, 0x01ae,
2211  7, 0x0020,
2212  0, 0x00ef,
2213  8, 0x0406,
2214  };
2215  i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2216  if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2217  return -ENODEV;
2218  i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2219  if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
2220  return -ENODEV;
2221 
2222  dib0700_set_i2c_speed(adap->dev, 1500);
2223  if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2224  return -ENODEV;
2225 
2226  fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
2227  if (fe_slave != NULL) {
2228  i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
2229  dib9000_set_i2c_adapter(fe_slave, i2c);
2230 
2231  i2c = dib9000_get_tuner_interface(fe_slave);
2232  if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
2233  return -ENODEV;
2234  fe_slave->dvb = adap->fe_adap[0].fe->dvb;
2235  dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 1500);
2236  if (dib9000_firmware_post_pll_init(fe_slave) < 0)
2237  return -ENODEV;
2238  }
2239  release_firmware(state->frontend_firmware);
2240 
2241  return 0;
2242 }
2243 
2244 /* NIM7090 */
2245 struct dib7090p_best_adc {
2246  u32 timf;
2247  u32 pll_loopdiv;
2248  u32 pll_prediv;
2249 };
2250 
2251 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dib7090p_best_adc *adc)
2252 {
2253  u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2254 
2255  u16 xtal = 12000;
2256  u32 fcp_min = 1900; /* PLL Minimum Frequency comparator KHz */
2257  u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
2258  u32 fdem_max = 76000;
2259  u32 fdem_min = 69500;
2260  u32 fcp = 0, fs = 0, fdem = 0;
2261  u32 harmonic_id = 0;
2262 
2263  adc->pll_loopdiv = loopdiv;
2264  adc->pll_prediv = prediv;
2265  adc->timf = 0;
2266 
2267  deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2268 
2269  /* Find Min and Max prediv */
2270  while ((xtal/max_prediv) >= fcp_min)
2271  max_prediv++;
2272 
2273  max_prediv--;
2274  min_prediv = max_prediv;
2275  while ((xtal/min_prediv) <= fcp_max) {
2276  min_prediv--;
2277  if (min_prediv == 1)
2278  break;
2279  }
2280  deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2281 
2282  min_prediv = 2;
2283 
2284  for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2285  fcp = xtal / prediv;
2286  if (fcp > fcp_min && fcp < fcp_max) {
2287  for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2288  fdem = ((xtal/prediv) * loopdiv);
2289  fs = fdem / 4;
2290  /* test min/max system restrictions */
2291 
2292  if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2293  spur = 0;
2294  /* test fs harmonics positions */
2295  for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ; harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2296  if (((fs*harmonic_id) >= ((fe->dtv_property_cache.frequency/1000) - (fe->dtv_property_cache.bandwidth_hz/2000))) && ((fs*harmonic_id) <= ((fe->dtv_property_cache.frequency/1000) + (fe->dtv_property_cache.bandwidth_hz/2000)))) {
2297  spur = 1;
2298  break;
2299  }
2300  }
2301 
2302  if (!spur) {
2303  adc->pll_loopdiv = loopdiv;
2304  adc->pll_prediv = prediv;
2305  adc->timf = 2396745143UL/fdem*(1 << 9);
2306  adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2307  deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2308  break;
2309  }
2310  }
2311  }
2312  }
2313  if (!spur)
2314  break;
2315  }
2316 
2317 
2318  if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2319  return -EINVAL;
2320  else
2321  return 0;
2322 }
2323 
2324 static int dib7090_agc_startup(struct dvb_frontend *fe)
2325 {
2326  struct dvb_usb_adapter *adap = fe->dvb->priv;
2327  struct dib0700_adapter_state *state = adap->priv;
2328  struct dibx000_bandwidth_config pll;
2329  u16 target;
2330  struct dib7090p_best_adc adc;
2331  int ret;
2332 
2333  ret = state->set_param_save(fe);
2334  if (ret < 0)
2335  return ret;
2336 
2337  memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2338  dib0090_pwm_gain_reset(fe);
2339  target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2340  dib7000p_set_wbd_ref(fe, target);
2341 
2342  if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2343  pll.pll_ratio = adc.pll_loopdiv;
2344  pll.pll_prediv = adc.pll_prediv;
2345 
2346  dib7000p_update_pll(fe, &pll);
2347  dib7000p_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2348  }
2349  return 0;
2350 }
2351 
2352 static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
2353 {
2354  deb_info("AGC restart callback: %d", restart);
2355  if (restart == 0) /* before AGC startup */
2356  dib0090_set_dc_servo(fe, 1);
2357  return 0;
2358 }
2359 
2360 static int dib7090e_update_lna(struct dvb_frontend *fe, u16 agc_global)
2361 {
2362  u16 agc1 = 0, agc2, wbd = 0, wbd_target, wbd_offset, threshold_agc1;
2363  s16 wbd_delta;
2364 
2365  if ((fe->dtv_property_cache.frequency) < 400000000)
2366  threshold_agc1 = 25000;
2367  else
2368  threshold_agc1 = 30000;
2369 
2370  wbd_target = (dib0090_get_wbd_target(fe)*8+1)/2;
2371  wbd_offset = dib0090_get_wbd_offset(fe);
2372  dib7000p_get_agc_values(fe, NULL, &agc1, &agc2, &wbd);
2373  wbd_delta = (s16)wbd - (((s16)wbd_offset+10)*4) ;
2374 
2375  deb_info("update lna, agc_global=%d agc1=%d agc2=%d",
2376  agc_global, agc1, agc2);
2377  deb_info("update lna, wbd=%d wbd target=%d wbd offset=%d wbd delta=%d",
2378  wbd, wbd_target, wbd_offset, wbd_delta);
2379 
2380  if ((agc1 < threshold_agc1) && (wbd_delta > 0)) {
2381  dib0090_set_switch(fe, 1, 1, 1);
2382  dib0090_set_vga(fe, 0);
2383  dib0090_update_rframp_7090(fe, 0);
2384  dib0090_update_tuning_table_7090(fe, 0);
2385  } else {
2386  dib0090_set_vga(fe, 1);
2387  dib0090_update_rframp_7090(fe, 1);
2388  dib0090_update_tuning_table_7090(fe, 1);
2389  dib0090_set_switch(fe, 0, 0, 0);
2390  }
2391 
2392  return 0;
2393 }
2394 
2395 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2396  { 380, 81, 850, 64, 540, 4},
2397  { 860, 51, 866, 21, 375, 4},
2398  {1700, 0, 250, 0, 100, 6},
2399  {2600, 0, 250, 0, 100, 6},
2400  { 0xFFFF, 0, 0, 0, 0, 0},
2401 };
2402 
2403 static struct dib0090_wbd_slope dib7090e_wbd_table[] = {
2404  { 380, 81, 850, 64, 540, 4},
2405  { 700, 51, 866, 21, 320, 4},
2406  { 860, 48, 666, 18, 330, 6},
2407  {1700, 0, 250, 0, 100, 6},
2408  {2600, 0, 250, 0, 100, 6},
2409  { 0xFFFF, 0, 0, 0, 0, 0},
2410 };
2411 
2412 static struct dibx000_agc_config dib7090_agc_config[2] = {
2413  {
2414  .band_caps = BAND_UHF,
2415  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2416  * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
2417  .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2418 
2419  .inv_gain = 687,
2420  .time_stabiliz = 10,
2421 
2422  .alpha_level = 0,
2423  .thlock = 118,
2424 
2425  .wbd_inv = 0,
2426  .wbd_ref = 1200,
2427  .wbd_sel = 3,
2428  .wbd_alpha = 5,
2429 
2430  .agc1_max = 65535,
2431  .agc1_min = 0,
2432 
2433  .agc2_max = 65535,
2434  .agc2_min = 0,
2435 
2436  .agc1_pt1 = 0,
2437  .agc1_pt2 = 32,
2438  .agc1_pt3 = 114,
2439  .agc1_slope1 = 143,
2440  .agc1_slope2 = 144,
2441  .agc2_pt1 = 114,
2442  .agc2_pt2 = 227,
2443  .agc2_slope1 = 116,
2444  .agc2_slope2 = 117,
2445 
2446  .alpha_mant = 18,
2447  .alpha_exp = 0,
2448  .beta_mant = 20,
2449  .beta_exp = 59,
2450 
2451  .perform_agc_softsplit = 0,
2452  } , {
2453  .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
2454  /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2455  * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
2456  .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2457 
2458  .inv_gain = 732,
2459  .time_stabiliz = 10,
2460 
2461  .alpha_level = 0,
2462  .thlock = 118,
2463 
2464  .wbd_inv = 0,
2465  .wbd_ref = 1200,
2466  .wbd_sel = 3,
2467  .wbd_alpha = 5,
2468 
2469  .agc1_max = 65535,
2470  .agc1_min = 0,
2471 
2472  .agc2_max = 65535,
2473  .agc2_min = 0,
2474 
2475  .agc1_pt1 = 0,
2476  .agc1_pt2 = 0,
2477  .agc1_pt3 = 98,
2478  .agc1_slope1 = 0,
2479  .agc1_slope2 = 167,
2480  .agc2_pt1 = 98,
2481  .agc2_pt2 = 255,
2482  .agc2_slope1 = 104,
2483  .agc2_slope2 = 0,
2484 
2485  .alpha_mant = 18,
2486  .alpha_exp = 0,
2487  .beta_mant = 20,
2488  .beta_exp = 59,
2489 
2490  .perform_agc_softsplit = 0,
2491  }
2492 };
2493 
2494 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2495  60000, 15000,
2496  1, 5, 0, 0, 0,
2497  0, 0, 1, 1, 2,
2498  (3 << 14) | (1 << 12) | (524 << 0),
2499  (0 << 25) | 0,
2500  20452225,
2501  15000000,
2502 };
2503 
2504 static struct dib7000p_config nim7090_dib7000p_config = {
2505  .output_mpeg2_in_188_bytes = 1,
2506  .hostbus_diversity = 1,
2507  .tuner_is_baseband = 1,
2508  .update_lna = NULL,
2509 
2510  .agc_config_count = 2,
2511  .agc = dib7090_agc_config,
2512 
2513  .bw = &dib7090_clock_config_12_mhz,
2514 
2515  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2516  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2517  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2518 
2519  .pwm_freq_div = 0,
2520 
2521  .agc_control = dib7090_agc_restart,
2522 
2523  .spur_protect = 0,
2524  .disable_sample_and_hold = 0,
2525  .enable_current_mirror = 0,
2526  .diversity_delay = 0,
2527 
2528  .output_mode = OUTMODE_MPEG2_FIFO,
2529  .enMpegOutput = 1,
2530 };
2531 
2532 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2533  {
2534  .output_mpeg2_in_188_bytes = 1,
2535  .hostbus_diversity = 1,
2536  .tuner_is_baseband = 1,
2537  .update_lna = NULL,
2538 
2539  .agc_config_count = 2,
2540  .agc = dib7090_agc_config,
2541 
2542  .bw = &dib7090_clock_config_12_mhz,
2543 
2544  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2545  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2546  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2547 
2548  .pwm_freq_div = 0,
2549 
2550  .agc_control = dib7090_agc_restart,
2551 
2552  .spur_protect = 0,
2553  .disable_sample_and_hold = 0,
2554  .enable_current_mirror = 0,
2555  .diversity_delay = 0,
2556 
2557  .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2558  .default_i2c_addr = 0x90,
2559  .enMpegOutput = 1,
2560  }, {
2561  .output_mpeg2_in_188_bytes = 1,
2562  .hostbus_diversity = 1,
2563  .tuner_is_baseband = 1,
2564  .update_lna = NULL,
2565 
2566  .agc_config_count = 2,
2567  .agc = dib7090_agc_config,
2568 
2569  .bw = &dib7090_clock_config_12_mhz,
2570 
2571  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2572  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2573  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2574 
2575  .pwm_freq_div = 0,
2576 
2577  .agc_control = dib7090_agc_restart,
2578 
2579  .spur_protect = 0,
2580  .disable_sample_and_hold = 0,
2581  .enable_current_mirror = 0,
2582  .diversity_delay = 0,
2583 
2584  .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2585  .default_i2c_addr = 0x92,
2586  .enMpegOutput = 0,
2587  }
2588 };
2589 
2590 static struct dib7000p_config tfe7090e_dib7000p_config = {
2591  .output_mpeg2_in_188_bytes = 1,
2592  .hostbus_diversity = 1,
2593  .tuner_is_baseband = 1,
2594  .update_lna = dib7090e_update_lna,
2595 
2596  .agc_config_count = 2,
2597  .agc = dib7090_agc_config,
2598 
2599  .bw = &dib7090_clock_config_12_mhz,
2600 
2601  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2602  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2603  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2604 
2605  .pwm_freq_div = 0,
2606 
2607  .agc_control = dib7090_agc_restart,
2608 
2609  .spur_protect = 0,
2610  .disable_sample_and_hold = 0,
2611  .enable_current_mirror = 0,
2612  .diversity_delay = 0,
2613 
2614  .output_mode = OUTMODE_MPEG2_FIFO,
2615  .enMpegOutput = 1,
2616 };
2617 
2618 static const struct dib0090_config nim7090_dib0090_config = {
2619  .io.clock_khz = 12000,
2620  .io.pll_bypass = 0,
2621  .io.pll_range = 0,
2622  .io.pll_prediv = 3,
2623  .io.pll_loopdiv = 6,
2624  .io.adc_clock_ratio = 0,
2625  .io.pll_int_loop_filt = 0,
2626  .reset = dib7090_tuner_sleep,
2627  .sleep = dib7090_tuner_sleep,
2628 
2629  .freq_offset_khz_uhf = 0,
2630  .freq_offset_khz_vhf = 0,
2631 
2632  .get_adc_power = dib7090_get_adc_power,
2633 
2634  .clkouttobamse = 1,
2635  .analog_output = 0,
2636 
2637  .wbd_vhf_offset = 0,
2638  .wbd_cband_offset = 0,
2639  .use_pwm_agc = 1,
2640  .clkoutdrive = 0,
2641 
2642  .fref_clock_ratio = 0,
2643 
2644  .wbd = dib7090_wbd_table,
2645 
2646  .ls_cfg_pad_drv = 0,
2647  .data_tx_drv = 0,
2648  .low_if = NULL,
2649  .in_soc = 1,
2650 };
2651 
2652 static const struct dib0090_config tfe7090e_dib0090_config = {
2653  .io.clock_khz = 12000,
2654  .io.pll_bypass = 0,
2655  .io.pll_range = 0,
2656  .io.pll_prediv = 3,
2657  .io.pll_loopdiv = 6,
2658  .io.adc_clock_ratio = 0,
2659  .io.pll_int_loop_filt = 0,
2660  .reset = dib7090_tuner_sleep,
2661  .sleep = dib7090_tuner_sleep,
2662 
2663  .freq_offset_khz_uhf = 0,
2664  .freq_offset_khz_vhf = 0,
2665 
2666  .get_adc_power = dib7090_get_adc_power,
2667 
2668  .clkouttobamse = 1,
2669  .analog_output = 0,
2670 
2671  .wbd_vhf_offset = 0,
2672  .wbd_cband_offset = 0,
2673  .use_pwm_agc = 1,
2674  .clkoutdrive = 0,
2675 
2676  .fref_clock_ratio = 0,
2677 
2678  .wbd = dib7090e_wbd_table,
2679 
2680  .ls_cfg_pad_drv = 0,
2681  .data_tx_drv = 0,
2682  .low_if = NULL,
2683  .in_soc = 1,
2684  .force_cband_input = 1,
2685  .is_dib7090e = 1,
2686 };
2687 
2688 static struct dib7000p_config tfe7790e_dib7000p_config = {
2689  .output_mpeg2_in_188_bytes = 1,
2690  .hostbus_diversity = 1,
2691  .tuner_is_baseband = 1,
2692  .update_lna = dib7090e_update_lna,
2693 
2694  .agc_config_count = 2,
2695  .agc = dib7090_agc_config,
2696 
2697  .bw = &dib7090_clock_config_12_mhz,
2698 
2699  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2700  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2701  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2702 
2703  .pwm_freq_div = 0,
2704 
2705  .agc_control = dib7090_agc_restart,
2706 
2707  .spur_protect = 0,
2708  .disable_sample_and_hold = 0,
2709  .enable_current_mirror = 0,
2710  .diversity_delay = 0,
2711 
2712  .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2713  .enMpegOutput = 1,
2714 };
2715 
2716 static const struct dib0090_config tfe7790e_dib0090_config = {
2717  .io.clock_khz = 12000,
2718  .io.pll_bypass = 0,
2719  .io.pll_range = 0,
2720  .io.pll_prediv = 3,
2721  .io.pll_loopdiv = 6,
2722  .io.adc_clock_ratio = 0,
2723  .io.pll_int_loop_filt = 0,
2724  .reset = dib7090_tuner_sleep,
2725  .sleep = dib7090_tuner_sleep,
2726 
2727  .freq_offset_khz_uhf = 0,
2728  .freq_offset_khz_vhf = 0,
2729 
2730  .get_adc_power = dib7090_get_adc_power,
2731 
2732  .clkouttobamse = 1,
2733  .analog_output = 0,
2734 
2735  .wbd_vhf_offset = 0,
2736  .wbd_cband_offset = 0,
2737  .use_pwm_agc = 1,
2738  .clkoutdrive = 0,
2739 
2740  .fref_clock_ratio = 0,
2741 
2742  .wbd = dib7090e_wbd_table,
2743 
2744  .ls_cfg_pad_drv = 0,
2745  .data_tx_drv = 0,
2746  .low_if = NULL,
2747  .in_soc = 1,
2748  .force_cband_input = 1,
2749  .is_dib7090e = 1,
2750  .force_crystal_mode = 1,
2751 };
2752 
2753 static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2754  {
2755  .io.clock_khz = 12000,
2756  .io.pll_bypass = 0,
2757  .io.pll_range = 0,
2758  .io.pll_prediv = 3,
2759  .io.pll_loopdiv = 6,
2760  .io.adc_clock_ratio = 0,
2761  .io.pll_int_loop_filt = 0,
2762  .reset = dib7090_tuner_sleep,
2763  .sleep = dib7090_tuner_sleep,
2764 
2765  .freq_offset_khz_uhf = 50,
2766  .freq_offset_khz_vhf = 70,
2767 
2768  .get_adc_power = dib7090_get_adc_power,
2769 
2770  .clkouttobamse = 1,
2771  .analog_output = 0,
2772 
2773  .wbd_vhf_offset = 0,
2774  .wbd_cband_offset = 0,
2775  .use_pwm_agc = 1,
2776  .clkoutdrive = 0,
2777 
2778  .fref_clock_ratio = 0,
2779 
2780  .wbd = dib7090_wbd_table,
2781 
2782  .ls_cfg_pad_drv = 0,
2783  .data_tx_drv = 0,
2784  .low_if = NULL,
2785  .in_soc = 1,
2786  }, {
2787  .io.clock_khz = 12000,
2788  .io.pll_bypass = 0,
2789  .io.pll_range = 0,
2790  .io.pll_prediv = 3,
2791  .io.pll_loopdiv = 6,
2792  .io.adc_clock_ratio = 0,
2793  .io.pll_int_loop_filt = 0,
2794  .reset = dib7090_tuner_sleep,
2795  .sleep = dib7090_tuner_sleep,
2796 
2797  .freq_offset_khz_uhf = -50,
2798  .freq_offset_khz_vhf = -70,
2799 
2800  .get_adc_power = dib7090_get_adc_power,
2801 
2802  .clkouttobamse = 1,
2803  .analog_output = 0,
2804 
2805  .wbd_vhf_offset = 0,
2806  .wbd_cband_offset = 0,
2807  .use_pwm_agc = 1,
2808  .clkoutdrive = 0,
2809 
2810  .fref_clock_ratio = 0,
2811 
2812  .wbd = dib7090_wbd_table,
2813 
2814  .ls_cfg_pad_drv = 0,
2815  .data_tx_drv = 0,
2816  .low_if = NULL,
2817  .in_soc = 1,
2818  }
2819 };
2820 
2821 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
2822 {
2823  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2824  msleep(20);
2825  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2826  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2827  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2828  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2829 
2830  msleep(20);
2831  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2832  msleep(20);
2833  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2834 
2835  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
2836  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2837  return -ENODEV;
2838  }
2839  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
2840 
2841  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2842 }
2843 
2844 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
2845 {
2846  struct dib0700_adapter_state *st = adap->priv;
2847  struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2848 
2849  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
2850  return -ENODEV;
2851 
2852  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2853 
2854  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2855  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2856  return 0;
2857 }
2858 
2859 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
2860 {
2861  struct dib0700_state *st = adap->dev->priv;
2862 
2863  /* The TFE7090 requires the dib0700 to not be in master mode */
2864  st->disable_streaming_master_mode = 1;
2865 
2866  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2867  msleep(20);
2868  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2869  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2870  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2871  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2872 
2873  msleep(20);
2874  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2875  msleep(20);
2876  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2877 
2878  /* initialize IC 0 */
2879  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
2880  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2881  return -ENODEV;
2882  }
2883 
2884  dib0700_set_i2c_speed(adap->dev, 340);
2885  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
2886  if (adap->fe_adap[0].fe == NULL)
2887  return -ENODEV;
2888 
2889  dib7090_slave_reset(adap->fe_adap[0].fe);
2890 
2891  return 0;
2892 }
2893 
2894 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
2895 {
2896  struct i2c_adapter *i2c;
2897 
2898  if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
2899  err("the master dib7090 has to be initialized first");
2900  return -ENODEV; /* the master device has not been initialized */
2901  }
2902 
2903  i2c = dib7000p_get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
2904  if (dib7000p_i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
2905  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2906  return -ENODEV;
2907  }
2908 
2909  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
2910  dib0700_set_i2c_speed(adap->dev, 200);
2911 
2912  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2913 }
2914 
2915 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
2916 {
2917  struct dib0700_adapter_state *st = adap->priv;
2918  struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2919 
2920  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
2921  return -ENODEV;
2922 
2923  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2924 
2925  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2926  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2927  return 0;
2928 }
2929 
2930 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
2931 {
2932  struct dib0700_adapter_state *st = adap->priv;
2933  struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2934 
2935  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
2936  return -ENODEV;
2937 
2938  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2939 
2940  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2941  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2942  return 0;
2943 }
2944 
2945 static int tfe7090e_frontend_attach(struct dvb_usb_adapter *adap)
2946 {
2947  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2948  msleep(20);
2949  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2950  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2951  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2952  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2953 
2954  msleep(20);
2955  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2956  msleep(20);
2957  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2958 
2959  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap,
2960  1, 0x10, &tfe7090e_dib7000p_config) != 0) {
2961  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
2962  __func__);
2963  return -ENODEV;
2964  }
2965  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
2966  0x80, &tfe7090e_dib7000p_config);
2967 
2968  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2969 }
2970 
2971 static int tfe7790e_frontend_attach(struct dvb_usb_adapter *adap)
2972 {
2973  struct dib0700_state *st = adap->dev->priv;
2974 
2975  /* The TFE7790E requires the dib0700 to not be in master mode */
2976  st->disable_streaming_master_mode = 1;
2977 
2978  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2979  msleep(20);
2980  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2981  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2982  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2983  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2984  msleep(20);
2985  dib0700_ctrl_clock(adap->dev, 72, 1);
2986  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2987  msleep(20);
2988  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2989 
2990  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap,
2991  1, 0x10, &tfe7790e_dib7000p_config) != 0) {
2992  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
2993  __func__);
2994  return -ENODEV;
2995  }
2996  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
2997  0x80, &tfe7790e_dib7000p_config);
2998 
2999  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3000 }
3001 
3002 static int tfe7790e_tuner_attach(struct dvb_usb_adapter *adap)
3003 {
3004  struct dib0700_adapter_state *st = adap->priv;
3005  struct i2c_adapter *tun_i2c =
3006  dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
3007 
3008  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3009  &tfe7790e_dib0090_config) == NULL)
3010  return -ENODEV;
3011 
3012  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3013 
3014  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3015  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3016  return 0;
3017 }
3018 
3019 static int tfe7090e_tuner_attach(struct dvb_usb_adapter *adap)
3020 {
3021  struct dib0700_adapter_state *st = adap->priv;
3022  struct i2c_adapter *tun_i2c =
3023  dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
3024 
3025  if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3026  &tfe7090e_dib0090_config) == NULL)
3027  return -ENODEV;
3028 
3029  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3030 
3031  st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3032  adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3033  return 0;
3034 }
3035 
3036 /* STK7070PD */
3037 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
3038  {
3039  .output_mpeg2_in_188_bytes = 1,
3040 
3041  .agc_config_count = 1,
3042  .agc = &dib7070_agc_config,
3043  .bw = &dib7070_bw_config_12_mhz,
3044  .tuner_is_baseband = 1,
3045  .spur_protect = 1,
3046 
3047  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3048  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3049  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3050 
3051  .hostbus_diversity = 1,
3052  }, {
3053  .output_mpeg2_in_188_bytes = 1,
3054 
3055  .agc_config_count = 1,
3056  .agc = &dib7070_agc_config,
3057  .bw = &dib7070_bw_config_12_mhz,
3058  .tuner_is_baseband = 1,
3059  .spur_protect = 1,
3060 
3061  .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3062  .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3063  .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3064 
3065  .hostbus_diversity = 1,
3066  }
3067 };
3068 
3069 static void stk7070pd_init(struct dvb_usb_device *dev)
3070 {
3071  dib0700_set_gpio(dev, GPIO6, GPIO_OUT, 1);
3072  msleep(10);
3073  dib0700_set_gpio(dev, GPIO9, GPIO_OUT, 1);
3074  dib0700_set_gpio(dev, GPIO4, GPIO_OUT, 1);
3075  dib0700_set_gpio(dev, GPIO7, GPIO_OUT, 1);
3076  dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 0);
3077 
3078  dib0700_ctrl_clock(dev, 72, 1);
3079 
3080  msleep(10);
3081  dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 1);
3082 }
3083 
3084 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
3085 {
3086  stk7070pd_init(adap->dev);
3087 
3088  msleep(10);
3089  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3090 
3091  if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
3092  stk7070pd_dib7000p_config) != 0) {
3093  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
3094  __func__);
3095  return -ENODEV;
3096  }
3097 
3098  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
3099  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3100 }
3101 
3102 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
3103 {
3104  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
3105  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3106 }
3107 
3108 static int novatd_read_status_override(struct dvb_frontend *fe,
3109  fe_status_t *stat)
3110 {
3111  struct dvb_usb_adapter *adap = fe->dvb->priv;
3112  struct dvb_usb_device *dev = adap->dev;
3113  struct dib0700_state *state = dev->priv;
3114  int ret;
3115 
3116  ret = state->read_status(fe, stat);
3117 
3118  if (!ret)
3119  dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3120  !!(*stat & FE_HAS_LOCK));
3121 
3122  return ret;
3123 }
3124 
3125 static int novatd_sleep_override(struct dvb_frontend* fe)
3126 {
3127  struct dvb_usb_adapter *adap = fe->dvb->priv;
3128  struct dvb_usb_device *dev = adap->dev;
3129  struct dib0700_state *state = dev->priv;
3130 
3131  /* turn off LED */
3132  dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, 0);
3133 
3134  return state->sleep(fe);
3135 }
3136 
3143 static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
3144 {
3145  struct dvb_usb_device *dev = adap->dev;
3146  struct dib0700_state *st = dev->priv;
3147 
3148  if (adap->id == 0) {
3149  stk7070pd_init(dev);
3150 
3151  /* turn the power LED on, the other two off (just in case) */
3152  dib0700_set_gpio(dev, GPIO0, GPIO_OUT, 0);
3153  dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
3154  dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
3155 
3156  if (dib7000p_i2c_enumeration(&dev->i2c_adap, 2, 18,
3157  stk7070pd_dib7000p_config) != 0) {
3158  err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
3159  __func__);
3160  return -ENODEV;
3161  }
3162  }
3163 
3164  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &dev->i2c_adap,
3165  adap->id == 0 ? 0x80 : 0x82,
3166  &stk7070pd_dib7000p_config[adap->id]);
3167 
3168  if (adap->fe_adap[0].fe == NULL)
3169  return -ENODEV;
3170 
3171  st->read_status = adap->fe_adap[0].fe->ops.read_status;
3172  adap->fe_adap[0].fe->ops.read_status = novatd_read_status_override;
3173  st->sleep = adap->fe_adap[0].fe->ops.sleep;
3174  adap->fe_adap[0].fe->ops.sleep = novatd_sleep_override;
3175 
3176  return 0;
3177 }
3178 
3179 /* S5H1411 */
3180 static struct s5h1411_config pinnacle_801e_config = {
3181  .output_mode = S5H1411_PARALLEL_OUTPUT,
3182  .gpio = S5H1411_GPIO_OFF,
3183  .mpeg_timing = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
3184  .qam_if = S5H1411_IF_44000,
3185  .vsb_if = S5H1411_IF_44000,
3186  .inversion = S5H1411_INVERSION_OFF,
3187  .status_mode = S5H1411_DEMODLOCKING
3188 };
3189 
3190 /* Pinnacle PCTV HD Pro 801e GPIOs map:
3191  GPIO0 - currently unknown
3192  GPIO1 - xc5000 tuner reset
3193  GPIO2 - CX25843 sleep
3194  GPIO3 - currently unknown
3195  GPIO4 - currently unknown
3196  GPIO6 - currently unknown
3197  GPIO7 - currently unknown
3198  GPIO9 - currently unknown
3199  GPIO10 - CX25843 reset
3200  */
3201 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
3202 {
3203  struct dib0700_state *st = adap->dev->priv;
3204 
3205  /* Make use of the new i2c functions from FW 1.20 */
3206  st->fw_use_new_i2c_api = 1;
3207 
3208  /* The s5h1411 requires the dib0700 to not be in master mode */
3209  st->disable_streaming_master_mode = 1;
3210 
3211  /* All msleep values taken from Windows USB trace */
3212  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
3213  dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
3214  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3215  msleep(400);
3216  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3217  msleep(60);
3218  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3219  msleep(30);
3220  dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3221  dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3222  dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3223  dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3224  dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
3225  msleep(30);
3226 
3227  /* Put the CX25843 to sleep for now since we're in digital mode */
3228  dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3229 
3230  /* GPIOs are initialized, do the attach */
3231  adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
3232  &adap->dev->i2c_adap);
3233  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3234 }
3235 
3236 static int dib0700_xc5000_tuner_callback(void *priv, int component,
3237  int command, int arg)
3238 {
3239  struct dvb_usb_adapter *adap = priv;
3240 
3241  if (command == XC5000_TUNER_RESET) {
3242  /* Reset the tuner */
3243  dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
3244  msleep(10);
3245  dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
3246  msleep(10);
3247  } else {
3248  err("xc5000: unknown tuner callback command: %d\n", command);
3249  return -EINVAL;
3250  }
3251 
3252  return 0;
3253 }
3254 
3255 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3256  .i2c_address = 0x64,
3257  .if_khz = 5380,
3258 };
3259 
3260 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
3261 {
3262  /* FIXME: generalize & move to common area */
3263  adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
3264 
3265  return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
3266  &s5h1411_xc5000_tunerconfig)
3267  == NULL ? -ENODEV : 0;
3268 }
3269 
3270 static int dib0700_xc4000_tuner_callback(void *priv, int component,
3271  int command, int arg)
3272 {
3273  struct dvb_usb_adapter *adap = priv;
3274 
3275  if (command == XC4000_TUNER_RESET) {
3276  /* Reset the tuner */
3277  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
3278  msleep(10);
3279  dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3280  } else {
3281  err("xc4000: unknown tuner callback command: %d\n", command);
3282  return -EINVAL;
3283  }
3284 
3285  return 0;
3286 }
3287 
3288 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
3289  .band_caps = BAND_UHF | BAND_VHF,
3290  .setup = 0x64,
3291  .inv_gain = 0x02c8,
3292  .time_stabiliz = 0x15,
3293  .alpha_level = 0x00,
3294  .thlock = 0x76,
3295  .wbd_inv = 0x01,
3296  .wbd_ref = 0x0b33,
3297  .wbd_sel = 0x00,
3298  .wbd_alpha = 0x02,
3299  .agc1_max = 0x00,
3300  .agc1_min = 0x00,
3301  .agc2_max = 0x9b26,
3302  .agc2_min = 0x26ca,
3303  .agc1_pt1 = 0x00,
3304  .agc1_pt2 = 0x00,
3305  .agc1_pt3 = 0x00,
3306  .agc1_slope1 = 0x00,
3307  .agc1_slope2 = 0x00,
3308  .agc2_pt1 = 0x00,
3309  .agc2_pt2 = 0x80,
3310  .agc2_slope1 = 0x1d,
3311  .agc2_slope2 = 0x1d,
3312  .alpha_mant = 0x11,
3313  .alpha_exp = 0x1b,
3314  .beta_mant = 0x17,
3315  .beta_exp = 0x33,
3316  .perform_agc_softsplit = 0x00,
3317 };
3318 
3319 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
3320  60000, 30000, /* internal, sampling */
3321  1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
3322  0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, */
3323  /* ADClkSrc, modulo */
3324  (3 << 14) | (1 << 12) | 524, /* sad_cfg: refsel, sel, freq_15k */
3325  39370534, /* ifreq */
3326  20452225, /* timf */
3327  30000000 /* xtal */
3328 };
3329 
3330 /* FIXME: none of these inputs are validated yet */
3331 static struct dib7000p_config pctv_340e_config = {
3332  .output_mpeg2_in_188_bytes = 1,
3333 
3334  .agc_config_count = 1,
3335  .agc = &stk7700p_7000p_xc4000_agc_config,
3336  .bw = &stk7700p_xc4000_pll_config,
3337 
3338  .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
3339  .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
3340  .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
3341 };
3342 
3343 /* PCTV 340e GPIOs map:
3344  dib0700:
3345  GPIO2 - CX25843 sleep
3346  GPIO3 - CS5340 reset
3347  GPIO5 - IRD
3348  GPIO6 - Power Supply
3349  GPIO8 - LNA (1=off 0=on)
3350  GPIO10 - CX25843 reset
3351  dib7000:
3352  GPIO8 - xc4000 reset
3353  */
3354 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
3355 {
3356  struct dib0700_state *st = adap->dev->priv;
3357 
3358  /* Power Supply on */
3359  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3360  msleep(50);
3361  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3362  msleep(100); /* Allow power supply to settle before probing */
3363 
3364  /* cx25843 reset */
3365  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3366  msleep(1); /* cx25843 datasheet say 350us required */
3367  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3368 
3369  /* LNA off for now */
3370  dib0700_set_gpio(adap->dev, GPIO8, GPIO_OUT, 1);
3371 
3372  /* Put the CX25843 to sleep for now since we're in digital mode */
3373  dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3374 
3375  /* FIXME: not verified yet */
3376  dib0700_ctrl_clock(adap->dev, 72, 1);
3377 
3378  msleep(500);
3379 
3380  if (dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
3381  /* Demodulator not found for some reason? */
3382  return -ENODEV;
3383  }
3384 
3385  adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x12,
3386  &pctv_340e_config);
3387  st->is_dib7000pc = 1;
3388 
3389  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3390 }
3391 
3392 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
3393  .i2c_address = 0x61,
3394  .default_pm = 1,
3395  .dvb_amplitude = 0,
3396  .set_smoothedcvbs = 0,
3397  .if_khz = 5400
3398 };
3399 
3400 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
3401 {
3402  struct i2c_adapter *tun_i2c;
3403 
3404  /* The xc4000 is not on the main i2c bus */
3405  tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
3406  DIBX000_I2C_INTERFACE_TUNER, 1);
3407  if (tun_i2c == NULL) {
3408  printk(KERN_ERR "Could not reach tuner i2c bus\n");
3409  return 0;
3410  }
3411 
3412  /* Setup the reset callback */
3413  adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
3414 
3415  return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
3416  &dib7000p_xc4000_tunerconfig)
3417  == NULL ? -ENODEV : 0;
3418 }
3419 
3420 static struct lgdt3305_config hcw_lgdt3305_config = {
3421  .i2c_addr = 0x0e,
3422  .mpeg_mode = LGDT3305_MPEG_PARALLEL,
3423  .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
3424  .tpvalid_polarity = LGDT3305_TP_VALID_LOW,
3425  .deny_i2c_rptr = 0,
3426  .spectral_inversion = 1,
3427  .qam_if_khz = 6000,
3428  .vsb_if_khz = 6000,
3429  .usref_8vsb = 0x0500,
3430 };
3431 
3432 static struct mxl5007t_config hcw_mxl5007t_config = {
3433  .xtal_freq_hz = MxL_XTAL_25_MHZ,
3434  .if_freq_hz = MxL_IF_6_MHZ,
3435  .invert_if = 1,
3436 };
3437 
3438 /* TIGER-ATSC map:
3439  GPIO0 - LNA_CTR (H: LNA power enabled, L: LNA power disabled)
3440  GPIO1 - ANT_SEL (H: VPA, L: MCX)
3441  GPIO4 - SCL2
3442  GPIO6 - EN_TUNER
3443  GPIO7 - SDA2
3444  GPIO10 - DEM_RST
3445 
3446  MXL is behind LG's i2c repeater. LG is on SCL2/SDA2 gpios on the DIB
3447  */
3448 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
3449 {
3450  struct dib0700_state *st = adap->dev->priv;
3451 
3452  /* Make use of the new i2c functions from FW 1.20 */
3453  st->fw_use_new_i2c_api = 1;
3454 
3455  st->disable_streaming_master_mode = 1;
3456 
3457  /* fe power enable */
3458  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3459  msleep(30);
3460  dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3461  msleep(30);
3462 
3463  /* demod reset */
3464  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3465  msleep(30);
3466  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3467  msleep(30);
3468  dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3469  msleep(30);
3470 
3471  adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
3472  &hcw_lgdt3305_config,
3473  &adap->dev->i2c_adap);
3474 
3475  return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3476 }
3477 
3478 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
3479 {
3480  return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
3481  &adap->dev->i2c_adap, 0x60,
3482  &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
3483 }
3484 
3485 
3486 /* DVB-USB and USB stuff follows */
3487 struct usb_device_id dib0700_usb_id_table[] = {
3488 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) },
3489  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P_PC) },
3490  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
3491  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
3492  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
3493 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
3494  { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500) },
3495  { USB_DEVICE(USB_VID_UNIWILL, USB_PID_UNIWILL_STK7700P) },
3496  { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
3497  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
3498 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
3499  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV2000E) },
3500  { USB_DEVICE(USB_VID_TERRATEC,
3501  USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
3502  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
3503  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700D) },
3504 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070P) },
3505  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
3506  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070PD) },
3507  { USB_DEVICE(USB_VID_PINNACLE,
3508  USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
3509  { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500_PC) },
3510 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
3511  { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
3512  { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
3513  { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000) },
3514  { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100) },
3515 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
3516  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
3517  { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
3518  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_EXPRESSCARD_320CX) },
3519  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV72E) },
3520 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73E) },
3521  { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_EC372S) },
3522  { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
3523  { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS) },
3524  { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
3525 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
3526  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
3527  { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U8000) },
3528  { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700PH) },
3529  { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000H) },
3530 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E) },
3531  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E_SE) },
3532  { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
3533  { USB_DEVICE(USB_VID_TERRATEC,
3534  USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
3535  { USB_DEVICE(USB_VID_SONY, USB_PID_SONY_PLAYTV) },
3536 /* 45 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_PD378S) },
3537  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
3538  { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
3539  { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_MC770) },
3540  { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT) },
3541 /* 50 */{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_Dlx) },
3542  { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_H) },
3543  { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T3) },
3544  { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T5) },
3545  { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D) },
3546 /* 55 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D_2) },
3547  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73A) },
3548  { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV73ESE) },
3549  { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV282E) },
3550  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7770P) },
3551 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS_2) },
3552  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XPVR) },
3553  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XP) },
3554  { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
3555  { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
3556 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73ESE) },
3557  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV282E) },
3558  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK8096GP) },
3559  { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DIVERSITY) },
3560  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090M) },
3561 /* 70 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM8096MD) },
3562  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090MD) },
3563  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM7090) },
3564  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7090PVR) },
3565  { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
3566 /* 75 */{ USB_DEVICE(USB_VID_MEDION, USB_PID_CREATIX_CTX1921) },
3567  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E) },
3568  { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E_SE) },
3569  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7090E) },
3570  { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7790E) },
3571 /* 80 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE8096P) },
3572  { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_2) },
3573  { 0 } /* Terminating entry */
3574 };
3575 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
3576 
3577 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
3578  .caps = DVB_USB_IS_AN_I2C_ADAPTER, \
3579  .usb_ctrl = DEVICE_SPECIFIC, \
3580  .firmware = "dvb-usb-dib0700-1.20.fw", \
3581  .download_firmware = dib0700_download_firmware, \
3582  .no_reconnect = 1, \
3583  .size_of_priv = sizeof(struct dib0700_state), \
3584  .i2c_algo = &dib0700_i2c_algo, \
3585  .identify_state = dib0700_identify_state
3586 
3587 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
3588  .streaming_ctrl = dib0700_streaming_ctrl, \
3589  .stream = { \
3590  .type = USB_BULK, \
3591  .count = 4, \
3592  .endpoint = ep, \
3593  .u = { \
3594  .bulk = { \
3595  .buffersize = 39480, \
3596  } \
3597  } \
3598  }
3599 
3600 struct dvb_usb_device_properties dib0700_devices[] = {
3601  {
3602  DIB0700_DEFAULT_DEVICE_PROPERTIES,
3603 
3604  .num_adapters = 1,
3605  .adapter = {
3606  {
3607  .num_frontends = 1,
3608  .fe = {{
3609  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3610  .pid_filter_count = 32,
3611  .pid_filter = stk7700p_pid_filter,
3612  .pid_filter_ctrl = stk7700p_pid_filter_ctrl,
3613  .frontend_attach = stk7700p_frontend_attach,
3614  .tuner_attach = stk7700p_tuner_attach,
3615 
3616  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3617  }},
3618  },
3619  },
3620 
3621  .num_device_descs = 8,
3622  .devices = {
3623  { "DiBcom STK7700P reference design",
3624  { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
3625  { NULL },
3626  },
3627  { "Hauppauge Nova-T Stick",
3628  { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
3629  { NULL },
3630  },
3631  { "AVerMedia AVerTV DVB-T Volar",
3632  { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
3633  { NULL },
3634  },
3635  { "Compro Videomate U500",
3636  { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
3637  { NULL },
3638  },
3639  { "Uniwill STK7700P based (Hama and others)",
3640  { &dib0700_usb_id_table[7], NULL },
3641  { NULL },
3642  },
3643  { "Leadtek Winfast DTV Dongle (STK7700P based)",
3644  { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
3645  { NULL },
3646  },
3647  { "AVerMedia AVerTV DVB-T Express",
3648  { &dib0700_usb_id_table[20] },
3649  { NULL },
3650  },
3651  { "Gigabyte U7000",
3652  { &dib0700_usb_id_table[21], NULL },
3653  { NULL },
3654  }
3655  },
3656 
3657  .rc.core = {
3658  .rc_interval = DEFAULT_RC_INTERVAL,
3659  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3660  .rc_query = dib0700_rc_query_old_firmware,
3661  .allowed_protos = RC_TYPE_RC5 |
3662  RC_TYPE_RC6 |
3663  RC_TYPE_NEC,
3664  .change_protocol = dib0700_change_protocol,
3665  },
3666  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3667 
3668  .num_adapters = 2,
3669  .adapter = {
3670  {
3671  .num_frontends = 1,
3672  .fe = {{
3673  .frontend_attach = bristol_frontend_attach,
3674  .tuner_attach = bristol_tuner_attach,
3675 
3676  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3677  }},
3678  }, {
3679  .num_frontends = 1,
3680  .fe = {{
3681  .frontend_attach = bristol_frontend_attach,
3682  .tuner_attach = bristol_tuner_attach,
3683 
3684  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3685  }},
3686  }
3687  },
3688 
3689  .num_device_descs = 1,
3690  .devices = {
3691  { "Hauppauge Nova-T 500 Dual DVB-T",
3692  { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
3693  { NULL },
3694  },
3695  },
3696 
3697  .rc.core = {
3698  .rc_interval = DEFAULT_RC_INTERVAL,
3699  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3700  .rc_query = dib0700_rc_query_old_firmware,
3701  .allowed_protos = RC_TYPE_RC5 |
3702  RC_TYPE_RC6 |
3703  RC_TYPE_NEC,
3704  .change_protocol = dib0700_change_protocol,
3705  },
3706  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3707 
3708  .num_adapters = 2,
3709  .adapter = {
3710  {
3711  .num_frontends = 1,
3712  .fe = {{
3713  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3714  .pid_filter_count = 32,
3715  .pid_filter = stk70x0p_pid_filter,
3716  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3717  .frontend_attach = stk7700d_frontend_attach,
3718  .tuner_attach = stk7700d_tuner_attach,
3719 
3720  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3721  }},
3722  }, {
3723  .num_frontends = 1,
3724  .fe = {{
3725  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3726  .pid_filter_count = 32,
3727  .pid_filter = stk70x0p_pid_filter,
3728  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3729  .frontend_attach = stk7700d_frontend_attach,
3730  .tuner_attach = stk7700d_tuner_attach,
3731 
3732  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3733  }},
3734  }
3735  },
3736 
3737  .num_device_descs = 5,
3738  .devices = {
3739  { "Pinnacle PCTV 2000e",
3740  { &dib0700_usb_id_table[11], NULL },
3741  { NULL },
3742  },
3743  { "Terratec Cinergy DT XS Diversity",
3744  { &dib0700_usb_id_table[12], NULL },
3745  { NULL },
3746  },
3747  { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
3748  { &dib0700_usb_id_table[13], NULL },
3749  { NULL },
3750  },
3751  { "DiBcom STK7700D reference design",
3752  { &dib0700_usb_id_table[14], NULL },
3753  { NULL },
3754  },
3755  { "YUAN High-Tech DiBcom STK7700D",
3756  { &dib0700_usb_id_table[55], NULL },
3757  { NULL },
3758  },
3759 
3760  },
3761 
3762  .rc.core = {
3763  .rc_interval = DEFAULT_RC_INTERVAL,
3764  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3765  .rc_query = dib0700_rc_query_old_firmware,
3766  .allowed_protos = RC_TYPE_RC5 |
3767  RC_TYPE_RC6 |
3768  RC_TYPE_NEC,
3769  .change_protocol = dib0700_change_protocol,
3770  },
3771  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3772 
3773  .num_adapters = 1,
3774  .adapter = {
3775  {
3776  .num_frontends = 1,
3777  .fe = {{
3778  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3779  .pid_filter_count = 32,
3780  .pid_filter = stk70x0p_pid_filter,
3781  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3782  .frontend_attach = stk7700P2_frontend_attach,
3783  .tuner_attach = stk7700d_tuner_attach,
3784 
3785  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3786  }},
3787  },
3788  },
3789 
3790  .num_device_descs = 3,
3791  .devices = {
3792  { "ASUS My Cinema U3000 Mini DVBT Tuner",
3793  { &dib0700_usb_id_table[23], NULL },
3794  { NULL },
3795  },
3796  { "Yuan EC372S",
3797  { &dib0700_usb_id_table[31], NULL },
3798  { NULL },
3799  },
3800  { "Terratec Cinergy T Express",
3801  { &dib0700_usb_id_table[42], NULL },
3802  { NULL },
3803  }
3804  },
3805 
3806  .rc.core = {
3807  .rc_interval = DEFAULT_RC_INTERVAL,
3808  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3809  .module_name = "dib0700",
3810  .rc_query = dib0700_rc_query_old_firmware,
3811  .allowed_protos = RC_TYPE_RC5 |
3812  RC_TYPE_RC6 |
3813  RC_TYPE_NEC,
3814  .change_protocol = dib0700_change_protocol,
3815  },
3816  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3817 
3818  .num_adapters = 1,
3819  .adapter = {
3820  {
3821  .num_frontends = 1,
3822  .fe = {{
3823  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3824  .pid_filter_count = 32,
3825  .pid_filter = stk70x0p_pid_filter,
3826  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3827  .frontend_attach = stk7070p_frontend_attach,
3828  .tuner_attach = dib7070p_tuner_attach,
3829 
3830  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3831  }},
3832  .size_of_priv = sizeof(struct dib0700_adapter_state),
3833  },
3834  },
3835 
3836  .num_device_descs = 12,
3837  .devices = {
3838  { "DiBcom STK7070P reference design",
3839  { &dib0700_usb_id_table[15], NULL },
3840  { NULL },
3841  },
3842  { "Pinnacle PCTV DVB-T Flash Stick",
3843  { &dib0700_usb_id_table[16], NULL },
3844  { NULL },
3845  },
3846  { "Artec T14BR DVB-T",
3847  { &dib0700_usb_id_table[22], NULL },
3848  { NULL },
3849  },
3850  { "ASUS My Cinema U3100 Mini DVBT Tuner",
3851  { &dib0700_usb_id_table[24], NULL },
3852  { NULL },
3853  },
3854  { "Hauppauge Nova-T Stick",
3855  { &dib0700_usb_id_table[25], NULL },
3856  { NULL },
3857  },
3858  { "Hauppauge Nova-T MyTV.t",
3859  { &dib0700_usb_id_table[26], NULL },
3860  { NULL },
3861  },
3862  { "Pinnacle PCTV 72e",
3863  { &dib0700_usb_id_table[29], NULL },
3864  { NULL },
3865  },
3866  { "Pinnacle PCTV 73e",
3867  { &dib0700_usb_id_table[30], NULL },
3868  { NULL },
3869  },
3870  { "Elgato EyeTV DTT",
3871  { &dib0700_usb_id_table[49], NULL },
3872  { NULL },
3873  },
3874  { "Yuan PD378S",
3875  { &dib0700_usb_id_table[45], NULL },
3876  { NULL },
3877  },
3878  { "Elgato EyeTV Dtt Dlx PD378S",
3879  { &dib0700_usb_id_table[50], NULL },
3880  { NULL },
3881  },
3882  { "Elgato EyeTV DTT rev. 2",
3883  { &dib0700_usb_id_table[81], NULL },
3884  { NULL },
3885  },
3886  },
3887 
3888  .rc.core = {
3889  .rc_interval = DEFAULT_RC_INTERVAL,
3890  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3891  .module_name = "dib0700",
3892  .rc_query = dib0700_rc_query_old_firmware,
3893  .allowed_protos = RC_TYPE_RC5 |
3894  RC_TYPE_RC6 |
3895  RC_TYPE_NEC,
3896  .change_protocol = dib0700_change_protocol,
3897  },
3898  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3899 
3900  .num_adapters = 1,
3901  .adapter = {
3902  {
3903  .num_frontends = 1,
3904  .fe = {{
3905  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3906  .pid_filter_count = 32,
3907  .pid_filter = stk70x0p_pid_filter,
3908  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3909  .frontend_attach = stk7070p_frontend_attach,
3910  .tuner_attach = dib7070p_tuner_attach,
3911 
3912  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3913  }},
3914  .size_of_priv = sizeof(struct dib0700_adapter_state),
3915  },
3916  },
3917 
3918  .num_device_descs = 3,
3919  .devices = {
3920  { "Pinnacle PCTV 73A",
3921  { &dib0700_usb_id_table[56], NULL },
3922  { NULL },
3923  },
3924  { "Pinnacle PCTV 73e SE",
3925  { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
3926  { NULL },
3927  },
3928  { "Pinnacle PCTV 282e",
3929  { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
3930  { NULL },
3931  },
3932  },
3933 
3934  .rc.core = {
3935  .rc_interval = DEFAULT_RC_INTERVAL,
3936  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3937  .module_name = "dib0700",
3938  .rc_query = dib0700_rc_query_old_firmware,
3939  .allowed_protos = RC_TYPE_RC5 |
3940  RC_TYPE_RC6 |
3941  RC_TYPE_NEC,
3942  .change_protocol = dib0700_change_protocol,
3943  },
3944  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3945 
3946  .num_adapters = 2,
3947  .adapter = {
3948  {
3949  .num_frontends = 1,
3950  .fe = {{
3951  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3952  .pid_filter_count = 32,
3953  .pid_filter = stk70x0p_pid_filter,
3954  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3955  .frontend_attach = novatd_frontend_attach,
3956  .tuner_attach = dib7070p_tuner_attach,
3957 
3958  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3959  }},
3960  .size_of_priv = sizeof(struct dib0700_adapter_state),
3961  }, {
3962  .num_frontends = 1,
3963  .fe = {{
3964  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3965  .pid_filter_count = 32,
3966  .pid_filter = stk70x0p_pid_filter,
3967  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3968  .frontend_attach = novatd_frontend_attach,
3969  .tuner_attach = dib7070p_tuner_attach,
3970 
3971  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3972  }},
3973  .size_of_priv = sizeof(struct dib0700_adapter_state),
3974  }
3975  },
3976 
3977  .num_device_descs = 1,
3978  .devices = {
3979  { "Hauppauge Nova-TD Stick (52009)",
3980  { &dib0700_usb_id_table[35], NULL },
3981  { NULL },
3982  },
3983  },
3984 
3985  .rc.core = {
3986  .rc_interval = DEFAULT_RC_INTERVAL,
3987  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3988  .module_name = "dib0700",
3989  .rc_query = dib0700_rc_query_old_firmware,
3990  .allowed_protos = RC_TYPE_RC5 |
3991  RC_TYPE_RC6 |
3992  RC_TYPE_NEC,
3993  .change_protocol = dib0700_change_protocol,
3994  },
3995  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3996 
3997  .num_adapters = 2,
3998  .adapter = {
3999  {
4000  .num_frontends = 1,
4001  .fe = {{
4002  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4003  .pid_filter_count = 32,
4004  .pid_filter = stk70x0p_pid_filter,
4005  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4006  .frontend_attach = stk7070pd_frontend_attach0,
4007  .tuner_attach = dib7070p_tuner_attach,
4008 
4009  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4010  }},
4011  .size_of_priv = sizeof(struct dib0700_adapter_state),
4012  }, {
4013  .num_frontends = 1,
4014  .fe = {{
4015  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4016  .pid_filter_count = 32,
4017  .pid_filter = stk70x0p_pid_filter,
4018  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4019  .frontend_attach = stk7070pd_frontend_attach1,
4020  .tuner_attach = dib7070p_tuner_attach,
4021 
4022  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4023  }},
4024  .size_of_priv = sizeof(struct dib0700_adapter_state),
4025  }
4026  },
4027 
4028  .num_device_descs = 5,
4029  .devices = {
4030  { "DiBcom STK7070PD reference design",
4031  { &dib0700_usb_id_table[17], NULL },
4032  { NULL },
4033  },
4034  { "Pinnacle PCTV Dual DVB-T Diversity Stick",
4035  { &dib0700_usb_id_table[18], NULL },
4036  { NULL },
4037  },
4038  { "Hauppauge Nova-TD-500 (84xxx)",
4039  { &dib0700_usb_id_table[36], NULL },
4040  { NULL },
4041  },
4042  { "Terratec Cinergy DT USB XS Diversity/ T5",
4043  { &dib0700_usb_id_table[43],
4044  &dib0700_usb_id_table[53], NULL},
4045  { NULL },
4046  },
4047  { "Sony PlayTV",
4048  { &dib0700_usb_id_table[44], NULL },
4049  { NULL },
4050  },
4051  },
4052 
4053  .rc.core = {
4054  .rc_interval = DEFAULT_RC_INTERVAL,
4055  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4056  .module_name = "dib0700",
4057  .rc_query = dib0700_rc_query_old_firmware,
4058  .allowed_protos = RC_TYPE_RC5 |
4059  RC_TYPE_RC6 |
4060  RC_TYPE_NEC,
4061  .change_protocol = dib0700_change_protocol,
4062  },
4063  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4064 
4065  .num_adapters = 2,
4066  .adapter = {
4067  {
4068  .num_frontends = 1,
4069  .fe = {{
4070  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4071  .pid_filter_count = 32,
4072  .pid_filter = stk70x0p_pid_filter,
4073  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4074  .frontend_attach = stk7070pd_frontend_attach0,
4075  .tuner_attach = dib7070p_tuner_attach,
4076 
4077  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4078  }},
4079  .size_of_priv = sizeof(struct dib0700_adapter_state),
4080  }, {
4081  .num_frontends = 1,
4082  .fe = {{
4083  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4084  .pid_filter_count = 32,
4085  .pid_filter = stk70x0p_pid_filter,
4086  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4087  .frontend_attach = stk7070pd_frontend_attach1,
4088  .tuner_attach = dib7070p_tuner_attach,
4089 
4090  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4091  }},
4092  .size_of_priv = sizeof(struct dib0700_adapter_state),
4093  }
4094  },
4095 
4096  .num_device_descs = 1,
4097  .devices = {
4098  { "Elgato EyeTV Diversity",
4099  { &dib0700_usb_id_table[68], NULL },
4100  { NULL },
4101  },
4102  },
4103 
4104  .rc.core = {
4105  .rc_interval = DEFAULT_RC_INTERVAL,
4106  .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
4107  .module_name = "dib0700",
4108  .rc_query = dib0700_rc_query_old_firmware,
4109  .allowed_protos = RC_TYPE_RC5 |
4110  RC_TYPE_RC6 |
4111  RC_TYPE_NEC,
4112  .change_protocol = dib0700_change_protocol,
4113  },
4114  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4115 
4116  .num_adapters = 1,
4117  .adapter = {
4118  {
4119  .num_frontends = 1,
4120  .fe = {{
4121  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4122  .pid_filter_count = 32,
4123  .pid_filter = stk70x0p_pid_filter,
4124  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4125  .frontend_attach = stk7700ph_frontend_attach,
4126  .tuner_attach = stk7700ph_tuner_attach,
4127 
4128  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4129  }},
4130  .size_of_priv = sizeof(struct
4131  dib0700_adapter_state),
4132  },
4133  },
4134 
4135  .num_device_descs = 9,
4136  .devices = {
4137  { "Terratec Cinergy HT USB XE",
4138  { &dib0700_usb_id_table[27], NULL },
4139  { NULL },
4140  },
4141  { "Pinnacle Expresscard 320cx",
4142  { &dib0700_usb_id_table[28], NULL },
4143  { NULL },
4144  },
4145  { "Terratec Cinergy HT Express",
4146  { &dib0700_usb_id_table[32], NULL },
4147  { NULL },
4148  },
4149  { "Gigabyte U8000-RH",
4150  { &dib0700_usb_id_table[37], NULL },
4151  { NULL },
4152  },
4153  { "YUAN High-Tech STK7700PH",
4154  { &dib0700_usb_id_table[38], NULL },
4155  { NULL },
4156  },
4157  { "Asus My Cinema-U3000Hybrid",
4158  { &dib0700_usb_id_table[39], NULL },
4159  { NULL },
4160  },
4161  { "YUAN High-Tech MC770",
4162  { &dib0700_usb_id_table[48], NULL },
4163  { NULL },
4164  },
4165  { "Leadtek WinFast DTV Dongle H",
4166  { &dib0700_usb_id_table[51], NULL },
4167  { NULL },
4168  },
4169  { "YUAN High-Tech STK7700D",
4170  { &dib0700_usb_id_table[54], NULL },
4171  { NULL },
4172  },
4173  },
4174 
4175  .rc.core = {
4176  .rc_interval = DEFAULT_RC_INTERVAL,
4177  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4178  .module_name = "dib0700",
4179  .rc_query = dib0700_rc_query_old_firmware,
4180  .allowed_protos = RC_TYPE_RC5 |
4181  RC_TYPE_RC6 |
4182  RC_TYPE_NEC,
4183  .change_protocol = dib0700_change_protocol,
4184  },
4185  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4186  .num_adapters = 1,
4187  .adapter = {
4188  {
4189  .num_frontends = 1,
4190  .fe = {{
4191  .frontend_attach = s5h1411_frontend_attach,
4192  .tuner_attach = xc5000_tuner_attach,
4193 
4194  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4195  }},
4196  .size_of_priv = sizeof(struct
4197  dib0700_adapter_state),
4198  },
4199  },
4200 
4201  .num_device_descs = 2,
4202  .devices = {
4203  { "Pinnacle PCTV HD Pro USB Stick",
4204  { &dib0700_usb_id_table[40], NULL },
4205  { NULL },
4206  },
4207  { "Pinnacle PCTV HD USB Stick",
4208  { &dib0700_usb_id_table[41], NULL },
4209  { NULL },
4210  },
4211  },
4212 
4213  .rc.core = {
4214  .rc_interval = DEFAULT_RC_INTERVAL,
4215  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4216  .module_name = "dib0700",
4217  .rc_query = dib0700_rc_query_old_firmware,
4218  .allowed_protos = RC_TYPE_RC5 |
4219  RC_TYPE_RC6 |
4220  RC_TYPE_NEC,
4221  .change_protocol = dib0700_change_protocol,
4222  },
4223  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4224  .num_adapters = 1,
4225  .adapter = {
4226  {
4227  .num_frontends = 1,
4228  .fe = {{
4229  .frontend_attach = lgdt3305_frontend_attach,
4230  .tuner_attach = mxl5007t_tuner_attach,
4231 
4232  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4233  }},
4234  .size_of_priv = sizeof(struct
4235  dib0700_adapter_state),
4236  },
4237  },
4238 
4239  .num_device_descs = 2,
4240  .devices = {
4241  { "Hauppauge ATSC MiniCard (B200)",
4242  { &dib0700_usb_id_table[46], NULL },
4243  { NULL },
4244  },
4245  { "Hauppauge ATSC MiniCard (B210)",
4246  { &dib0700_usb_id_table[47], NULL },
4247  { NULL },
4248  },
4249  },
4250  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4251 
4252  .num_adapters = 1,
4253  .adapter = {
4254  {
4255  .num_frontends = 1,
4256  .fe = {{
4257  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4258  .pid_filter_count = 32,
4259  .pid_filter = stk70x0p_pid_filter,
4260  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4261  .frontend_attach = stk7770p_frontend_attach,
4262  .tuner_attach = dib7770p_tuner_attach,
4263 
4264  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4265  }},
4266  .size_of_priv =
4267  sizeof(struct dib0700_adapter_state),
4268  },
4269  },
4270 
4271  .num_device_descs = 4,
4272  .devices = {
4273  { "DiBcom STK7770P reference design",
4274  { &dib0700_usb_id_table[59], NULL },
4275  { NULL },
4276  },
4277  { "Terratec Cinergy T USB XXS (HD)/ T3",
4278  { &dib0700_usb_id_table[33],
4279  &dib0700_usb_id_table[52],
4280  &dib0700_usb_id_table[60], NULL},
4281  { NULL },
4282  },
4283  { "TechniSat AirStar TeleStick 2",
4284  { &dib0700_usb_id_table[74], NULL },
4285  { NULL },
4286  },
4287  { "Medion CTX1921 DVB-T USB",
4288  { &dib0700_usb_id_table[75], NULL },
4289  { NULL },
4290  },
4291  },
4292 
4293  .rc.core = {
4294  .rc_interval = DEFAULT_RC_INTERVAL,
4295  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4296  .module_name = "dib0700",
4297  .rc_query = dib0700_rc_query_old_firmware,
4298  .allowed_protos = RC_TYPE_RC5 |
4299  RC_TYPE_RC6 |
4300  RC_TYPE_NEC,
4301  .change_protocol = dib0700_change_protocol,
4302  },
4303  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4304  .num_adapters = 1,
4305  .adapter = {
4306  {
4307  .num_frontends = 1,
4308  .fe = {{
4309  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4310  .pid_filter_count = 32,
4311  .pid_filter = stk80xx_pid_filter,
4312  .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4313  .frontend_attach = stk807x_frontend_attach,
4314  .tuner_attach = dib807x_tuner_attach,
4315 
4316  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4317  }},
4318  .size_of_priv =
4319  sizeof(struct dib0700_adapter_state),
4320  },
4321  },
4322 
4323  .num_device_descs = 3,
4324  .devices = {
4325  { "DiBcom STK807xP reference design",
4326  { &dib0700_usb_id_table[62], NULL },
4327  { NULL },
4328  },
4329  { "Prolink Pixelview SBTVD",
4330  { &dib0700_usb_id_table[63], NULL },
4331  { NULL },
4332  },
4333  { "EvolutePC TVWay+",
4334  { &dib0700_usb_id_table[64], NULL },
4335  { NULL },
4336  },
4337  },
4338 
4339  .rc.core = {
4340  .rc_interval = DEFAULT_RC_INTERVAL,
4341  .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
4342  .module_name = "dib0700",
4343  .rc_query = dib0700_rc_query_old_firmware,
4344  .allowed_protos = RC_TYPE_RC5 |
4345  RC_TYPE_RC6 |
4346  RC_TYPE_NEC,
4347  .change_protocol = dib0700_change_protocol,
4348  },
4349  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4350  .num_adapters = 2,
4351  .adapter = {
4352  {
4353  .num_frontends = 1,
4354  .fe = {{
4355  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4356  .pid_filter_count = 32,
4357  .pid_filter = stk80xx_pid_filter,
4358  .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4359  .frontend_attach = stk807xpvr_frontend_attach0,
4360  .tuner_attach = dib807x_tuner_attach,
4361 
4362  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4363  }},
4364  .size_of_priv =
4365  sizeof(struct dib0700_adapter_state),
4366  },
4367  {
4368  .num_frontends = 1,
4369  .fe = {{
4370  .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4371  .pid_filter_count = 32,
4372  .pid_filter = stk80xx_pid_filter,
4373  .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4374  .frontend_attach = stk807xpvr_frontend_attach1,
4375  .tuner_attach = dib807x_tuner_attach,
4376 
4377  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4378  }},
4379  .size_of_priv =
4380  sizeof(struct dib0700_adapter_state),
4381  },
4382  },
4383 
4384  .num_device_descs = 1,
4385  .devices = {
4386  { "DiBcom STK807xPVR reference design",
4387  { &dib0700_usb_id_table[61], NULL },
4388  { NULL },
4389  },
4390  },
4391 
4392  .rc.core = {
4393  .rc_interval = DEFAULT_RC_INTERVAL,
4394  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4395  .module_name = "dib0700",
4396  .rc_query = dib0700_rc_query_old_firmware,
4397  .allowed_protos = RC_TYPE_RC5 |
4398  RC_TYPE_RC6 |
4399  RC_TYPE_NEC,
4400  .change_protocol = dib0700_change_protocol,
4401  },
4402  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4403  .num_adapters = 1,
4404  .adapter = {
4405  {
4406  .num_frontends = 1,
4407  .fe = {{
4408  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4409  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4410  .pid_filter_count = 32,
4411  .pid_filter = stk80xx_pid_filter,
4412  .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4413  .frontend_attach = stk809x_frontend_attach,
4414  .tuner_attach = dib809x_tuner_attach,
4415 
4416  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4417  }},
4418  .size_of_priv =
4419  sizeof(struct dib0700_adapter_state),
4420  },
4421  },
4422 
4423  .num_device_descs = 1,
4424  .devices = {
4425  { "DiBcom STK8096GP reference design",
4426  { &dib0700_usb_id_table[67], NULL },
4427  { NULL },
4428  },
4429  },
4430 
4431  .rc.core = {
4432  .rc_interval = DEFAULT_RC_INTERVAL,
4433  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4434  .module_name = "dib0700",
4435  .rc_query = dib0700_rc_query_old_firmware,
4436  .allowed_protos = RC_TYPE_RC5 |
4437  RC_TYPE_RC6 |
4438  RC_TYPE_NEC,
4439  .change_protocol = dib0700_change_protocol,
4440  },
4441  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4442  .num_adapters = 1,
4443  .adapter = {
4444  {
4445  .num_frontends = 1,
4446  .fe = {{
4447  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4448  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4449  .pid_filter_count = 32,
4450  .pid_filter = dib90x0_pid_filter,
4451  .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4452  .frontend_attach = stk9090m_frontend_attach,
4453  .tuner_attach = dib9090_tuner_attach,
4454 
4455  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4456  }},
4457  .size_of_priv =
4458  sizeof(struct dib0700_adapter_state),
4459  },
4460  },
4461 
4462  .num_device_descs = 1,
4463  .devices = {
4464  { "DiBcom STK9090M reference design",
4465  { &dib0700_usb_id_table[69], NULL },
4466  { NULL },
4467  },
4468  },
4469 
4470  .rc.core = {
4471  .rc_interval = DEFAULT_RC_INTERVAL,
4472  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4473  .module_name = "dib0700",
4474  .rc_query = dib0700_rc_query_old_firmware,
4475  .allowed_protos = RC_TYPE_RC5 |
4476  RC_TYPE_RC6 |
4477  RC_TYPE_NEC,
4478  .change_protocol = dib0700_change_protocol,
4479  },
4480  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4481  .num_adapters = 1,
4482  .adapter = {
4483  {
4484  .num_frontends = 1,
4485  .fe = {{
4486  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4487  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4488  .pid_filter_count = 32,
4489  .pid_filter = stk80xx_pid_filter,
4490  .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4491  .frontend_attach = nim8096md_frontend_attach,
4492  .tuner_attach = nim8096md_tuner_attach,
4493 
4494  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4495  }},
4496  .size_of_priv =
4497  sizeof(struct dib0700_adapter_state),
4498  },
4499  },
4500 
4501  .num_device_descs = 1,
4502  .devices = {
4503  { "DiBcom NIM8096MD reference design",
4504  { &dib0700_usb_id_table[70], NULL },
4505  { NULL },
4506  },
4507  },
4508 
4509  .rc.core = {
4510  .rc_interval = DEFAULT_RC_INTERVAL,
4511  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4512  .module_name = "dib0700",
4513  .rc_query = dib0700_rc_query_old_firmware,
4514  .allowed_protos = RC_TYPE_RC5 |
4515  RC_TYPE_RC6 |
4516  RC_TYPE_NEC,
4517  .change_protocol = dib0700_change_protocol,
4518  },
4519  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4520  .num_adapters = 1,
4521  .adapter = {
4522  {
4523  .num_frontends = 1,
4524  .fe = {{
4525  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4526  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4527  .pid_filter_count = 32,
4528  .pid_filter = dib90x0_pid_filter,
4529  .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4530  .frontend_attach = nim9090md_frontend_attach,
4531  .tuner_attach = nim9090md_tuner_attach,
4532 
4533  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4534  }},
4535  .size_of_priv =
4536  sizeof(struct dib0700_adapter_state),
4537  },
4538  },
4539 
4540  .num_device_descs = 1,
4541  .devices = {
4542  { "DiBcom NIM9090MD reference design",
4543  { &dib0700_usb_id_table[71], NULL },
4544  { NULL },
4545  },
4546  },
4547 
4548  .rc.core = {
4549  .rc_interval = DEFAULT_RC_INTERVAL,
4550  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4551  .module_name = "dib0700",
4552  .rc_query = dib0700_rc_query_old_firmware,
4553  .allowed_protos = RC_TYPE_RC5 |
4554  RC_TYPE_RC6 |
4555  RC_TYPE_NEC,
4556  .change_protocol = dib0700_change_protocol,
4557  },
4558  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4559  .num_adapters = 1,
4560  .adapter = {
4561  {
4562  .num_frontends = 1,
4563  .fe = {{
4564  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4565  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4566  .pid_filter_count = 32,
4567  .pid_filter = stk70x0p_pid_filter,
4568  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4569  .frontend_attach = nim7090_frontend_attach,
4570  .tuner_attach = nim7090_tuner_attach,
4571 
4572  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4573  }},
4574  .size_of_priv =
4575  sizeof(struct dib0700_adapter_state),
4576  },
4577  },
4578 
4579  .num_device_descs = 1,
4580  .devices = {
4581  { "DiBcom NIM7090 reference design",
4582  { &dib0700_usb_id_table[72], NULL },
4583  { NULL },
4584  },
4585  },
4586 
4587  .rc.core = {
4588  .rc_interval = DEFAULT_RC_INTERVAL,
4589  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4590  .module_name = "dib0700",
4591  .rc_query = dib0700_rc_query_old_firmware,
4592  .allowed_protos = RC_TYPE_RC5 |
4593  RC_TYPE_RC6 |
4594  RC_TYPE_NEC,
4595  .change_protocol = dib0700_change_protocol,
4596  },
4597  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4598  .num_adapters = 2,
4599  .adapter = {
4600  {
4601  .num_frontends = 1,
4602  .fe = {{
4603  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4604  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4605  .pid_filter_count = 32,
4606  .pid_filter = stk70x0p_pid_filter,
4607  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4608  .frontend_attach = tfe7090pvr_frontend0_attach,
4609  .tuner_attach = tfe7090pvr_tuner0_attach,
4610 
4611  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4612  }},
4613  .size_of_priv =
4614  sizeof(struct dib0700_adapter_state),
4615  },
4616  {
4617  .num_frontends = 1,
4618  .fe = {{
4619  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4620  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4621  .pid_filter_count = 32,
4622  .pid_filter = stk70x0p_pid_filter,
4623  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4624  .frontend_attach = tfe7090pvr_frontend1_attach,
4625  .tuner_attach = tfe7090pvr_tuner1_attach,
4626 
4627  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4628  }},
4629  .size_of_priv =
4630  sizeof(struct dib0700_adapter_state),
4631  },
4632  },
4633 
4634  .num_device_descs = 1,
4635  .devices = {
4636  { "DiBcom TFE7090PVR reference design",
4637  { &dib0700_usb_id_table[73], NULL },
4638  { NULL },
4639  },
4640  },
4641 
4642  .rc.core = {
4643  .rc_interval = DEFAULT_RC_INTERVAL,
4644  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4645  .module_name = "dib0700",
4646  .rc_query = dib0700_rc_query_old_firmware,
4647  .allowed_protos = RC_TYPE_RC5 |
4648  RC_TYPE_RC6 |
4649  RC_TYPE_NEC,
4650  .change_protocol = dib0700_change_protocol,
4651  },
4652  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4653  .num_adapters = 1,
4654  .adapter = {
4655  {
4656  .num_frontends = 1,
4657  .fe = {{
4658  .frontend_attach = pctv340e_frontend_attach,
4659  .tuner_attach = xc4000_tuner_attach,
4660 
4661  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4662  }},
4663  .size_of_priv = sizeof(struct
4664  dib0700_adapter_state),
4665  },
4666  },
4667 
4668  .num_device_descs = 2,
4669  .devices = {
4670  { "Pinnacle PCTV 340e HD Pro USB Stick",
4671  { &dib0700_usb_id_table[76], NULL },
4672  { NULL },
4673  },
4674  { "Pinnacle PCTV Hybrid Stick Solo",
4675  { &dib0700_usb_id_table[77], NULL },
4676  { NULL },
4677  },
4678  },
4679  .rc.core = {
4680  .rc_interval = DEFAULT_RC_INTERVAL,
4681  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4682  .module_name = "dib0700",
4683  .rc_query = dib0700_rc_query_old_firmware,
4684  .allowed_protos = RC_TYPE_RC5 |
4685  RC_TYPE_RC6 |
4686  RC_TYPE_NEC,
4687  .change_protocol = dib0700_change_protocol,
4688  },
4689  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4690  .num_adapters = 1,
4691  .adapter = {
4692  {
4693  .num_frontends = 1,
4694  .fe = {{
4695  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4696  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4697  .pid_filter_count = 32,
4698  .pid_filter = stk70x0p_pid_filter,
4699  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4700  .frontend_attach = tfe7090e_frontend_attach,
4701  .tuner_attach = tfe7090e_tuner_attach,
4702 
4703  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4704  } },
4705 
4706  .size_of_priv =
4707  sizeof(struct dib0700_adapter_state),
4708  },
4709  },
4710 
4711  .num_device_descs = 1,
4712  .devices = {
4713  { "DiBcom TFE7090E reference design",
4714  { &dib0700_usb_id_table[78], NULL },
4715  { NULL },
4716  },
4717  },
4718 
4719  .rc.core = {
4720  .rc_interval = DEFAULT_RC_INTERVAL,
4721  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4722  .module_name = "dib0700",
4723  .rc_query = dib0700_rc_query_old_firmware,
4724  .allowed_protos = RC_TYPE_RC5 |
4725  RC_TYPE_RC6 |
4726  RC_TYPE_NEC,
4727  .change_protocol = dib0700_change_protocol,
4728  },
4729  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4730  .num_adapters = 1,
4731  .adapter = {
4732  {
4733  .num_frontends = 1,
4734  .fe = {{
4735  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4736  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4737  .pid_filter_count = 32,
4738  .pid_filter = stk70x0p_pid_filter,
4739  .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4740  .frontend_attach = tfe7790e_frontend_attach,
4741  .tuner_attach = tfe7790e_tuner_attach,
4742 
4743  DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4744  } },
4745 
4746  .size_of_priv =
4747  sizeof(struct dib0700_adapter_state),
4748  },
4749  },
4750 
4751  .num_device_descs = 1,
4752  .devices = {
4753  { "DiBcom TFE7790E reference design",
4754  { &dib0700_usb_id_table[79], NULL },
4755  { NULL },
4756  },
4757  },
4758 
4759  .rc.core = {
4760  .rc_interval = DEFAULT_RC_INTERVAL,
4761  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4762  .module_name = "dib0700",
4763  .rc_query = dib0700_rc_query_old_firmware,
4764  .allowed_protos = RC_TYPE_RC5 |
4765  RC_TYPE_RC6 |
4766  RC_TYPE_NEC,
4767  .change_protocol = dib0700_change_protocol,
4768  },
4769  }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4770  .num_adapters = 1,
4771  .adapter = {
4772  {
4773  .num_frontends = 1,
4774  .fe = {{
4775  .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4776  DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4777  .pid_filter_count = 32,
4778  .pid_filter = stk80xx_pid_filter,
4779  .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4780  .frontend_attach = tfe8096p_frontend_attach,
4781  .tuner_attach = tfe8096p_tuner_attach,
4782 
4783  DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4784 
4785  } },
4786 
4787  .size_of_priv =
4788  sizeof(struct dib0700_adapter_state),
4789  },
4790  },
4791 
4792  .num_device_descs = 1,
4793  .devices = {
4794  { "DiBcom TFE8096P reference design",
4795  { &dib0700_usb_id_table[80], NULL },
4796  { NULL },
4797  },
4798  },
4799 
4800  .rc.core = {
4801  .rc_interval = DEFAULT_RC_INTERVAL,
4802  .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4803  .module_name = "dib0700",
4804  .rc_query = dib0700_rc_query_old_firmware,
4805  .allowed_protos = RC_TYPE_RC5 |
4806  RC_TYPE_RC6 |
4807  RC_TYPE_NEC,
4808  .change_protocol = dib0700_change_protocol,
4809  },
4810  },
4811 };
4812 
4813 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
Generated on Thu Jan 10 2013 13:51:23 for Linux Kernel by   doxygen 1.8.2