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