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