?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / media / dvb / dvb-usb / dib0700_devices.c
blobf657c636df95d0a5cb0df10580261f2773474279
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 "mt2060.h"
16 #include "mt2266.h"
17 #include "tuner-xc2028.h"
18 #include "xc5000.h"
19 #include "s5h1411.h"
20 #include "dib0070.h"
21 #include "dib0090.h"
22 #include "lgdt3305.h"
23 #include "mxl5007t.h"
24
25 static int force_lna_activation;
26 module_param(force_lna_activation, int, 0644);
27 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
28 "if applicable for the device (default: 0=automatic/off).");
29
30 struct dib0700_adapter_state {
31 int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
32 };
33
34 /* Hauppauge Nova-T 500 (aka Bristol)
35 * has a LNA on GPIO0 which is enabled by setting 1 */
36 static struct mt2060_config bristol_mt2060_config[2] = {
37 {
38 .i2c_address = 0x60,
39 .clock_out = 3,
40 }, {
41 .i2c_address = 0x61,
42 }
43 };
44
45
46 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
47 .band_caps = BAND_VHF | BAND_UHF,
48 .setup = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
49
50 .agc1_max = 42598,
51 .agc1_min = 17694,
52 .agc2_max = 45875,
53 .agc2_min = 0,
54
55 .agc1_pt1 = 0,
56 .agc1_pt2 = 59,
57
58 .agc1_slope1 = 0,
59 .agc1_slope2 = 69,
60
61 .agc2_pt1 = 0,
62 .agc2_pt2 = 59,
63
64 .agc2_slope1 = 111,
65 .agc2_slope2 = 28,
66 };
67
68 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
69 { .agc = &bristol_dib3000p_mt2060_agc_config,
70 .max_time = 0x196,
71 .ln_adc_level = 0x1cc7,
72 .output_mpeg2_in_188_bytes = 1,
73 },
74 { .agc = &bristol_dib3000p_mt2060_agc_config,
75 .max_time = 0x196,
76 .ln_adc_level = 0x1cc7,
77 .output_mpeg2_in_188_bytes = 1,
78 }
79 };
80
81 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
82 {
83 struct dib0700_state *st = adap->dev->priv;
84 if (adap->id == 0) {
85 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
86 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
87 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
88 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
89
90 if (force_lna_activation)
91 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
92 else
93 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
94
95 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
96 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
97 return -ENODEV;
98 }
99 }
100 st->mt2060_if1[adap->id] = 1220;
101 return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
102 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
103 }
104
105 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
106 {
107 struct i2c_msg msg[2] = {
108 { .addr = 0x50, .flags = 0, .buf = &adrs, .len = 1 },
109 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval, .len = 1 },
110 };
111 if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
112 return 0;
113 }
114
115 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
116 {
117 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
118 struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
119 s8 a;
120 int if1=1220;
121 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
122 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
123 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
124 }
125 return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
126 if1) == NULL ? -ENODEV : 0;
127 }
128
129 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
130
131 /* MT226x */
132 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
133 {
134 BAND_UHF,
135
136 /* 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,
137 * 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 */
138 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
139 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
140
141 1130,
142 21,
143
144 0,
145 118,
146
147 0,
148 3530,
149 1,
150 0,
151
152 65535,
153 33770,
154 65535,
155 23592,
156
157 0,
158 62,
159 255,
160 64,
161 64,
162 132,
163 192,
164 80,
165 80,
166
167 17,
168 27,
169 23,
170 51,
171
172 1,
173 }, {
174 BAND_VHF | BAND_LBAND,
175
176 /* 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,
177 * 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 */
178 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
179 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
180
181 2372,
182 21,
183
184 0,
185 118,
186
187 0,
188 3530,
189 1,
190 0,
191
192 65535,
193 0,
194 65535,
195 23592,
196
197 0,
198 128,
199 128,
200 128,
201 0,
202 128,
203 253,
204 81,
205 0,
206
207 17,
208 27,
209 23,
210 51,
211
212 1,
213 }
214 };
215
216 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
217 60000, 30000,
218 1, 8, 3, 1, 0,
219 0, 0, 1, 1, 2,
220 (3 << 14) | (1 << 12) | (524 << 0),
221 0,
222 20452225,
223 };
224
225 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
226 { .output_mpeg2_in_188_bytes = 1,
227 .hostbus_diversity = 1,
228 .tuner_is_baseband = 1,
229
230 .agc_config_count = 2,
231 .agc = stk7700d_7000p_mt2266_agc_config,
232 .bw = &stk7700d_mt2266_pll_config,
233
234 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
235 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
236 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
237 },
238 { .output_mpeg2_in_188_bytes = 1,
239 .hostbus_diversity = 1,
240 .tuner_is_baseband = 1,
241
242 .agc_config_count = 2,
243 .agc = stk7700d_7000p_mt2266_agc_config,
244 .bw = &stk7700d_mt2266_pll_config,
245
246 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
247 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
248 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
249 }
250 };
251
252 static struct mt2266_config stk7700d_mt2266_config[2] = {
253 { .i2c_address = 0x60
254 },
255 { .i2c_address = 0x60
256 }
257 };
258
259 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
260 {
261 if (adap->id == 0) {
262 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
263 msleep(10);
264 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
265 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
266 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
267 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
268 msleep(10);
269 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
270 msleep(10);
271 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
272 stk7700d_dib7000p_mt2266_config)
273 != 0) {
274 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
275 return -ENODEV;
276 }
277 }
278
279 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
280 &stk7700d_dib7000p_mt2266_config[adap->id]);
281
282 return adap->fe == NULL ? -ENODEV : 0;
283 }
284
285 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
286 {
287 if (adap->id == 0) {
288 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
289 msleep(10);
290 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
291 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
292 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
293 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
294 msleep(10);
295 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
296 msleep(10);
297 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
298 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
299 stk7700d_dib7000p_mt2266_config)
300 != 0) {
301 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
302 return -ENODEV;
303 }
304 }
305
306 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
307 &stk7700d_dib7000p_mt2266_config[adap->id]);
308
309 return adap->fe == NULL ? -ENODEV : 0;
310 }
311
312 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
313 {
314 struct i2c_adapter *tun_i2c;
315 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
316 return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
317 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
318 }
319
320 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
321 static struct dibx000_agc_config xc3028_agc_config = {
322 BAND_VHF | BAND_UHF, /* band_caps */
323
324 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
325 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
326 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
327 (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
328 (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
329
330 712, /* inv_gain */
331 21, /* time_stabiliz */
332
333 0, /* alpha_level */
334 118, /* thlock */
335
336 0, /* wbd_inv */
337 2867, /* wbd_ref */
338 0, /* wbd_sel */
339 2, /* wbd_alpha */
340
341 0, /* agc1_max */
342 0, /* agc1_min */
343 39718, /* agc2_max */
344 9930, /* agc2_min */
345 0, /* agc1_pt1 */
346 0, /* agc1_pt2 */
347 0, /* agc1_pt3 */
348 0, /* agc1_slope1 */
349 0, /* agc1_slope2 */
350 0, /* agc2_pt1 */
351 128, /* agc2_pt2 */
352 29, /* agc2_slope1 */
353 29, /* agc2_slope2 */
354
355 17, /* alpha_mant */
356 27, /* alpha_exp */
357 23, /* beta_mant */
358 51, /* beta_exp */
359
360 1, /* perform_agc_softsplit */
361 };
362
363 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
364 static struct dibx000_bandwidth_config xc3028_bw_config = {
365 60000, 30000, /* internal, sampling */
366 1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
367 0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
368 modulo */
369 (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
370 (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
371 20452225, /* timf */
372 30000000, /* xtal_hz */
373 };
374
375 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
376 .output_mpeg2_in_188_bytes = 1,
377 .tuner_is_baseband = 1,
378
379 .agc_config_count = 1,
380 .agc = &xc3028_agc_config,
381 .bw = &xc3028_bw_config,
382
383 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
384 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
385 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
386 };
387
388 static int stk7700ph_xc3028_callback(void *ptr, int component,
389 int command, int arg)
390 {
391 struct dvb_usb_adapter *adap = ptr;
392
393 switch (command) {
394 case XC2028_TUNER_RESET:
395 /* Send the tuner in then out of reset */
396 dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
397 dib7000p_set_gpio(adap->fe, 8, 0, 1);
398 break;
399 case XC2028_RESET_CLK:
400 break;
401 default:
402 err("%s: unknown command %d, arg %d\n", __func__,
403 command, arg);
404 return -EINVAL;
405 }
406 return 0;
407 }
408
409 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
410 .fname = XC2028_DEFAULT_FIRMWARE,
411 .max_len = 64,
412 .demod = XC3028_FE_DIBCOM52,
413 };
414
415 static struct xc2028_config stk7700ph_xc3028_config = {
416 .i2c_addr = 0x61,
417 .ctrl = &stk7700ph_xc3028_ctrl,
418 };
419
420 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
421 {
422 struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
423
424 if (desc->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
425 desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
426 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
427 else
428 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
429 msleep(20);
430 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
431 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
432 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
433 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
434 msleep(10);
435 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
436 msleep(20);
437 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
438 msleep(10);
439
440 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
441 &stk7700ph_dib7700_xc3028_config) != 0) {
442 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
443 __func__);
444 return -ENODEV;
445 }
446
447 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
448 &stk7700ph_dib7700_xc3028_config);
449
450 return adap->fe == NULL ? -ENODEV : 0;
451 }
452
453 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
454 {
455 struct i2c_adapter *tun_i2c;
456
457 tun_i2c = dib7000p_get_i2c_master(adap->fe,
458 DIBX000_I2C_INTERFACE_TUNER, 1);
459
460 stk7700ph_xc3028_config.i2c_adap = tun_i2c;
461
462 adap->fe->callback = stk7700ph_xc3028_callback;
463
464 return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
465 == NULL ? -ENODEV : 0;
466 }
467
468 #define DEFAULT_RC_INTERVAL 50
469
470 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
471
472 /* Number of keypresses to ignore before start repeating */
473 #define RC_REPEAT_DELAY 6
474
475 /*
476 * This function is used only when firmware is < 1.20 version. Newer
477 * firmwares use bulk mode, with functions implemented at dib0700_core,
478 * at dib0700_rc_urb_completion()
479 */
480 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
481 {
482 u8 key[4];
483 u32 keycode;
484 u8 toggle;
485 int i;
486 struct dib0700_state *st = d->priv;
487
488 if (st->fw_version >= 0x10200) {
489 /* For 1.20 firmware , We need to keep the RC polling
490 callback so we can reuse the input device setup in
491 dvb-usb-remote.c. However, the actual work is being done
492 in the bulk URB completion handler. */
493 return 0;
494 }
495
496 i = dib0700_ctrl_rd(d, rc_request, 2, key, 4);
497 if (i <= 0) {
498 err("RC Query Failed");
499 return -1;
500 }
501
502 /* losing half of KEY_0 events from Philipps rc5 remotes.. */
503 if (key[0] == 0 && key[1] == 0 && key[2] == 0 && key[3] == 0)
504 return 0;
505
506 /* 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]); */
507
508 dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
509
510 d->last_event = 0;
511 switch (d->props.rc.core.protocol) {
512 case IR_TYPE_NEC:
513 /* NEC protocol sends repeat code as 0 0 0 FF */
514 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
515 (key[3] == 0xff))
516 keycode = d->last_event;
517 else {
518 keycode = key[3-2] << 8 | key[3-3];
519 d->last_event = keycode;
520 }
521
522 ir_keydown(d->rc_input_dev, keycode, 0);
523 break;
524 default:
525 /* RC-5 protocol changes toggle bit on new keypress */
526 keycode = key[3-2] << 8 | key[3-3];
527 toggle = key[3-1];
528 ir_keydown(d->rc_input_dev, keycode, toggle);
529
530 break;
531 }
532 return 0;
533 }
534
535 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
536 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
537 BAND_UHF | BAND_VHF,
538
539 /* 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,
540 * 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 */
541 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
542 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
543
544 712,
545 41,
546
547 0,
548 118,
549
550 0,
551 4095,
552 0,
553 0,
554
555 42598,
556 17694,
557 45875,
558 2621,
559 0,
560 76,
561 139,
562 52,
563 59,
564 107,
565 172,
566 57,
567 70,
568
569 21,
570 25,
571 28,
572 48,
573
574 1,
575 { 0,
576 107,
577 51800,
578 24700
579 },
580 };
581
582 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
583 BAND_UHF | BAND_VHF,
584
585 /* 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,
586 * 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 */
587 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
588 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
589
590 712,
591 41,
592
593 0,
594 118,
595
596 0,
597 4095,
598 0,
599 0,
600
601 42598,
602 16384,
603 42598,
604 0,
605
606 0,
607 137,
608 255,
609
610 0,
611 255,
612
613 0,
614 0,
615
616 0,
617 41,
618
619 15,
620 25,
621
622 28,
623 48,
624
625 0,
626 };
627
628 static struct dibx000_bandwidth_config stk7700p_pll_config = {
629 60000, 30000,
630 1, 8, 3, 1, 0,
631 0, 0, 1, 1, 0,
632 (3 << 14) | (1 << 12) | (524 << 0),
633 60258167,
634 20452225,
635 30000000,
636 };
637
638 static struct dib7000m_config stk7700p_dib7000m_config = {
639 .dvbt_mode = 1,
640 .output_mpeg2_in_188_bytes = 1,
641 .quartz_direct = 1,
642
643 .agc_config_count = 1,
644 .agc = &stk7700p_7000m_mt2060_agc_config,
645 .bw = &stk7700p_pll_config,
646
647 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
648 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
649 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
650 };
651
652 static struct dib7000p_config stk7700p_dib7000p_config = {
653 .output_mpeg2_in_188_bytes = 1,
654
655 .agc_config_count = 1,
656 .agc = &stk7700p_7000p_mt2060_agc_config,
657 .bw = &stk7700p_pll_config,
658
659 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
660 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
661 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
662 };
663
664 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
665 {
666 struct dib0700_state *st = adap->dev->priv;
667 /* unless there is no real power management in DVB - we leave the device on GPIO6 */
668
669 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
670 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(50);
671
672 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
673 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
674
675 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
676 dib0700_ctrl_clock(adap->dev, 72, 1);
677 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
678
679 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
680
681 st->mt2060_if1[0] = 1220;
682
683 if (dib7000pc_detection(&adap->dev->i2c_adap)) {
684 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
685 st->is_dib7000pc = 1;
686 } else
687 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
688
689 return adap->fe == NULL ? -ENODEV : 0;
690 }
691
692 static struct mt2060_config stk7700p_mt2060_config = {
693 0x60
694 };
695
696 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
697 {
698 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
699 struct dib0700_state *st = adap->dev->priv;
700 struct i2c_adapter *tun_i2c;
701 s8 a;
702 int if1=1220;
703 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
704 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
705 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
706 }
707 if (st->is_dib7000pc)
708 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
709 else
710 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
711
712 return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
713 if1) == NULL ? -ENODEV : 0;
714 }
715
716 /* DIB7070 generic */
717 static struct dibx000_agc_config dib7070_agc_config = {
718 BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
719 /* 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,
720 * 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 */
721 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
722 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
723
724 600,
725 10,
726
727 0,
728 118,
729
730 0,
731 3530,
732 1,
733 5,
734
735 65535,
736 0,
737
738 65535,
739 0,
740
741 0,
742 40,
743 183,
744 206,
745 255,
746 72,
747 152,
748 88,
749 90,
750
751 17,
752 27,
753 23,
754 51,
755
756 0,
757 };
758
759 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
760 {
761 deb_info("reset: %d", onoff);
762 return dib7000p_set_gpio(fe, 8, 0, !onoff);
763 }
764
765 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
766 {
767 deb_info("sleep: %d", onoff);
768 return dib7000p_set_gpio(fe, 9, 0, onoff);
769 }
770
771 static struct dib0070_config dib7070p_dib0070_config[2] = {
772 {
773 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
774 .reset = dib7070_tuner_reset,
775 .sleep = dib7070_tuner_sleep,
776 .clock_khz = 12000,
777 .clock_pad_drive = 4,
778 .charge_pump = 2,
779 }, {
780 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
781 .reset = dib7070_tuner_reset,
782 .sleep = dib7070_tuner_sleep,
783 .clock_khz = 12000,
784 .charge_pump = 2,
785 }
786 };
787
788 static struct dib0070_config dib7770p_dib0070_config = {
789 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
790 .reset = dib7070_tuner_reset,
791 .sleep = dib7070_tuner_sleep,
792 .clock_khz = 12000,
793 .clock_pad_drive = 0,
794 .flip_chip = 1,
795 .charge_pump = 2,
796 };
797
798 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
799 {
800 struct dvb_usb_adapter *adap = fe->dvb->priv;
801 struct dib0700_adapter_state *state = adap->priv;
802
803 u16 offset;
804 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
805 switch (band) {
806 case BAND_VHF: offset = 950; break;
807 case BAND_UHF:
808 default: offset = 550; break;
809 }
810 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
811 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
812 return state->set_param_save(fe, fep);
813 }
814
815 static int dib7770_set_param_override(struct dvb_frontend *fe,
816 struct dvb_frontend_parameters *fep)
817 {
818 struct dvb_usb_adapter *adap = fe->dvb->priv;
819 struct dib0700_adapter_state *state = adap->priv;
820
821 u16 offset;
822 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
823 switch (band) {
824 case BAND_VHF:
825 dib7000p_set_gpio(fe, 0, 0, 1);
826 offset = 850;
827 break;
828 case BAND_UHF:
829 default:
830 dib7000p_set_gpio(fe, 0, 0, 0);
831 offset = 250;
832 break;
833 }
834 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
835 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
836 return state->set_param_save(fe, fep);
837 }
838
839 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
840 {
841 struct dib0700_adapter_state *st = adap->priv;
842 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
843 DIBX000_I2C_INTERFACE_TUNER, 1);
844
845 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
846 &dib7770p_dib0070_config) == NULL)
847 return -ENODEV;
848
849 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
850 adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
851 return 0;
852 }
853
854 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
855 {
856 struct dib0700_adapter_state *st = adap->priv;
857 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
858
859 if (adap->id == 0) {
860 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
861 return -ENODEV;
862 } else {
863 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
864 return -ENODEV;
865 }
866
867 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
868 adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
869 return 0;
870 }
871
872 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
873 {
874 return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
875 }
876
877 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
878 {
879 return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
880 }
881
882 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
883 60000, 15000,
884 1, 20, 3, 1, 0,
885 0, 0, 1, 1, 2,
886 (3 << 14) | (1 << 12) | (524 << 0),
887 (0 << 25) | 0,
888 20452225,
889 12000000,
890 };
891
892 static struct dib7000p_config dib7070p_dib7000p_config = {
893 .output_mpeg2_in_188_bytes = 1,
894
895 .agc_config_count = 1,
896 .agc = &dib7070_agc_config,
897 .bw = &dib7070_bw_config_12_mhz,
898 .tuner_is_baseband = 1,
899 .spur_protect = 1,
900
901 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
902 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
903 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
904
905 .hostbus_diversity = 1,
906 };
907
908 /* STK7070P */
909 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
910 {
911 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
912 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
913 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
914 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
915 else
916 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
917 msleep(10);
918 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
919 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
920 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
921 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
922
923 dib0700_ctrl_clock(adap->dev, 72, 1);
924
925 msleep(10);
926 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
927 msleep(10);
928 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
929
930 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
931 &dib7070p_dib7000p_config) != 0) {
932 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
933 __func__);
934 return -ENODEV;
935 }
936
937 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
938 &dib7070p_dib7000p_config);
939 return adap->fe == NULL ? -ENODEV : 0;
940 }
941
942 /* STK7770P */
943 static struct dib7000p_config dib7770p_dib7000p_config = {
944 .output_mpeg2_in_188_bytes = 1,
945
946 .agc_config_count = 1,
947 .agc = &dib7070_agc_config,
948 .bw = &dib7070_bw_config_12_mhz,
949 .tuner_is_baseband = 1,
950 .spur_protect = 1,
951
952 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
953 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
954 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
955
956 .hostbus_diversity = 1,
957 .enable_current_mirror = 1,
958 .disable_sample_and_hold = 0,
959 };
960
961 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
962 {
963 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
964 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
965 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
966 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
967 else
968 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
969 msleep(10);
970 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
971 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
972 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
973 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
974
975 dib0700_ctrl_clock(adap->dev, 72, 1);
976
977 msleep(10);
978 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
979 msleep(10);
980 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
981
982 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
983 &dib7770p_dib7000p_config) != 0) {
984 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
985 __func__);
986 return -ENODEV;
987 }
988
989 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
990 &dib7770p_dib7000p_config);
991 return adap->fe == NULL ? -ENODEV : 0;
992 }
993
994 /* DIB807x generic */
995 static struct dibx000_agc_config dib807x_agc_config[2] = {
996 {
997 BAND_VHF,
998 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
999 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1000 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1001 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1002 * P_agc_write=0 */
1003 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1004 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1005 (0 << 0), /* setup*/
1006
1007 600, /* inv_gain*/
1008 10, /* time_stabiliz*/
1009
1010 0, /* alpha_level*/
1011 118, /* thlock*/
1012
1013 0, /* wbd_inv*/
1014 3530, /* wbd_ref*/
1015 1, /* wbd_sel*/
1016 5, /* wbd_alpha*/
1017
1018 65535, /* agc1_max*/
1019 0, /* agc1_min*/
1020
1021 65535, /* agc2_max*/
1022 0, /* agc2_min*/
1023
1024 0, /* agc1_pt1*/
1025 40, /* agc1_pt2*/
1026 183, /* agc1_pt3*/
1027 206, /* agc1_slope1*/
1028 255, /* agc1_slope2*/
1029 72, /* agc2_pt1*/
1030 152, /* agc2_pt2*/
1031 88, /* agc2_slope1*/
1032 90, /* agc2_slope2*/
1033
1034 17, /* alpha_mant*/
1035 27, /* alpha_exp*/
1036 23, /* beta_mant*/
1037 51, /* beta_exp*/
1038
1039 0, /* perform_agc_softsplit*/
1040 }, {
1041 BAND_UHF,
1042 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1043 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1044 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1045 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1046 * P_agc_write=0 */
1047 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1048 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1049 (0 << 0), /* setup */
1050
1051 600, /* inv_gain*/
1052 10, /* time_stabiliz*/
1053
1054 0, /* alpha_level*/
1055 118, /* thlock*/
1056
1057 0, /* wbd_inv*/
1058 3530, /* wbd_ref*/
1059 1, /* wbd_sel*/
1060 5, /* wbd_alpha*/
1061
1062 65535, /* agc1_max*/
1063 0, /* agc1_min*/
1064
1065 65535, /* agc2_max*/
1066 0, /* agc2_min*/
1067
1068 0, /* agc1_pt1*/
1069 40, /* agc1_pt2*/
1070 183, /* agc1_pt3*/
1071 206, /* agc1_slope1*/
1072 255, /* agc1_slope2*/
1073 72, /* agc2_pt1*/
1074 152, /* agc2_pt2*/
1075 88, /* agc2_slope1*/
1076 90, /* agc2_slope2*/
1077
1078 17, /* alpha_mant*/
1079 27, /* alpha_exp*/
1080 23, /* beta_mant*/
1081 51, /* beta_exp*/
1082
1083 0, /* perform_agc_softsplit*/
1084 }
1085 };
1086
1087 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1088 60000, 15000, /* internal, sampling*/
1089 1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1090 0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1091 ADClkSrc, modulo */
1092 (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1093 (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1094 18179755, /* timf*/
1095 12000000, /* xtal_hz*/
1096 };
1097
1098 static struct dib8000_config dib807x_dib8000_config[2] = {
1099 {
1100 .output_mpeg2_in_188_bytes = 1,
1101
1102 .agc_config_count = 2,
1103 .agc = dib807x_agc_config,
1104 .pll = &dib807x_bw_config_12_mhz,
1105 .tuner_is_baseband = 1,
1106
1107 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1108 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1109 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1110
1111 .hostbus_diversity = 1,
1112 .div_cfg = 1,
1113 .agc_control = &dib0070_ctrl_agc_filter,
1114 .output_mode = OUTMODE_MPEG2_FIFO,
1115 .drives = 0x2d98,
1116 }, {
1117 .output_mpeg2_in_188_bytes = 1,
1118
1119 .agc_config_count = 2,
1120 .agc = dib807x_agc_config,
1121 .pll = &dib807x_bw_config_12_mhz,
1122 .tuner_is_baseband = 1,
1123
1124 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1125 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1126 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1127
1128 .hostbus_diversity = 1,
1129 .agc_control = &dib0070_ctrl_agc_filter,
1130 .output_mode = OUTMODE_MPEG2_FIFO,
1131 .drives = 0x2d98,
1132 }
1133 };
1134
1135 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1136 {
1137 return dib8000_set_gpio(fe, 5, 0, !onoff);
1138 }
1139
1140 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1141 {
1142 return dib8000_set_gpio(fe, 0, 0, onoff);
1143 }
1144
1145 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1146 { 240, 7},
1147 { 0xffff, 6},
1148 };
1149
1150 static struct dib0070_config dib807x_dib0070_config[2] = {
1151 {
1152 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1153 .reset = dib80xx_tuner_reset,
1154 .sleep = dib80xx_tuner_sleep,
1155 .clock_khz = 12000,
1156 .clock_pad_drive = 4,
1157 .vga_filter = 1,
1158 .force_crystal_mode = 1,
1159 .enable_third_order_filter = 1,
1160 .charge_pump = 0,
1161 .wbd_gain = dib8070_wbd_gain_cfg,
1162 .osc_buffer_state = 0,
1163 .freq_offset_khz_uhf = -100,
1164 .freq_offset_khz_vhf = -100,
1165 }, {
1166 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1167 .reset = dib80xx_tuner_reset,
1168 .sleep = dib80xx_tuner_sleep,
1169 .clock_khz = 12000,
1170 .clock_pad_drive = 2,
1171 .vga_filter = 1,
1172 .force_crystal_mode = 1,
1173 .enable_third_order_filter = 1,
1174 .charge_pump = 0,
1175 .wbd_gain = dib8070_wbd_gain_cfg,
1176 .osc_buffer_state = 0,
1177 .freq_offset_khz_uhf = -25,
1178 .freq_offset_khz_vhf = -25,
1179 }
1180 };
1181
1182 static int dib807x_set_param_override(struct dvb_frontend *fe,
1183 struct dvb_frontend_parameters *fep)
1184 {
1185 struct dvb_usb_adapter *adap = fe->dvb->priv;
1186 struct dib0700_adapter_state *state = adap->priv;
1187
1188 u16 offset = dib0070_wbd_offset(fe);
1189 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1190 switch (band) {
1191 case BAND_VHF:
1192 offset += 750;
1193 break;
1194 case BAND_UHF: /* fall-thru wanted */
1195 default:
1196 offset += 250; break;
1197 }
1198 deb_info("WBD for DiB8000: %d\n", offset);
1199 dib8000_set_wbd_ref(fe, offset);
1200
1201 return state->set_param_save(fe, fep);
1202 }
1203
1204 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1205 {
1206 struct dib0700_adapter_state *st = adap->priv;
1207 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1208 DIBX000_I2C_INTERFACE_TUNER, 1);
1209
1210 if (adap->id == 0) {
1211 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1212 &dib807x_dib0070_config[0]) == NULL)
1213 return -ENODEV;
1214 } else {
1215 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1216 &dib807x_dib0070_config[1]) == NULL)
1217 return -ENODEV;
1218 }
1219
1220 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1221 adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1222 return 0;
1223 }
1224
1225 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1226 u16 pid, int onoff)
1227 {
1228 return dib8000_pid_filter(adapter->fe, index, pid, onoff);
1229 }
1230
1231 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1232 int onoff)
1233 {
1234 return dib8000_pid_filter_ctrl(adapter->fe, onoff);
1235 }
1236
1237 /* STK807x */
1238 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1239 {
1240 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1241 msleep(10);
1242 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1243 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1244 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1245
1246 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1247
1248 dib0700_ctrl_clock(adap->dev, 72, 1);
1249
1250 msleep(10);
1251 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1252 msleep(10);
1253 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1254
1255 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1256 0x80);
1257
1258 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1259 &dib807x_dib8000_config[0]);
1260
1261 return adap->fe == NULL ? -ENODEV : 0;
1262 }
1263
1264 /* STK807xPVR */
1265 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1266 {
1267 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1268 msleep(30);
1269 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1270 msleep(500);
1271 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1272 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1273 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1274
1275 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1276
1277 dib0700_ctrl_clock(adap->dev, 72, 1);
1278
1279 msleep(10);
1280 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1281 msleep(10);
1282 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1283
1284 /* initialize IC 0 */
1285 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
1286
1287 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1288 &dib807x_dib8000_config[0]);
1289
1290 return adap->fe == NULL ? -ENODEV : 0;
1291 }
1292
1293 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1294 {
1295 /* initialize IC 1 */
1296 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
1297
1298 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1299 &dib807x_dib8000_config[1]);
1300
1301 return adap->fe == NULL ? -ENODEV : 0;
1302 }
1303
1304 /* STK8096GP */
1305 struct dibx000_agc_config dib8090_agc_config[2] = {
1306 {
1307 BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1308 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1309 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1310 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1311 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1312 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1313
1314 787,
1315 10,
1316
1317 0,
1318 118,
1319
1320 0,
1321 3530,
1322 1,
1323 5,
1324
1325 65535,
1326 0,
1327
1328 65535,
1329 0,
1330
1331 0,
1332 32,
1333 114,
1334 143,
1335 144,
1336 114,
1337 227,
1338 116,
1339 117,
1340
1341 28,
1342 26,
1343 31,
1344 51,
1345
1346 0,
1347 },
1348 {
1349 BAND_CBAND,
1350 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1351 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1352 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1353 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1354 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1355
1356 787,
1357 10,
1358
1359 0,
1360 118,
1361
1362 0,
1363 3530,
1364 1,
1365 5,
1366
1367 0,
1368 0,
1369
1370 65535,
1371 0,
1372
1373 0,
1374 32,
1375 114,
1376 143,
1377 144,
1378 114,
1379 227,
1380 116,
1381 117,
1382
1383 28,
1384 26,
1385 31,
1386 51,
1387
1388 0,
1389 }
1390 };
1391
1392 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1393 54000, 13500,
1394 1, 18, 3, 1, 0,
1395 0, 0, 1, 1, 2,
1396 (3 << 14) | (1 << 12) | (599 << 0),
1397 (0 << 25) | 0,
1398 20199727,
1399 12000000,
1400 };
1401
1402 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1403 {
1404 return dib8000_get_adc_power(fe, 1);
1405 }
1406
1407 static struct dib8000_config dib809x_dib8000_config = {
1408 .output_mpeg2_in_188_bytes = 1,
1409
1410 .agc_config_count = 2,
1411 .agc = dib8090_agc_config,
1412 .agc_control = dib0090_dcc_freq,
1413 .pll = &dib8090_pll_config_12mhz,
1414 .tuner_is_baseband = 1,
1415
1416 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1417 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1418 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1419
1420 .hostbus_diversity = 1,
1421 .div_cfg = 0x31,
1422 .output_mode = OUTMODE_MPEG2_FIFO,
1423 .drives = 0x2d98,
1424 .diversity_delay = 144,
1425 .refclksel = 3,
1426 };
1427
1428 static struct dib0090_config dib809x_dib0090_config = {
1429 .io.pll_bypass = 1,
1430 .io.pll_range = 1,
1431 .io.pll_prediv = 1,
1432 .io.pll_loopdiv = 20,
1433 .io.adc_clock_ratio = 8,
1434 .io.pll_int_loop_filt = 0,
1435 .io.clock_khz = 12000,
1436 .reset = dib80xx_tuner_reset,
1437 .sleep = dib80xx_tuner_sleep,
1438 .clkouttobamse = 1,
1439 .analog_output = 1,
1440 .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1441 .wbd_vhf_offset = 100,
1442 .wbd_cband_offset = 450,
1443 .use_pwm_agc = 1,
1444 .clkoutdrive = 1,
1445 .get_adc_power = dib8090_get_adc_power,
1446 .freq_offset_khz_uhf = 0,
1447 .freq_offset_khz_vhf = -143,
1448 };
1449
1450 static int dib8096_set_param_override(struct dvb_frontend *fe,
1451 struct dvb_frontend_parameters *fep)
1452 {
1453 struct dvb_usb_adapter *adap = fe->dvb->priv;
1454 struct dib0700_adapter_state *state = adap->priv;
1455 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1456 u16 offset;
1457 int ret = 0;
1458 enum frontend_tune_state tune_state = CT_SHUTDOWN;
1459 u16 ltgain, rf_gain_limit;
1460
1461 ret = state->set_param_save(fe, fep);
1462 if (ret < 0)
1463 return ret;
1464
1465 switch (band) {
1466 case BAND_VHF:
1467 offset = 100;
1468 break;
1469 case BAND_UHF:
1470 offset = 550;
1471 break;
1472 default:
1473 offset = 0;
1474 break;
1475 }
1476 offset += (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1477 dib8000_set_wbd_ref(fe, offset);
1478
1479
1480 if (band == BAND_CBAND) {
1481 deb_info("tuning in CBAND - soft-AGC startup\n");
1482 /* TODO specific wbd target for dib0090 - needed for startup ? */
1483 dib0090_set_tune_state(fe, CT_AGC_START);
1484 do {
1485 ret = dib0090_gain_control(fe);
1486 msleep(ret);
1487 tune_state = dib0090_get_tune_state(fe);
1488 if (tune_state == CT_AGC_STEP_0)
1489 dib8000_set_gpio(fe, 6, 0, 1);
1490 else if (tune_state == CT_AGC_STEP_1) {
1491 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1492 if (rf_gain_limit == 0)
1493 dib8000_set_gpio(fe, 6, 0, 0);
1494 }
1495 } while (tune_state < CT_AGC_STOP);
1496 dib0090_pwm_gain_reset(fe);
1497 dib8000_pwm_agc_reset(fe);
1498 dib8000_set_tune_state(fe, CT_DEMOD_START);
1499 } else {
1500 deb_info("not tuning in CBAND - standard AGC startup\n");
1501 dib0090_pwm_gain_reset(fe);
1502 }
1503
1504 return 0;
1505 }
1506
1507 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1508 {
1509 struct dib0700_adapter_state *st = adap->priv;
1510 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1511
1512 if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1513 return -ENODEV;
1514
1515 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1516 adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1517 return 0;
1518 }
1519
1520 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1521 {
1522 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1523 msleep(10);
1524 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1525 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1526 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1527
1528 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1529
1530 dib0700_ctrl_clock(adap->dev, 72, 1);
1531
1532 msleep(10);
1533 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1534 msleep(10);
1535 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1536
1537 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1538
1539 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config);
1540
1541 return adap->fe == NULL ? -ENODEV : 0;
1542 }
1543
1544 /* STK7070PD */
1545 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
1546 {
1547 .output_mpeg2_in_188_bytes = 1,
1548
1549 .agc_config_count = 1,
1550 .agc = &dib7070_agc_config,
1551 .bw = &dib7070_bw_config_12_mhz,
1552 .tuner_is_baseband = 1,
1553 .spur_protect = 1,
1554
1555 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1556 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1557 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1558
1559 .hostbus_diversity = 1,
1560 }, {
1561 .output_mpeg2_in_188_bytes = 1,
1562
1563 .agc_config_count = 1,
1564 .agc = &dib7070_agc_config,
1565 .bw = &dib7070_bw_config_12_mhz,
1566 .tuner_is_baseband = 1,
1567 .spur_protect = 1,
1568
1569 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1570 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1571 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1572
1573 .hostbus_diversity = 1,
1574 }
1575 };
1576
1577 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
1578 {
1579 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1580 msleep(10);
1581 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1582 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1583 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1584 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1585
1586 dib0700_ctrl_clock(adap->dev, 72, 1);
1587
1588 msleep(10);
1589 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1590 msleep(10);
1591 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1592
1593 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
1594 stk7070pd_dib7000p_config) != 0) {
1595 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
1596 __func__);
1597 return -ENODEV;
1598 }
1599
1600 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
1601 return adap->fe == NULL ? -ENODEV : 0;
1602 }
1603
1604 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
1605 {
1606 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
1607 return adap->fe == NULL ? -ENODEV : 0;
1608 }
1609
1610 /* S5H1411 */
1611 static struct s5h1411_config pinnacle_801e_config = {
1612 .output_mode = S5H1411_PARALLEL_OUTPUT,
1613 .gpio = S5H1411_GPIO_OFF,
1614 .mpeg_timing = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
1615 .qam_if = S5H1411_IF_44000,
1616 .vsb_if = S5H1411_IF_44000,
1617 .inversion = S5H1411_INVERSION_OFF,
1618 .status_mode = S5H1411_DEMODLOCKING
1619 };
1620
1621 /* Pinnacle PCTV HD Pro 801e GPIOs map:
1622 GPIO0 - currently unknown
1623 GPIO1 - xc5000 tuner reset
1624 GPIO2 - CX25843 sleep
1625 GPIO3 - currently unknown
1626 GPIO4 - currently unknown
1627 GPIO6 - currently unknown
1628 GPIO7 - currently unknown
1629 GPIO9 - currently unknown
1630 GPIO10 - CX25843 reset
1631 */
1632 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
1633 {
1634 struct dib0700_state *st = adap->dev->priv;
1635
1636 /* Make use of the new i2c functions from FW 1.20 */
1637 st->fw_use_new_i2c_api = 1;
1638
1639 /* The s5h1411 requires the dib0700 to not be in master mode */
1640 st->disable_streaming_master_mode = 1;
1641
1642 /* All msleep values taken from Windows USB trace */
1643 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
1644 dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
1645 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1646 msleep(400);
1647 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1648 msleep(60);
1649 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1650 msleep(30);
1651 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1652 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1653 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1654 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1655 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
1656 msleep(30);
1657
1658 /* Put the CX25843 to sleep for now since we're in digital mode */
1659 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
1660
1661 /* GPIOs are initialized, do the attach */
1662 adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
1663 &adap->dev->i2c_adap);
1664 return adap->fe == NULL ? -ENODEV : 0;
1665 }
1666
1667 static int dib0700_xc5000_tuner_callback(void *priv, int component,
1668 int command, int arg)
1669 {
1670 struct dvb_usb_adapter *adap = priv;
1671
1672 if (command == XC5000_TUNER_RESET) {
1673 /* Reset the tuner */
1674 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
1675 msleep(10);
1676 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
1677 msleep(10);
1678 } else {
1679 err("xc5000: unknown tuner callback command: %d\n", command);
1680 return -EINVAL;
1681 }
1682
1683 return 0;
1684 }
1685
1686 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
1687 .i2c_address = 0x64,
1688 .if_khz = 5380,
1689 };
1690
1691 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
1692 {
1693 adap->fe->callback = dib0700_xc5000_tuner_callback;
1694
1695 return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
1696 &s5h1411_xc5000_tunerconfig)
1697 == NULL ? -ENODEV : 0;
1698 }
1699
1700 static struct lgdt3305_config hcw_lgdt3305_config = {
1701 .i2c_addr = 0x0e,
1702 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
1703 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
1704 .tpvalid_polarity = LGDT3305_TP_VALID_LOW,
1705 .deny_i2c_rptr = 0,
1706 .spectral_inversion = 1,
1707 .qam_if_khz = 6000,
1708 .vsb_if_khz = 6000,
1709 .usref_8vsb = 0x0500,
1710 };
1711
1712 static struct mxl5007t_config hcw_mxl5007t_config = {
1713 .xtal_freq_hz = MxL_XTAL_25_MHZ,
1714 .if_freq_hz = MxL_IF_6_MHZ,
1715 .invert_if = 1,
1716 };
1717
1718 /* TIGER-ATSC map:
1719 GPIO0 - LNA_CTR (H: LNA power enabled, L: LNA power disabled)
1720 GPIO1 - ANT_SEL (H: VPA, L: MCX)
1721 GPIO4 - SCL2
1722 GPIO6 - EN_TUNER
1723 GPIO7 - SDA2
1724 GPIO10 - DEM_RST
1725
1726 MXL is behind LG's i2c repeater. LG is on SCL2/SDA2 gpios on the DIB
1727 */
1728 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
1729 {
1730 struct dib0700_state *st = adap->dev->priv;
1731
1732 /* Make use of the new i2c functions from FW 1.20 */
1733 st->fw_use_new_i2c_api = 1;
1734
1735 st->disable_streaming_master_mode = 1;
1736
1737 /* fe power enable */
1738 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1739 msleep(30);
1740 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1741 msleep(30);
1742
1743 /* demod reset */
1744 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1745 msleep(30);
1746 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1747 msleep(30);
1748 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1749 msleep(30);
1750
1751 adap->fe = dvb_attach(lgdt3305_attach,
1752 &hcw_lgdt3305_config,
1753 &adap->dev->i2c_adap);
1754
1755 return adap->fe == NULL ? -ENODEV : 0;
1756 }
1757
1758 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
1759 {
1760 return dvb_attach(mxl5007t_attach, adap->fe,
1761 &adap->dev->i2c_adap, 0x60,
1762 &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
1763 }
1764
1765
1766 /* DVB-USB and USB stuff follows */
1767 struct usb_device_id dib0700_usb_id_table[] = {
1768 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) },
1769 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P_PC) },
1770 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
1771 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
1772 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
1773 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
1774 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500) },
1775 { USB_DEVICE(USB_VID_UNIWILL, USB_PID_UNIWILL_STK7700P) },
1776 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
1777 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
1778 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
1779 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV2000E) },
1780 { USB_DEVICE(USB_VID_TERRATEC,
1781 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
1782 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
1783 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700D) },
1784 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070P) },
1785 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
1786 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070PD) },
1787 { USB_DEVICE(USB_VID_PINNACLE,
1788 USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
1789 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500_PC) },
1790 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
1791 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
1792 { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
1793 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000) },
1794 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100) },
1795 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
1796 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
1797 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
1798 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_EXPRESSCARD_320CX) },
1799 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV72E) },
1800 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73E) },
1801 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_EC372S) },
1802 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
1803 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS) },
1804 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
1805 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
1806 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
1807 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U8000) },
1808 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700PH) },
1809 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000H) },
1810 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E) },
1811 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E_SE) },
1812 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
1813 { USB_DEVICE(USB_VID_TERRATEC,
1814 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
1815 { USB_DEVICE(USB_VID_SONY, USB_PID_SONY_PLAYTV) },
1816 /* 45 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_PD378S) },
1817 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
1818 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
1819 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_MC770) },
1820 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT) },
1821 /* 50 */{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_Dlx) },
1822 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_H) },
1823 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T3) },
1824 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T5) },
1825 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D) },
1826 /* 55 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D_2) },
1827 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73A) },
1828 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV73ESE) },
1829 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV282E) },
1830 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7770P) },
1831 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS_2) },
1832 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XPVR) },
1833 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XP) },
1834 { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
1835 { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
1836 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73ESE) },
1837 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV282E) },
1838 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK8096GP) },
1839 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DIVERSITY) },
1840 { 0 } /* Terminating entry */
1841 };
1842 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
1843
1844 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
1845 .caps = DVB_USB_IS_AN_I2C_ADAPTER, \
1846 .usb_ctrl = DEVICE_SPECIFIC, \
1847 .firmware = "dvb-usb-dib0700-1.20.fw", \
1848 .download_firmware = dib0700_download_firmware, \
1849 .no_reconnect = 1, \
1850 .size_of_priv = sizeof(struct dib0700_state), \
1851 .i2c_algo = &dib0700_i2c_algo, \
1852 .identify_state = dib0700_identify_state
1853
1854 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
1855 .streaming_ctrl = dib0700_streaming_ctrl, \
1856 .stream = { \
1857 .type = USB_BULK, \
1858 .count = 4, \
1859 .endpoint = ep, \
1860 .u = { \
1861 .bulk = { \
1862 .buffersize = 39480, \
1863 } \
1864 } \
1865 }
1866
1867 struct dvb_usb_device_properties dib0700_devices[] = {
1868 {
1869 DIB0700_DEFAULT_DEVICE_PROPERTIES,
1870
1871 .num_adapters = 1,
1872 .adapter = {
1873 {
1874 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1875 .pid_filter_count = 32,
1876 .pid_filter = stk70x0p_pid_filter,
1877 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
1878 .frontend_attach = stk7700p_frontend_attach,
1879 .tuner_attach = stk7700p_tuner_attach,
1880
1881 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1882 },
1883 },
1884
1885 .num_device_descs = 8,
1886 .devices = {
1887 { "DiBcom STK7700P reference design",
1888 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
1889 { NULL },
1890 },
1891 { "Hauppauge Nova-T Stick",
1892 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
1893 { NULL },
1894 },
1895 { "AVerMedia AVerTV DVB-T Volar",
1896 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
1897 { NULL },
1898 },
1899 { "Compro Videomate U500",
1900 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
1901 { NULL },
1902 },
1903 { "Uniwill STK7700P based (Hama and others)",
1904 { &dib0700_usb_id_table[7], NULL },
1905 { NULL },
1906 },
1907 { "Leadtek Winfast DTV Dongle (STK7700P based)",
1908 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
1909 { NULL },
1910 },
1911 { "AVerMedia AVerTV DVB-T Express",
1912 { &dib0700_usb_id_table[20] },
1913 { NULL },
1914 },
1915 { "Gigabyte U7000",
1916 { &dib0700_usb_id_table[21], NULL },
1917 { NULL },
1918 }
1919 },
1920
1921 .rc.core = {
1922 .rc_interval = DEFAULT_RC_INTERVAL,
1923 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
1924 .rc_query = dib0700_rc_query_old_firmware,
1925 .rc_props = {
1926 .allowed_protos = IR_TYPE_RC5 |
1927 IR_TYPE_RC6 |
1928 IR_TYPE_NEC,
1929 .change_protocol = dib0700_change_protocol,
1930 },
1931 },
1932 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1933
1934 .num_adapters = 2,
1935 .adapter = {
1936 {
1937 .frontend_attach = bristol_frontend_attach,
1938 .tuner_attach = bristol_tuner_attach,
1939
1940 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1941 }, {
1942 .frontend_attach = bristol_frontend_attach,
1943 .tuner_attach = bristol_tuner_attach,
1944
1945 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1946 }
1947 },
1948
1949 .num_device_descs = 1,
1950 .devices = {
1951 { "Hauppauge Nova-T 500 Dual DVB-T",
1952 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
1953 { NULL },
1954 },
1955 },
1956
1957 .rc.core = {
1958 .rc_interval = DEFAULT_RC_INTERVAL,
1959 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
1960 .rc_query = dib0700_rc_query_old_firmware,
1961 .rc_props = {
1962 .allowed_protos = IR_TYPE_RC5 |
1963 IR_TYPE_RC6 |
1964 IR_TYPE_NEC,
1965 .change_protocol = dib0700_change_protocol,
1966 },
1967 },
1968 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1969
1970 .num_adapters = 2,
1971 .adapter = {
1972 {
1973 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1974 .pid_filter_count = 32,
1975 .pid_filter = stk70x0p_pid_filter,
1976 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
1977 .frontend_attach = stk7700d_frontend_attach,
1978 .tuner_attach = stk7700d_tuner_attach,
1979
1980 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1981 }, {
1982 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1983 .pid_filter_count = 32,
1984 .pid_filter = stk70x0p_pid_filter,
1985 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
1986 .frontend_attach = stk7700d_frontend_attach,
1987 .tuner_attach = stk7700d_tuner_attach,
1988
1989 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1990 }
1991 },
1992
1993 .num_device_descs = 5,
1994 .devices = {
1995 { "Pinnacle PCTV 2000e",
1996 { &dib0700_usb_id_table[11], NULL },
1997 { NULL },
1998 },
1999 { "Terratec Cinergy DT XS Diversity",
2000 { &dib0700_usb_id_table[12], NULL },
2001 { NULL },
2002 },
2003 { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
2004 { &dib0700_usb_id_table[13], NULL },
2005 { NULL },
2006 },
2007 { "DiBcom STK7700D reference design",
2008 { &dib0700_usb_id_table[14], NULL },
2009 { NULL },
2010 },
2011 { "YUAN High-Tech DiBcom STK7700D",
2012 { &dib0700_usb_id_table[55], NULL },
2013 { NULL },
2014 },
2015
2016 },
2017
2018 .rc.core = {
2019 .rc_interval = DEFAULT_RC_INTERVAL,
2020 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2021 .rc_query = dib0700_rc_query_old_firmware,
2022 .rc_props = {
2023 .allowed_protos = IR_TYPE_RC5 |
2024 IR_TYPE_RC6 |
2025 IR_TYPE_NEC,
2026 .change_protocol = dib0700_change_protocol,
2027 },
2028 },
2029 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2030
2031 .num_adapters = 1,
2032 .adapter = {
2033 {
2034 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2035 .pid_filter_count = 32,
2036 .pid_filter = stk70x0p_pid_filter,
2037 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2038 .frontend_attach = stk7700P2_frontend_attach,
2039 .tuner_attach = stk7700d_tuner_attach,
2040
2041 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2042 },
2043 },
2044
2045 .num_device_descs = 3,
2046 .devices = {
2047 { "ASUS My Cinema U3000 Mini DVBT Tuner",
2048 { &dib0700_usb_id_table[23], NULL },
2049 { NULL },
2050 },
2051 { "Yuan EC372S",
2052 { &dib0700_usb_id_table[31], NULL },
2053 { NULL },
2054 },
2055 { "Terratec Cinergy T Express",
2056 { &dib0700_usb_id_table[42], NULL },
2057 { NULL },
2058 }
2059 },
2060
2061 .rc.core = {
2062 .rc_interval = DEFAULT_RC_INTERVAL,
2063 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2064 .module_name = "dib0700",
2065 .rc_query = dib0700_rc_query_old_firmware,
2066 .rc_props = {
2067 .allowed_protos = IR_TYPE_RC5 |
2068 IR_TYPE_RC6 |
2069 IR_TYPE_NEC,
2070 .change_protocol = dib0700_change_protocol,
2071 },
2072 },
2073 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2074
2075 .num_adapters = 1,
2076 .adapter = {
2077 {
2078 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2079 .pid_filter_count = 32,
2080 .pid_filter = stk70x0p_pid_filter,
2081 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2082 .frontend_attach = stk7070p_frontend_attach,
2083 .tuner_attach = dib7070p_tuner_attach,
2084
2085 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2086
2087 .size_of_priv = sizeof(struct dib0700_adapter_state),
2088 },
2089 },
2090
2091 .num_device_descs = 11,
2092 .devices = {
2093 { "DiBcom STK7070P reference design",
2094 { &dib0700_usb_id_table[15], NULL },
2095 { NULL },
2096 },
2097 { "Pinnacle PCTV DVB-T Flash Stick",
2098 { &dib0700_usb_id_table[16], NULL },
2099 { NULL },
2100 },
2101 { "Artec T14BR DVB-T",
2102 { &dib0700_usb_id_table[22], NULL },
2103 { NULL },
2104 },
2105 { "ASUS My Cinema U3100 Mini DVBT Tuner",
2106 { &dib0700_usb_id_table[24], NULL },
2107 { NULL },
2108 },
2109 { "Hauppauge Nova-T Stick",
2110 { &dib0700_usb_id_table[25], NULL },
2111 { NULL },
2112 },
2113 { "Hauppauge Nova-T MyTV.t",
2114 { &dib0700_usb_id_table[26], NULL },
2115 { NULL },
2116 },
2117 { "Pinnacle PCTV 72e",
2118 { &dib0700_usb_id_table[29], NULL },
2119 { NULL },
2120 },
2121 { "Pinnacle PCTV 73e",
2122 { &dib0700_usb_id_table[30], NULL },
2123 { NULL },
2124 },
2125 { "Elgato EyeTV DTT",
2126 { &dib0700_usb_id_table[49], NULL },
2127 { NULL },
2128 },
2129 { "Yuan PD378S",
2130 { &dib0700_usb_id_table[45], NULL },
2131 { NULL },
2132 },
2133 { "Elgato EyeTV Dtt Dlx PD378S",
2134 { &dib0700_usb_id_table[50], NULL },
2135 { NULL },
2136 },
2137 },
2138
2139 .rc.core = {
2140 .rc_interval = DEFAULT_RC_INTERVAL,
2141 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2142 .module_name = "dib0700",
2143 .rc_query = dib0700_rc_query_old_firmware,
2144 .rc_props = {
2145 .allowed_protos = IR_TYPE_RC5 |
2146 IR_TYPE_RC6 |
2147 IR_TYPE_NEC,
2148 .change_protocol = dib0700_change_protocol,
2149 },
2150 },
2151 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2152
2153 .num_adapters = 1,
2154 .adapter = {
2155 {
2156 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2157 .pid_filter_count = 32,
2158 .pid_filter = stk70x0p_pid_filter,
2159 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2160 .frontend_attach = stk7070p_frontend_attach,
2161 .tuner_attach = dib7070p_tuner_attach,
2162
2163 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2164
2165 .size_of_priv = sizeof(struct dib0700_adapter_state),
2166 },
2167 },
2168
2169 .num_device_descs = 3,
2170 .devices = {
2171 { "Pinnacle PCTV 73A",
2172 { &dib0700_usb_id_table[56], NULL },
2173 { NULL },
2174 },
2175 { "Pinnacle PCTV 73e SE",
2176 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
2177 { NULL },
2178 },
2179 { "Pinnacle PCTV 282e",
2180 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
2181 { NULL },
2182 },
2183 },
2184
2185 .rc.core = {
2186 .rc_interval = DEFAULT_RC_INTERVAL,
2187 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2188 .module_name = "dib0700",
2189 .rc_query = dib0700_rc_query_old_firmware,
2190 .rc_props = {
2191 .allowed_protos = IR_TYPE_RC5 |
2192 IR_TYPE_RC6 |
2193 IR_TYPE_NEC,
2194 .change_protocol = dib0700_change_protocol,
2195 },
2196 },
2197 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2198
2199 .num_adapters = 2,
2200 .adapter = {
2201 {
2202 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2203 .pid_filter_count = 32,
2204 .pid_filter = stk70x0p_pid_filter,
2205 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2206 .frontend_attach = stk7070pd_frontend_attach0,
2207 .tuner_attach = dib7070p_tuner_attach,
2208
2209 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2210
2211 .size_of_priv = sizeof(struct dib0700_adapter_state),
2212 }, {
2213 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2214 .pid_filter_count = 32,
2215 .pid_filter = stk70x0p_pid_filter,
2216 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2217 .frontend_attach = stk7070pd_frontend_attach1,
2218 .tuner_attach = dib7070p_tuner_attach,
2219
2220 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2221
2222 .size_of_priv = sizeof(struct dib0700_adapter_state),
2223 }
2224 },
2225
2226 .num_device_descs = 6,
2227 .devices = {
2228 { "DiBcom STK7070PD reference design",
2229 { &dib0700_usb_id_table[17], NULL },
2230 { NULL },
2231 },
2232 { "Pinnacle PCTV Dual DVB-T Diversity Stick",
2233 { &dib0700_usb_id_table[18], NULL },
2234 { NULL },
2235 },
2236 { "Hauppauge Nova-TD Stick (52009)",
2237 { &dib0700_usb_id_table[35], NULL },
2238 { NULL },
2239 },
2240 { "Hauppauge Nova-TD-500 (84xxx)",
2241 { &dib0700_usb_id_table[36], NULL },
2242 { NULL },
2243 },
2244 { "Terratec Cinergy DT USB XS Diversity/ T5",
2245 { &dib0700_usb_id_table[43],
2246 &dib0700_usb_id_table[53], NULL},
2247 { NULL },
2248 },
2249 { "Sony PlayTV",
2250 { &dib0700_usb_id_table[44], NULL },
2251 { NULL },
2252 },
2253 },
2254
2255 .rc.core = {
2256 .rc_interval = DEFAULT_RC_INTERVAL,
2257 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2258 .module_name = "dib0700",
2259 .rc_query = dib0700_rc_query_old_firmware,
2260 .rc_props = {
2261 .allowed_protos = IR_TYPE_RC5 |
2262 IR_TYPE_RC6 |
2263 IR_TYPE_NEC,
2264 .change_protocol = dib0700_change_protocol,
2265 },
2266 },
2267 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2268
2269 .num_adapters = 2,
2270 .adapter = {
2271 {
2272 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2273 .pid_filter_count = 32,
2274 .pid_filter = stk70x0p_pid_filter,
2275 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2276 .frontend_attach = stk7070pd_frontend_attach0,
2277 .tuner_attach = dib7070p_tuner_attach,
2278
2279 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2280
2281 .size_of_priv = sizeof(struct dib0700_adapter_state),
2282 }, {
2283 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2284 .pid_filter_count = 32,
2285 .pid_filter = stk70x0p_pid_filter,
2286 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2287 .frontend_attach = stk7070pd_frontend_attach1,
2288 .tuner_attach = dib7070p_tuner_attach,
2289
2290 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2291
2292 .size_of_priv = sizeof(struct dib0700_adapter_state),
2293 }
2294 },
2295
2296 .num_device_descs = 1,
2297 .devices = {
2298 { "Elgato EyeTV Diversity",
2299 { &dib0700_usb_id_table[68], NULL },
2300 { NULL },
2301 },
2302 },
2303
2304 .rc.core = {
2305 .rc_interval = DEFAULT_RC_INTERVAL,
2306 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
2307 .module_name = "dib0700",
2308 .rc_query = dib0700_rc_query_old_firmware,
2309 .rc_props = {
2310 .allowed_protos = IR_TYPE_RC5 |
2311 IR_TYPE_RC6 |
2312 IR_TYPE_NEC,
2313 .change_protocol = dib0700_change_protocol,
2314 },
2315 },
2316 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2317
2318 .num_adapters = 1,
2319 .adapter = {
2320 {
2321 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2322 .pid_filter_count = 32,
2323 .pid_filter = stk70x0p_pid_filter,
2324 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2325 .frontend_attach = stk7700ph_frontend_attach,
2326 .tuner_attach = stk7700ph_tuner_attach,
2327
2328 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2329
2330 .size_of_priv = sizeof(struct
2331 dib0700_adapter_state),
2332 },
2333 },
2334
2335 .num_device_descs = 9,
2336 .devices = {
2337 { "Terratec Cinergy HT USB XE",
2338 { &dib0700_usb_id_table[27], NULL },
2339 { NULL },
2340 },
2341 { "Pinnacle Expresscard 320cx",
2342 { &dib0700_usb_id_table[28], NULL },
2343 { NULL },
2344 },
2345 { "Terratec Cinergy HT Express",
2346 { &dib0700_usb_id_table[32], NULL },
2347 { NULL },
2348 },
2349 { "Gigabyte U8000-RH",
2350 { &dib0700_usb_id_table[37], NULL },
2351 { NULL },
2352 },
2353 { "YUAN High-Tech STK7700PH",
2354 { &dib0700_usb_id_table[38], NULL },
2355 { NULL },
2356 },
2357 { "Asus My Cinema-U3000Hybrid",
2358 { &dib0700_usb_id_table[39], NULL },
2359 { NULL },
2360 },
2361 { "YUAN High-Tech MC770",
2362 { &dib0700_usb_id_table[48], NULL },
2363 { NULL },
2364 },
2365 { "Leadtek WinFast DTV Dongle H",
2366 { &dib0700_usb_id_table[51], NULL },
2367 { NULL },
2368 },
2369 { "YUAN High-Tech STK7700D",
2370 { &dib0700_usb_id_table[54], NULL },
2371 { NULL },
2372 },
2373 },
2374
2375 .rc.core = {
2376 .rc_interval = DEFAULT_RC_INTERVAL,
2377 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2378 .module_name = "dib0700",
2379 .rc_query = dib0700_rc_query_old_firmware,
2380 .rc_props = {
2381 .allowed_protos = IR_TYPE_RC5 |
2382 IR_TYPE_RC6 |
2383 IR_TYPE_NEC,
2384 .change_protocol = dib0700_change_protocol,
2385 },
2386 },
2387 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2388 .num_adapters = 1,
2389 .adapter = {
2390 {
2391 .frontend_attach = s5h1411_frontend_attach,
2392 .tuner_attach = xc5000_tuner_attach,
2393
2394 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2395
2396 .size_of_priv = sizeof(struct
2397 dib0700_adapter_state),
2398 },
2399 },
2400
2401 .num_device_descs = 2,
2402 .devices = {
2403 { "Pinnacle PCTV HD Pro USB Stick",
2404 { &dib0700_usb_id_table[40], NULL },
2405 { NULL },
2406 },
2407 { "Pinnacle PCTV HD USB Stick",
2408 { &dib0700_usb_id_table[41], NULL },
2409 { NULL },
2410 },
2411 },
2412
2413 .rc.core = {
2414 .rc_interval = DEFAULT_RC_INTERVAL,
2415 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2416 .module_name = "dib0700",
2417 .rc_query = dib0700_rc_query_old_firmware,
2418 .rc_props = {
2419 .allowed_protos = IR_TYPE_RC5 |
2420 IR_TYPE_RC6 |
2421 IR_TYPE_NEC,
2422 .change_protocol = dib0700_change_protocol,
2423 },
2424 },
2425 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2426 .num_adapters = 1,
2427 .adapter = {
2428 {
2429 .frontend_attach = lgdt3305_frontend_attach,
2430 .tuner_attach = mxl5007t_tuner_attach,
2431
2432 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2433
2434 .size_of_priv = sizeof(struct
2435 dib0700_adapter_state),
2436 },
2437 },
2438
2439 .num_device_descs = 2,
2440 .devices = {
2441 { "Hauppauge ATSC MiniCard (B200)",
2442 { &dib0700_usb_id_table[46], NULL },
2443 { NULL },
2444 },
2445 { "Hauppauge ATSC MiniCard (B210)",
2446 { &dib0700_usb_id_table[47], NULL },
2447 { NULL },
2448 },
2449 },
2450 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2451
2452 .num_adapters = 1,
2453 .adapter = {
2454 {
2455 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2456 .pid_filter_count = 32,
2457 .pid_filter = stk70x0p_pid_filter,
2458 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2459 .frontend_attach = stk7770p_frontend_attach,
2460 .tuner_attach = dib7770p_tuner_attach,
2461
2462 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2463
2464 .size_of_priv =
2465 sizeof(struct dib0700_adapter_state),
2466 },
2467 },
2468
2469 .num_device_descs = 2,
2470 .devices = {
2471 { "DiBcom STK7770P reference design",
2472 { &dib0700_usb_id_table[59], NULL },
2473 { NULL },
2474 },
2475 { "Terratec Cinergy T USB XXS (HD)/ T3",
2476 { &dib0700_usb_id_table[33],
2477 &dib0700_usb_id_table[52],
2478 &dib0700_usb_id_table[60], NULL},
2479 { NULL },
2480 },
2481 },
2482
2483 .rc.core = {
2484 .rc_interval = DEFAULT_RC_INTERVAL,
2485 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2486 .module_name = "dib0700",
2487 .rc_query = dib0700_rc_query_old_firmware,
2488 .rc_props = {
2489 .allowed_protos = IR_TYPE_RC5 |
2490 IR_TYPE_RC6 |
2491 IR_TYPE_NEC,
2492 .change_protocol = dib0700_change_protocol,
2493 },
2494 },
2495 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2496 .num_adapters = 1,
2497 .adapter = {
2498 {
2499 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2500 .pid_filter_count = 32,
2501 .pid_filter = stk80xx_pid_filter,
2502 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2503 .frontend_attach = stk807x_frontend_attach,
2504 .tuner_attach = dib807x_tuner_attach,
2505
2506 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2507
2508 .size_of_priv =
2509 sizeof(struct dib0700_adapter_state),
2510 },
2511 },
2512
2513 .num_device_descs = 3,
2514 .devices = {
2515 { "DiBcom STK807xP reference design",
2516 { &dib0700_usb_id_table[62], NULL },
2517 { NULL },
2518 },
2519 { "Prolink Pixelview SBTVD",
2520 { &dib0700_usb_id_table[63], NULL },
2521 { NULL },
2522 },
2523 { "EvolutePC TVWay+",
2524 { &dib0700_usb_id_table[64], NULL },
2525 { NULL },
2526 },
2527 },
2528
2529 .rc.core = {
2530 .rc_interval = DEFAULT_RC_INTERVAL,
2531 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
2532 .module_name = "dib0700",
2533 .rc_query = dib0700_rc_query_old_firmware,
2534 .rc_props = {
2535 .allowed_protos = IR_TYPE_RC5 |
2536 IR_TYPE_RC6 |
2537 IR_TYPE_NEC,
2538 .change_protocol = dib0700_change_protocol,
2539 },
2540 },
2541 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2542 .num_adapters = 2,
2543 .adapter = {
2544 {
2545 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2546 .pid_filter_count = 32,
2547 .pid_filter = stk80xx_pid_filter,
2548 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2549 .frontend_attach = stk807xpvr_frontend_attach0,
2550 .tuner_attach = dib807x_tuner_attach,
2551
2552 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2553
2554 .size_of_priv =
2555 sizeof(struct dib0700_adapter_state),
2556 },
2557 {
2558 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2559 .pid_filter_count = 32,
2560 .pid_filter = stk80xx_pid_filter,
2561 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2562 .frontend_attach = stk807xpvr_frontend_attach1,
2563 .tuner_attach = dib807x_tuner_attach,
2564
2565 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2566
2567 .size_of_priv =
2568 sizeof(struct dib0700_adapter_state),
2569 },
2570 },
2571
2572 .num_device_descs = 1,
2573 .devices = {
2574 { "DiBcom STK807xPVR reference design",
2575 { &dib0700_usb_id_table[61], NULL },
2576 { NULL },
2577 },
2578 },
2579
2580 .rc.core = {
2581 .rc_interval = DEFAULT_RC_INTERVAL,
2582 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2583 .module_name = "dib0700",
2584 .rc_query = dib0700_rc_query_old_firmware,
2585 .rc_props = {
2586 .allowed_protos = IR_TYPE_RC5 |
2587 IR_TYPE_RC6 |
2588 IR_TYPE_NEC,
2589 .change_protocol = dib0700_change_protocol,
2590 },
2591 },
2592 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2593 .num_adapters = 1,
2594 .adapter = {
2595 {
2596 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
2597 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2598 .pid_filter_count = 32,
2599 .pid_filter = stk80xx_pid_filter,
2600 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2601 .frontend_attach = stk809x_frontend_attach,
2602 .tuner_attach = dib809x_tuner_attach,
2603
2604 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2605
2606 .size_of_priv =
2607 sizeof(struct dib0700_adapter_state),
2608 },
2609 },
2610
2611 .num_device_descs = 1,
2612 .devices = {
2613 { "DiBcom STK8096GP reference design",
2614 { &dib0700_usb_id_table[67], NULL },
2615 { NULL },
2616 },
2617 },
2618
2619 .rc.core = {
2620 .rc_interval = DEFAULT_RC_INTERVAL,
2621 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2622 .module_name = "dib0700",
2623 .rc_query = dib0700_rc_query_old_firmware,
2624 .rc_props = {
2625 .allowed_protos = IR_TYPE_RC5 |
2626 IR_TYPE_RC6 |
2627 IR_TYPE_NEC,
2628 .change_protocol = dib0700_change_protocol,
2629 },
2630 },
2631 },
2632 };
2633
2634 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
Tomato firmware and modifications.