?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB: dib0700: properly implement IR change_protocol
[linux-2.6.git] / drivers / media / dvb / dvb-usb / dib0700_devices.c
blobf634d2e784b2ce24a005b0593372b505b903e1c3
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 IR_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 ir_keydown(d->rc_input_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 ir_keydown(d->rc_input_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 /* DIB807x generic */
944 static struct dibx000_agc_config dib807x_agc_config[2] = {
945 {
946 BAND_VHF,
947 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
948 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
949 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
950 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
951 * P_agc_write=0 */
952 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
953 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
954 (0 << 0), /* setup*/
955
956 600, /* inv_gain*/
957 10, /* time_stabiliz*/
958
959 0, /* alpha_level*/
960 118, /* thlock*/
961
962 0, /* wbd_inv*/
963 3530, /* wbd_ref*/
964 1, /* wbd_sel*/
965 5, /* wbd_alpha*/
966
967 65535, /* agc1_max*/
968 0, /* agc1_min*/
969
970 65535, /* agc2_max*/
971 0, /* agc2_min*/
972
973 0, /* agc1_pt1*/
974 40, /* agc1_pt2*/
975 183, /* agc1_pt3*/
976 206, /* agc1_slope1*/
977 255, /* agc1_slope2*/
978 72, /* agc2_pt1*/
979 152, /* agc2_pt2*/
980 88, /* agc2_slope1*/
981 90, /* agc2_slope2*/
982
983 17, /* alpha_mant*/
984 27, /* alpha_exp*/
985 23, /* beta_mant*/
986 51, /* beta_exp*/
987
988 0, /* perform_agc_softsplit*/
989 }, {
990 BAND_UHF,
991 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
992 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
993 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
994 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
995 * P_agc_write=0 */
996 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
997 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
998 (0 << 0), /* setup */
999
1000 600, /* inv_gain*/
1001 10, /* time_stabiliz*/
1002
1003 0, /* alpha_level*/
1004 118, /* thlock*/
1005
1006 0, /* wbd_inv*/
1007 3530, /* wbd_ref*/
1008 1, /* wbd_sel*/
1009 5, /* wbd_alpha*/
1010
1011 65535, /* agc1_max*/
1012 0, /* agc1_min*/
1013
1014 65535, /* agc2_max*/
1015 0, /* agc2_min*/
1016
1017 0, /* agc1_pt1*/
1018 40, /* agc1_pt2*/
1019 183, /* agc1_pt3*/
1020 206, /* agc1_slope1*/
1021 255, /* agc1_slope2*/
1022 72, /* agc2_pt1*/
1023 152, /* agc2_pt2*/
1024 88, /* agc2_slope1*/
1025 90, /* agc2_slope2*/
1026
1027 17, /* alpha_mant*/
1028 27, /* alpha_exp*/
1029 23, /* beta_mant*/
1030 51, /* beta_exp*/
1031
1032 0, /* perform_agc_softsplit*/
1033 }
1034 };
1035
1036 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1037 60000, 15000, /* internal, sampling*/
1038 1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1039 0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1040 ADClkSrc, modulo */
1041 (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1042 (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1043 18179755, /* timf*/
1044 12000000, /* xtal_hz*/
1045 };
1046
1047 static struct dib8000_config dib807x_dib8000_config[2] = {
1048 {
1049 .output_mpeg2_in_188_bytes = 1,
1050
1051 .agc_config_count = 2,
1052 .agc = dib807x_agc_config,
1053 .pll = &dib807x_bw_config_12_mhz,
1054 .tuner_is_baseband = 1,
1055
1056 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1057 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1058 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1059
1060 .hostbus_diversity = 1,
1061 .div_cfg = 1,
1062 .agc_control = &dib0070_ctrl_agc_filter,
1063 .output_mode = OUTMODE_MPEG2_FIFO,
1064 .drives = 0x2d98,
1065 }, {
1066 .output_mpeg2_in_188_bytes = 1,
1067
1068 .agc_config_count = 2,
1069 .agc = dib807x_agc_config,
1070 .pll = &dib807x_bw_config_12_mhz,
1071 .tuner_is_baseband = 1,
1072
1073 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1074 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1075 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1076
1077 .hostbus_diversity = 1,
1078 .agc_control = &dib0070_ctrl_agc_filter,
1079 .output_mode = OUTMODE_MPEG2_FIFO,
1080 .drives = 0x2d98,
1081 }
1082 };
1083
1084 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1085 {
1086 return dib8000_set_gpio(fe, 5, 0, !onoff);
1087 }
1088
1089 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1090 {
1091 return dib8000_set_gpio(fe, 0, 0, onoff);
1092 }
1093
1094 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1095 { 240, 7},
1096 { 0xffff, 6},
1097 };
1098
1099 static struct dib0070_config dib807x_dib0070_config[2] = {
1100 {
1101 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1102 .reset = dib80xx_tuner_reset,
1103 .sleep = dib80xx_tuner_sleep,
1104 .clock_khz = 12000,
1105 .clock_pad_drive = 4,
1106 .vga_filter = 1,
1107 .force_crystal_mode = 1,
1108 .enable_third_order_filter = 1,
1109 .charge_pump = 0,
1110 .wbd_gain = dib8070_wbd_gain_cfg,
1111 .osc_buffer_state = 0,
1112 .freq_offset_khz_uhf = -100,
1113 .freq_offset_khz_vhf = -100,
1114 }, {
1115 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1116 .reset = dib80xx_tuner_reset,
1117 .sleep = dib80xx_tuner_sleep,
1118 .clock_khz = 12000,
1119 .clock_pad_drive = 2,
1120 .vga_filter = 1,
1121 .force_crystal_mode = 1,
1122 .enable_third_order_filter = 1,
1123 .charge_pump = 0,
1124 .wbd_gain = dib8070_wbd_gain_cfg,
1125 .osc_buffer_state = 0,
1126 .freq_offset_khz_uhf = -25,
1127 .freq_offset_khz_vhf = -25,
1128 }
1129 };
1130
1131 static int dib807x_set_param_override(struct dvb_frontend *fe,
1132 struct dvb_frontend_parameters *fep)
1133 {
1134 struct dvb_usb_adapter *adap = fe->dvb->priv;
1135 struct dib0700_adapter_state *state = adap->priv;
1136
1137 u16 offset = dib0070_wbd_offset(fe);
1138 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1139 switch (band) {
1140 case BAND_VHF:
1141 offset += 750;
1142 break;
1143 case BAND_UHF: /* fall-thru wanted */
1144 default:
1145 offset += 250; break;
1146 }
1147 deb_info("WBD for DiB8000: %d\n", offset);
1148 dib8000_set_wbd_ref(fe, offset);
1149
1150 return state->set_param_save(fe, fep);
1151 }
1152
1153 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1154 {
1155 struct dib0700_adapter_state *st = adap->priv;
1156 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1157 DIBX000_I2C_INTERFACE_TUNER, 1);
1158
1159 if (adap->id == 0) {
1160 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1161 &dib807x_dib0070_config[0]) == NULL)
1162 return -ENODEV;
1163 } else {
1164 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1165 &dib807x_dib0070_config[1]) == NULL)
1166 return -ENODEV;
1167 }
1168
1169 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1170 adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1171 return 0;
1172 }
1173
1174 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1175 u16 pid, int onoff)
1176 {
1177 return dib8000_pid_filter(adapter->fe, index, pid, onoff);
1178 }
1179
1180 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1181 int onoff)
1182 {
1183 return dib8000_pid_filter_ctrl(adapter->fe, onoff);
1184 }
1185
1186 /* STK807x */
1187 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1188 {
1189 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1190 msleep(10);
1191 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1192 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1193 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1194
1195 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1196
1197 dib0700_ctrl_clock(adap->dev, 72, 1);
1198
1199 msleep(10);
1200 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1201 msleep(10);
1202 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1203
1204 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1205 0x80);
1206
1207 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1208 &dib807x_dib8000_config[0]);
1209
1210 return adap->fe == NULL ? -ENODEV : 0;
1211 }
1212
1213 /* STK807xPVR */
1214 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1215 {
1216 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1217 msleep(30);
1218 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1219 msleep(500);
1220 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1221 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1222 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1223
1224 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1225
1226 dib0700_ctrl_clock(adap->dev, 72, 1);
1227
1228 msleep(10);
1229 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1230 msleep(10);
1231 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1232
1233 /* initialize IC 0 */
1234 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
1235
1236 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1237 &dib807x_dib8000_config[0]);
1238
1239 return adap->fe == NULL ? -ENODEV : 0;
1240 }
1241
1242 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1243 {
1244 /* initialize IC 1 */
1245 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
1246
1247 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1248 &dib807x_dib8000_config[1]);
1249
1250 return adap->fe == NULL ? -ENODEV : 0;
1251 }
1252
1253 /* STK8096GP */
1254 struct dibx000_agc_config dib8090_agc_config[2] = {
1255 {
1256 BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1257 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1258 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1259 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1260 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1261 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1262
1263 787,
1264 10,
1265
1266 0,
1267 118,
1268
1269 0,
1270 3530,
1271 1,
1272 5,
1273
1274 65535,
1275 0,
1276
1277 65535,
1278 0,
1279
1280 0,
1281 32,
1282 114,
1283 143,
1284 144,
1285 114,
1286 227,
1287 116,
1288 117,
1289
1290 28,
1291 26,
1292 31,
1293 51,
1294
1295 0,
1296 },
1297 {
1298 BAND_CBAND,
1299 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1300 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1301 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1302 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1303 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1304
1305 787,
1306 10,
1307
1308 0,
1309 118,
1310
1311 0,
1312 3530,
1313 1,
1314 5,
1315
1316 0,
1317 0,
1318
1319 65535,
1320 0,
1321
1322 0,
1323 32,
1324 114,
1325 143,
1326 144,
1327 114,
1328 227,
1329 116,
1330 117,
1331
1332 28,
1333 26,
1334 31,
1335 51,
1336
1337 0,
1338 }
1339 };
1340
1341 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1342 54000, 13500,
1343 1, 18, 3, 1, 0,
1344 0, 0, 1, 1, 2,
1345 (3 << 14) | (1 << 12) | (599 << 0),
1346 (0 << 25) | 0,
1347 20199727,
1348 12000000,
1349 };
1350
1351 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1352 {
1353 return dib8000_get_adc_power(fe, 1);
1354 }
1355
1356 static struct dib8000_config dib809x_dib8000_config = {
1357 .output_mpeg2_in_188_bytes = 1,
1358
1359 .agc_config_count = 2,
1360 .agc = dib8090_agc_config,
1361 .agc_control = dib0090_dcc_freq,
1362 .pll = &dib8090_pll_config_12mhz,
1363 .tuner_is_baseband = 1,
1364
1365 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1366 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1367 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1368
1369 .hostbus_diversity = 1,
1370 .div_cfg = 0x31,
1371 .output_mode = OUTMODE_MPEG2_FIFO,
1372 .drives = 0x2d98,
1373 .diversity_delay = 144,
1374 .refclksel = 3,
1375 };
1376
1377 static struct dib0090_config dib809x_dib0090_config = {
1378 .io.pll_bypass = 1,
1379 .io.pll_range = 1,
1380 .io.pll_prediv = 1,
1381 .io.pll_loopdiv = 20,
1382 .io.adc_clock_ratio = 8,
1383 .io.pll_int_loop_filt = 0,
1384 .io.clock_khz = 12000,
1385 .reset = dib80xx_tuner_reset,
1386 .sleep = dib80xx_tuner_sleep,
1387 .clkouttobamse = 1,
1388 .analog_output = 1,
1389 .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1390 .wbd_vhf_offset = 100,
1391 .wbd_cband_offset = 450,
1392 .use_pwm_agc = 1,
1393 .clkoutdrive = 1,
1394 .get_adc_power = dib8090_get_adc_power,
1395 .freq_offset_khz_uhf = 0,
1396 .freq_offset_khz_vhf = -143,
1397 };
1398
1399 static int dib8096_set_param_override(struct dvb_frontend *fe,
1400 struct dvb_frontend_parameters *fep)
1401 {
1402 struct dvb_usb_adapter *adap = fe->dvb->priv;
1403 struct dib0700_adapter_state *state = adap->priv;
1404 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1405 u16 offset;
1406 int ret = 0;
1407 enum frontend_tune_state tune_state = CT_SHUTDOWN;
1408 u16 ltgain, rf_gain_limit;
1409
1410 ret = state->set_param_save(fe, fep);
1411 if (ret < 0)
1412 return ret;
1413
1414 switch (band) {
1415 case BAND_VHF:
1416 offset = 100;
1417 break;
1418 case BAND_UHF:
1419 offset = 550;
1420 break;
1421 default:
1422 offset = 0;
1423 break;
1424 }
1425 offset += (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1426 dib8000_set_wbd_ref(fe, offset);
1427
1428
1429 if (band == BAND_CBAND) {
1430 deb_info("tuning in CBAND - soft-AGC startup\n");
1431 /* TODO specific wbd target for dib0090 - needed for startup ? */
1432 dib0090_set_tune_state(fe, CT_AGC_START);
1433 do {
1434 ret = dib0090_gain_control(fe);
1435 msleep(ret);
1436 tune_state = dib0090_get_tune_state(fe);
1437 if (tune_state == CT_AGC_STEP_0)
1438 dib8000_set_gpio(fe, 6, 0, 1);
1439 else if (tune_state == CT_AGC_STEP_1) {
1440 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1441 if (rf_gain_limit == 0)
1442 dib8000_set_gpio(fe, 6, 0, 0);
1443 }
1444 } while (tune_state < CT_AGC_STOP);
1445 dib0090_pwm_gain_reset(fe);
1446 dib8000_pwm_agc_reset(fe);
1447 dib8000_set_tune_state(fe, CT_DEMOD_START);
1448 } else {
1449 deb_info("not tuning in CBAND - standard AGC startup\n");
1450 dib0090_pwm_gain_reset(fe);
1451 }
1452
1453 return 0;
1454 }
1455
1456 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1457 {
1458 struct dib0700_adapter_state *st = adap->priv;
1459 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1460
1461 if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1462 return -ENODEV;
1463
1464 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1465 adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1466 return 0;
1467 }
1468
1469 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1470 {
1471 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1472 msleep(10);
1473 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1474 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1475 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1476
1477 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1478
1479 dib0700_ctrl_clock(adap->dev, 72, 1);
1480
1481 msleep(10);
1482 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1483 msleep(10);
1484 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1485
1486 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1487
1488 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config);
1489
1490 return adap->fe == NULL ? -ENODEV : 0;
1491 }
1492
1493 /* STK7070PD */
1494 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
1495 {
1496 .output_mpeg2_in_188_bytes = 1,
1497
1498 .agc_config_count = 1,
1499 .agc = &dib7070_agc_config,
1500 .bw = &dib7070_bw_config_12_mhz,
1501 .tuner_is_baseband = 1,
1502 .spur_protect = 1,
1503
1504 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1505 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1506 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1507
1508 .hostbus_diversity = 1,
1509 }, {
1510 .output_mpeg2_in_188_bytes = 1,
1511
1512 .agc_config_count = 1,
1513 .agc = &dib7070_agc_config,
1514 .bw = &dib7070_bw_config_12_mhz,
1515 .tuner_is_baseband = 1,
1516 .spur_protect = 1,
1517
1518 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1519 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1520 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1521
1522 .hostbus_diversity = 1,
1523 }
1524 };
1525
1526 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
1527 {
1528 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1529 msleep(10);
1530 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1531 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1532 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1533 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1534
1535 dib0700_ctrl_clock(adap->dev, 72, 1);
1536
1537 msleep(10);
1538 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1539 msleep(10);
1540 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1541
1542 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
1543 stk7070pd_dib7000p_config) != 0) {
1544 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
1545 __func__);
1546 return -ENODEV;
1547 }
1548
1549 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
1550 return adap->fe == NULL ? -ENODEV : 0;
1551 }
1552
1553 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
1554 {
1555 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
1556 return adap->fe == NULL ? -ENODEV : 0;
1557 }
1558
1559 /* S5H1411 */
1560 static struct s5h1411_config pinnacle_801e_config = {
1561 .output_mode = S5H1411_PARALLEL_OUTPUT,
1562 .gpio = S5H1411_GPIO_OFF,
1563 .mpeg_timing = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
1564 .qam_if = S5H1411_IF_44000,
1565 .vsb_if = S5H1411_IF_44000,
1566 .inversion = S5H1411_INVERSION_OFF,
1567 .status_mode = S5H1411_DEMODLOCKING
1568 };
1569
1570 /* Pinnacle PCTV HD Pro 801e GPIOs map:
1571 GPIO0 - currently unknown
1572 GPIO1 - xc5000 tuner reset
1573 GPIO2 - CX25843 sleep
1574 GPIO3 - currently unknown
1575 GPIO4 - currently unknown
1576 GPIO6 - currently unknown
1577 GPIO7 - currently unknown
1578 GPIO9 - currently unknown
1579 GPIO10 - CX25843 reset
1580 */
1581 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
1582 {
1583 struct dib0700_state *st = adap->dev->priv;
1584
1585 /* Make use of the new i2c functions from FW 1.20 */
1586 st->fw_use_new_i2c_api = 1;
1587
1588 /* The s5h1411 requires the dib0700 to not be in master mode */
1589 st->disable_streaming_master_mode = 1;
1590
1591 /* All msleep values taken from Windows USB trace */
1592 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
1593 dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
1594 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1595 msleep(400);
1596 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1597 msleep(60);
1598 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1599 msleep(30);
1600 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1601 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1602 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1603 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1604 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
1605 msleep(30);
1606
1607 /* Put the CX25843 to sleep for now since we're in digital mode */
1608 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
1609
1610 /* GPIOs are initialized, do the attach */
1611 adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
1612 &adap->dev->i2c_adap);
1613 return adap->fe == NULL ? -ENODEV : 0;
1614 }
1615
1616 static int dib0700_xc5000_tuner_callback(void *priv, int component,
1617 int command, int arg)
1618 {
1619 struct dvb_usb_adapter *adap = priv;
1620
1621 if (command == XC5000_TUNER_RESET) {
1622 /* Reset the tuner */
1623 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
1624 msleep(10);
1625 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
1626 msleep(10);
1627 } else {
1628 err("xc5000: unknown tuner callback command: %d\n", command);
1629 return -EINVAL;
1630 }
1631
1632 return 0;
1633 }
1634
1635 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
1636 .i2c_address = 0x64,
1637 .if_khz = 5380,
1638 };
1639
1640 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
1641 {
1642 /* FIXME: generalize & move to common area */
1643 adap->fe->callback = dib0700_xc5000_tuner_callback;
1644
1645 return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
1646 &s5h1411_xc5000_tunerconfig)
1647 == NULL ? -ENODEV : 0;
1648 }
1649
1650 static struct lgdt3305_config hcw_lgdt3305_config = {
1651 .i2c_addr = 0x0e,
1652 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
1653 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
1654 .tpvalid_polarity = LGDT3305_TP_VALID_LOW,
1655 .deny_i2c_rptr = 0,
1656 .spectral_inversion = 1,
1657 .qam_if_khz = 6000,
1658 .vsb_if_khz = 6000,
1659 .usref_8vsb = 0x0500,
1660 };
1661
1662 static struct mxl5007t_config hcw_mxl5007t_config = {
1663 .xtal_freq_hz = MxL_XTAL_25_MHZ,
1664 .if_freq_hz = MxL_IF_6_MHZ,
1665 .invert_if = 1,
1666 };
1667
1668 /* TIGER-ATSC map:
1669 GPIO0 - LNA_CTR (H: LNA power enabled, L: LNA power disabled)
1670 GPIO1 - ANT_SEL (H: VPA, L: MCX)
1671 GPIO4 - SCL2
1672 GPIO6 - EN_TUNER
1673 GPIO7 - SDA2
1674 GPIO10 - DEM_RST
1675
1676 MXL is behind LG's i2c repeater. LG is on SCL2/SDA2 gpios on the DIB
1677 */
1678 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
1679 {
1680 struct dib0700_state *st = adap->dev->priv;
1681
1682 /* Make use of the new i2c functions from FW 1.20 */
1683 st->fw_use_new_i2c_api = 1;
1684
1685 st->disable_streaming_master_mode = 1;
1686
1687 /* fe power enable */
1688 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1689 msleep(30);
1690 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1691 msleep(30);
1692
1693 /* demod reset */
1694 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1695 msleep(30);
1696 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1697 msleep(30);
1698 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1699 msleep(30);
1700
1701 adap->fe = dvb_attach(lgdt3305_attach,
1702 &hcw_lgdt3305_config,
1703 &adap->dev->i2c_adap);
1704
1705 return adap->fe == NULL ? -ENODEV : 0;
1706 }
1707
1708 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
1709 {
1710 return dvb_attach(mxl5007t_attach, adap->fe,
1711 &adap->dev->i2c_adap, 0x60,
1712 &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
1713 }
1714
1715
1716 /* DVB-USB and USB stuff follows */
1717 struct usb_device_id dib0700_usb_id_table[] = {
1718 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) },
1719 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P_PC) },
1720 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
1721 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
1722 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
1723 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
1724 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500) },
1725 { USB_DEVICE(USB_VID_UNIWILL, USB_PID_UNIWILL_STK7700P) },
1726 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
1727 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
1728 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
1729 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV2000E) },
1730 { USB_DEVICE(USB_VID_TERRATEC,
1731 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
1732 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
1733 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700D) },
1734 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070P) },
1735 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
1736 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070PD) },
1737 { USB_DEVICE(USB_VID_PINNACLE,
1738 USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
1739 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500_PC) },
1740 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
1741 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
1742 { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
1743 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000) },
1744 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100) },
1745 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
1746 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
1747 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
1748 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_EXPRESSCARD_320CX) },
1749 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV72E) },
1750 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73E) },
1751 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_EC372S) },
1752 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
1753 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS) },
1754 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
1755 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
1756 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
1757 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U8000) },
1758 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700PH) },
1759 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000H) },
1760 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E) },
1761 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E_SE) },
1762 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
1763 { USB_DEVICE(USB_VID_TERRATEC,
1764 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
1765 { USB_DEVICE(USB_VID_SONY, USB_PID_SONY_PLAYTV) },
1766 /* 45 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_PD378S) },
1767 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
1768 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
1769 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_MC770) },
1770 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT) },
1771 /* 50 */{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_Dlx) },
1772 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_H) },
1773 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T3) },
1774 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T5) },
1775 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D) },
1776 /* 55 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D_2) },
1777 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73A) },
1778 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV73ESE) },
1779 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV282E) },
1780 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7770P) },
1781 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS_2) },
1782 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XPVR) },
1783 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XP) },
1784 { USB_DEVICE(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD) },
1785 { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
1786 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73ESE) },
1787 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV282E) },
1788 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK8096GP) },
1789 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DIVERSITY) },
1790 { 0 } /* Terminating entry */
1791 };
1792 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
1793
1794 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
1795 .caps = DVB_USB_IS_AN_I2C_ADAPTER, \
1796 .usb_ctrl = DEVICE_SPECIFIC, \
1797 .firmware = "dvb-usb-dib0700-1.20.fw", \
1798 .download_firmware = dib0700_download_firmware, \
1799 .no_reconnect = 1, \
1800 .size_of_priv = sizeof(struct dib0700_state), \
1801 .i2c_algo = &dib0700_i2c_algo, \
1802 .identify_state = dib0700_identify_state
1803
1804 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
1805 .streaming_ctrl = dib0700_streaming_ctrl, \
1806 .stream = { \
1807 .type = USB_BULK, \
1808 .count = 4, \
1809 .endpoint = ep, \
1810 .u = { \
1811 .bulk = { \
1812 .buffersize = 39480, \
1813 } \
1814 } \
1815 }
1816
1817 struct dvb_usb_device_properties dib0700_devices[] = {
1818 {
1819 DIB0700_DEFAULT_DEVICE_PROPERTIES,
1820
1821 .num_adapters = 1,
1822 .adapter = {
1823 {
1824 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1825 .pid_filter_count = 32,
1826 .pid_filter = stk70x0p_pid_filter,
1827 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
1828 .frontend_attach = stk7700p_frontend_attach,
1829 .tuner_attach = stk7700p_tuner_attach,
1830
1831 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1832 },
1833 },
1834
1835 .num_device_descs = 8,
1836 .devices = {
1837 { "DiBcom STK7700P reference design",
1838 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
1839 { NULL },
1840 },
1841 { "Hauppauge Nova-T Stick",
1842 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
1843 { NULL },
1844 },
1845 { "AVerMedia AVerTV DVB-T Volar",
1846 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
1847 { NULL },
1848 },
1849 { "Compro Videomate U500",
1850 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
1851 { NULL },
1852 },
1853 { "Uniwill STK7700P based (Hama and others)",
1854 { &dib0700_usb_id_table[7], NULL },
1855 { NULL },
1856 },
1857 { "Leadtek Winfast DTV Dongle (STK7700P based)",
1858 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
1859 { NULL },
1860 },
1861 { "AVerMedia AVerTV DVB-T Express",
1862 { &dib0700_usb_id_table[20] },
1863 { NULL },
1864 },
1865 { "Gigabyte U7000",
1866 { &dib0700_usb_id_table[21], NULL },
1867 { NULL },
1868 }
1869 },
1870
1871 .rc.core = {
1872 .rc_interval = DEFAULT_RC_INTERVAL,
1873 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
1874 .rc_query = dib0700_rc_query_old_firmware,
1875 .rc_props = {
1876 .allowed_protos = IR_TYPE_RC5 |
1877 IR_TYPE_RC6 |
1878 IR_TYPE_NEC,
1879 .change_protocol = dib0700_change_protocol,
1880 },
1881 },
1882 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1883
1884 .num_adapters = 2,
1885 .adapter = {
1886 {
1887 .frontend_attach = bristol_frontend_attach,
1888 .tuner_attach = bristol_tuner_attach,
1889
1890 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1891 }, {
1892 .frontend_attach = bristol_frontend_attach,
1893 .tuner_attach = bristol_tuner_attach,
1894
1895 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1896 }
1897 },
1898
1899 .num_device_descs = 1,
1900 .devices = {
1901 { "Hauppauge Nova-T 500 Dual DVB-T",
1902 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
1903 { NULL },
1904 },
1905 },
1906
1907 .rc.core = {
1908 .rc_interval = DEFAULT_RC_INTERVAL,
1909 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
1910 .rc_query = dib0700_rc_query_old_firmware,
1911 .rc_props = {
1912 .allowed_protos = IR_TYPE_RC5 |
1913 IR_TYPE_RC6 |
1914 IR_TYPE_NEC,
1915 .change_protocol = dib0700_change_protocol,
1916 },
1917 },
1918 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1919
1920 .num_adapters = 2,
1921 .adapter = {
1922 {
1923 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1924 .pid_filter_count = 32,
1925 .pid_filter = stk70x0p_pid_filter,
1926 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
1927 .frontend_attach = stk7700d_frontend_attach,
1928 .tuner_attach = stk7700d_tuner_attach,
1929
1930 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1931 }, {
1932 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1933 .pid_filter_count = 32,
1934 .pid_filter = stk70x0p_pid_filter,
1935 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
1936 .frontend_attach = stk7700d_frontend_attach,
1937 .tuner_attach = stk7700d_tuner_attach,
1938
1939 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1940 }
1941 },
1942
1943 .num_device_descs = 5,
1944 .devices = {
1945 { "Pinnacle PCTV 2000e",
1946 { &dib0700_usb_id_table[11], NULL },
1947 { NULL },
1948 },
1949 { "Terratec Cinergy DT XS Diversity",
1950 { &dib0700_usb_id_table[12], NULL },
1951 { NULL },
1952 },
1953 { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
1954 { &dib0700_usb_id_table[13], NULL },
1955 { NULL },
1956 },
1957 { "DiBcom STK7700D reference design",
1958 { &dib0700_usb_id_table[14], NULL },
1959 { NULL },
1960 },
1961 { "YUAN High-Tech DiBcom STK7700D",
1962 { &dib0700_usb_id_table[55], NULL },
1963 { NULL },
1964 },
1965
1966 },
1967
1968 .rc.core = {
1969 .rc_interval = DEFAULT_RC_INTERVAL,
1970 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
1971 .rc_query = dib0700_rc_query_old_firmware,
1972 .rc_props = {
1973 .allowed_protos = IR_TYPE_RC5 |
1974 IR_TYPE_RC6 |
1975 IR_TYPE_NEC,
1976 .change_protocol = dib0700_change_protocol,
1977 },
1978 },
1979 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1980
1981 .num_adapters = 1,
1982 .adapter = {
1983 {
1984 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1985 .pid_filter_count = 32,
1986 .pid_filter = stk70x0p_pid_filter,
1987 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
1988 .frontend_attach = stk7700P2_frontend_attach,
1989 .tuner_attach = stk7700d_tuner_attach,
1990
1991 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1992 },
1993 },
1994
1995 .num_device_descs = 3,
1996 .devices = {
1997 { "ASUS My Cinema U3000 Mini DVBT Tuner",
1998 { &dib0700_usb_id_table[23], NULL },
1999 { NULL },
2000 },
2001 { "Yuan EC372S",
2002 { &dib0700_usb_id_table[31], NULL },
2003 { NULL },
2004 },
2005 { "Terratec Cinergy T Express",
2006 { &dib0700_usb_id_table[42], NULL },
2007 { NULL },
2008 }
2009 },
2010
2011 .rc.core = {
2012 .rc_interval = DEFAULT_RC_INTERVAL,
2013 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2014 .module_name = "dib0700",
2015 .rc_query = dib0700_rc_query_old_firmware,
2016 .rc_props = {
2017 .allowed_protos = IR_TYPE_RC5 |
2018 IR_TYPE_RC6 |
2019 IR_TYPE_NEC,
2020 .change_protocol = dib0700_change_protocol,
2021 },
2022 },
2023 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2024
2025 .num_adapters = 1,
2026 .adapter = {
2027 {
2028 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2029 .pid_filter_count = 32,
2030 .pid_filter = stk70x0p_pid_filter,
2031 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2032 .frontend_attach = stk7070p_frontend_attach,
2033 .tuner_attach = dib7070p_tuner_attach,
2034
2035 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2036
2037 .size_of_priv = sizeof(struct dib0700_adapter_state),
2038 },
2039 },
2040
2041 .num_device_descs = 11,
2042 .devices = {
2043 { "DiBcom STK7070P reference design",
2044 { &dib0700_usb_id_table[15], NULL },
2045 { NULL },
2046 },
2047 { "Pinnacle PCTV DVB-T Flash Stick",
2048 { &dib0700_usb_id_table[16], NULL },
2049 { NULL },
2050 },
2051 { "Artec T14BR DVB-T",
2052 { &dib0700_usb_id_table[22], NULL },
2053 { NULL },
2054 },
2055 { "ASUS My Cinema U3100 Mini DVBT Tuner",
2056 { &dib0700_usb_id_table[24], NULL },
2057 { NULL },
2058 },
2059 { "Hauppauge Nova-T Stick",
2060 { &dib0700_usb_id_table[25], NULL },
2061 { NULL },
2062 },
2063 { "Hauppauge Nova-T MyTV.t",
2064 { &dib0700_usb_id_table[26], NULL },
2065 { NULL },
2066 },
2067 { "Pinnacle PCTV 72e",
2068 { &dib0700_usb_id_table[29], NULL },
2069 { NULL },
2070 },
2071 { "Pinnacle PCTV 73e",
2072 { &dib0700_usb_id_table[30], NULL },
2073 { NULL },
2074 },
2075 { "Elgato EyeTV DTT",
2076 { &dib0700_usb_id_table[49], NULL },
2077 { NULL },
2078 },
2079 { "Yuan PD378S",
2080 { &dib0700_usb_id_table[45], NULL },
2081 { NULL },
2082 },
2083 { "Elgato EyeTV Dtt Dlx PD378S",
2084 { &dib0700_usb_id_table[50], NULL },
2085 { NULL },
2086 },
2087 },
2088
2089 .rc.core = {
2090 .rc_interval = DEFAULT_RC_INTERVAL,
2091 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2092 .module_name = "dib0700",
2093 .rc_query = dib0700_rc_query_old_firmware,
2094 .rc_props = {
2095 .allowed_protos = IR_TYPE_RC5 |
2096 IR_TYPE_RC6 |
2097 IR_TYPE_NEC,
2098 .change_protocol = dib0700_change_protocol,
2099 },
2100 },
2101 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2102
2103 .num_adapters = 1,
2104 .adapter = {
2105 {
2106 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2107 .pid_filter_count = 32,
2108 .pid_filter = stk70x0p_pid_filter,
2109 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2110 .frontend_attach = stk7070p_frontend_attach,
2111 .tuner_attach = dib7070p_tuner_attach,
2112
2113 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2114
2115 .size_of_priv = sizeof(struct dib0700_adapter_state),
2116 },
2117 },
2118
2119 .num_device_descs = 3,
2120 .devices = {
2121 { "Pinnacle PCTV 73A",
2122 { &dib0700_usb_id_table[56], NULL },
2123 { NULL },
2124 },
2125 { "Pinnacle PCTV 73e SE",
2126 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
2127 { NULL },
2128 },
2129 { "Pinnacle PCTV 282e",
2130 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
2131 { NULL },
2132 },
2133 },
2134
2135 .rc.core = {
2136 .rc_interval = DEFAULT_RC_INTERVAL,
2137 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2138 .module_name = "dib0700",
2139 .rc_query = dib0700_rc_query_old_firmware,
2140 .rc_props = {
2141 .allowed_protos = IR_TYPE_RC5 |
2142 IR_TYPE_RC6 |
2143 IR_TYPE_NEC,
2144 .change_protocol = dib0700_change_protocol,
2145 },
2146 },
2147 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2148
2149 .num_adapters = 2,
2150 .adapter = {
2151 {
2152 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2153 .pid_filter_count = 32,
2154 .pid_filter = stk70x0p_pid_filter,
2155 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2156 .frontend_attach = stk7070pd_frontend_attach0,
2157 .tuner_attach = dib7070p_tuner_attach,
2158
2159 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2160
2161 .size_of_priv = sizeof(struct dib0700_adapter_state),
2162 }, {
2163 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2164 .pid_filter_count = 32,
2165 .pid_filter = stk70x0p_pid_filter,
2166 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2167 .frontend_attach = stk7070pd_frontend_attach1,
2168 .tuner_attach = dib7070p_tuner_attach,
2169
2170 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2171
2172 .size_of_priv = sizeof(struct dib0700_adapter_state),
2173 }
2174 },
2175
2176 .num_device_descs = 6,
2177 .devices = {
2178 { "DiBcom STK7070PD reference design",
2179 { &dib0700_usb_id_table[17], NULL },
2180 { NULL },
2181 },
2182 { "Pinnacle PCTV Dual DVB-T Diversity Stick",
2183 { &dib0700_usb_id_table[18], NULL },
2184 { NULL },
2185 },
2186 { "Hauppauge Nova-TD Stick (52009)",
2187 { &dib0700_usb_id_table[35], NULL },
2188 { NULL },
2189 },
2190 { "Hauppauge Nova-TD-500 (84xxx)",
2191 { &dib0700_usb_id_table[36], NULL },
2192 { NULL },
2193 },
2194 { "Terratec Cinergy DT USB XS Diversity/ T5",
2195 { &dib0700_usb_id_table[43],
2196 &dib0700_usb_id_table[53], NULL},
2197 { NULL },
2198 },
2199 { "Sony PlayTV",
2200 { &dib0700_usb_id_table[44], NULL },
2201 { NULL },
2202 },
2203 },
2204
2205 .rc.core = {
2206 .rc_interval = DEFAULT_RC_INTERVAL,
2207 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2208 .module_name = "dib0700",
2209 .rc_query = dib0700_rc_query_old_firmware,
2210 .rc_props = {
2211 .allowed_protos = IR_TYPE_RC5 |
2212 IR_TYPE_RC6 |
2213 IR_TYPE_NEC,
2214 .change_protocol = dib0700_change_protocol,
2215 },
2216 },
2217 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2218
2219 .num_adapters = 2,
2220 .adapter = {
2221 {
2222 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2223 .pid_filter_count = 32,
2224 .pid_filter = stk70x0p_pid_filter,
2225 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2226 .frontend_attach = stk7070pd_frontend_attach0,
2227 .tuner_attach = dib7070p_tuner_attach,
2228
2229 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2230
2231 .size_of_priv = sizeof(struct dib0700_adapter_state),
2232 }, {
2233 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2234 .pid_filter_count = 32,
2235 .pid_filter = stk70x0p_pid_filter,
2236 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2237 .frontend_attach = stk7070pd_frontend_attach1,
2238 .tuner_attach = dib7070p_tuner_attach,
2239
2240 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2241
2242 .size_of_priv = sizeof(struct dib0700_adapter_state),
2243 }
2244 },
2245
2246 .num_device_descs = 1,
2247 .devices = {
2248 { "Elgato EyeTV Diversity",
2249 { &dib0700_usb_id_table[68], NULL },
2250 { NULL },
2251 },
2252 },
2253
2254 .rc.core = {
2255 .rc_interval = DEFAULT_RC_INTERVAL,
2256 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
2257 .module_name = "dib0700",
2258 .rc_query = dib0700_rc_query_old_firmware,
2259 .rc_props = {
2260 .allowed_protos = IR_TYPE_RC5 |
2261 IR_TYPE_RC6 |
2262 IR_TYPE_NEC,
2263 .change_protocol = dib0700_change_protocol,
2264 },
2265 },
2266 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2267
2268 .num_adapters = 1,
2269 .adapter = {
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 = stk7700ph_frontend_attach,
2276 .tuner_attach = stk7700ph_tuner_attach,
2277
2278 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2279
2280 .size_of_priv = sizeof(struct
2281 dib0700_adapter_state),
2282 },
2283 },
2284
2285 .num_device_descs = 9,
2286 .devices = {
2287 { "Terratec Cinergy HT USB XE",
2288 { &dib0700_usb_id_table[27], NULL },
2289 { NULL },
2290 },
2291 { "Pinnacle Expresscard 320cx",
2292 { &dib0700_usb_id_table[28], NULL },
2293 { NULL },
2294 },
2295 { "Terratec Cinergy HT Express",
2296 { &dib0700_usb_id_table[32], NULL },
2297 { NULL },
2298 },
2299 { "Gigabyte U8000-RH",
2300 { &dib0700_usb_id_table[37], NULL },
2301 { NULL },
2302 },
2303 { "YUAN High-Tech STK7700PH",
2304 { &dib0700_usb_id_table[38], NULL },
2305 { NULL },
2306 },
2307 { "Asus My Cinema-U3000Hybrid",
2308 { &dib0700_usb_id_table[39], NULL },
2309 { NULL },
2310 },
2311 { "YUAN High-Tech MC770",
2312 { &dib0700_usb_id_table[48], NULL },
2313 { NULL },
2314 },
2315 { "Leadtek WinFast DTV Dongle H",
2316 { &dib0700_usb_id_table[51], NULL },
2317 { NULL },
2318 },
2319 { "YUAN High-Tech STK7700D",
2320 { &dib0700_usb_id_table[54], NULL },
2321 { NULL },
2322 },
2323 },
2324
2325 .rc.core = {
2326 .rc_interval = DEFAULT_RC_INTERVAL,
2327 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2328 .module_name = "dib0700",
2329 .rc_query = dib0700_rc_query_old_firmware,
2330 .rc_props = {
2331 .allowed_protos = IR_TYPE_RC5 |
2332 IR_TYPE_RC6 |
2333 IR_TYPE_NEC,
2334 .change_protocol = dib0700_change_protocol,
2335 },
2336 },
2337 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2338 .num_adapters = 1,
2339 .adapter = {
2340 {
2341 .frontend_attach = s5h1411_frontend_attach,
2342 .tuner_attach = xc5000_tuner_attach,
2343
2344 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2345
2346 .size_of_priv = sizeof(struct
2347 dib0700_adapter_state),
2348 },
2349 },
2350
2351 .num_device_descs = 2,
2352 .devices = {
2353 { "Pinnacle PCTV HD Pro USB Stick",
2354 { &dib0700_usb_id_table[40], NULL },
2355 { NULL },
2356 },
2357 { "Pinnacle PCTV HD USB Stick",
2358 { &dib0700_usb_id_table[41], NULL },
2359 { NULL },
2360 },
2361 },
2362
2363 .rc.core = {
2364 .rc_interval = DEFAULT_RC_INTERVAL,
2365 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2366 .module_name = "dib0700",
2367 .rc_query = dib0700_rc_query_old_firmware,
2368 .rc_props = {
2369 .allowed_protos = IR_TYPE_RC5 |
2370 IR_TYPE_RC6 |
2371 IR_TYPE_NEC,
2372 .change_protocol = dib0700_change_protocol,
2373 },
2374 },
2375 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2376 .num_adapters = 1,
2377 .adapter = {
2378 {
2379 .frontend_attach = lgdt3305_frontend_attach,
2380 .tuner_attach = mxl5007t_tuner_attach,
2381
2382 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2383
2384 .size_of_priv = sizeof(struct
2385 dib0700_adapter_state),
2386 },
2387 },
2388
2389 .num_device_descs = 2,
2390 .devices = {
2391 { "Hauppauge ATSC MiniCard (B200)",
2392 { &dib0700_usb_id_table[46], NULL },
2393 { NULL },
2394 },
2395 { "Hauppauge ATSC MiniCard (B210)",
2396 { &dib0700_usb_id_table[47], NULL },
2397 { NULL },
2398 },
2399 },
2400 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2401
2402 .num_adapters = 1,
2403 .adapter = {
2404 {
2405 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2406 .pid_filter_count = 32,
2407 .pid_filter = stk70x0p_pid_filter,
2408 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
2409 .frontend_attach = stk7070p_frontend_attach,
2410 .tuner_attach = dib7770p_tuner_attach,
2411
2412 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2413
2414 .size_of_priv =
2415 sizeof(struct dib0700_adapter_state),
2416 },
2417 },
2418
2419 .num_device_descs = 2,
2420 .devices = {
2421 { "DiBcom STK7770P reference design",
2422 { &dib0700_usb_id_table[59], NULL },
2423 { NULL },
2424 },
2425 { "Terratec Cinergy T USB XXS (HD)/ T3",
2426 { &dib0700_usb_id_table[33],
2427 &dib0700_usb_id_table[52],
2428 &dib0700_usb_id_table[60], NULL},
2429 { NULL },
2430 },
2431 },
2432
2433 .rc.core = {
2434 .rc_interval = DEFAULT_RC_INTERVAL,
2435 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2436 .module_name = "dib0700",
2437 .rc_query = dib0700_rc_query_old_firmware,
2438 .rc_props = {
2439 .allowed_protos = IR_TYPE_RC5 |
2440 IR_TYPE_RC6 |
2441 IR_TYPE_NEC,
2442 .change_protocol = dib0700_change_protocol,
2443 },
2444 },
2445 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2446 .num_adapters = 1,
2447 .adapter = {
2448 {
2449 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2450 .pid_filter_count = 32,
2451 .pid_filter = stk80xx_pid_filter,
2452 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2453 .frontend_attach = stk807x_frontend_attach,
2454 .tuner_attach = dib807x_tuner_attach,
2455
2456 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2457
2458 .size_of_priv =
2459 sizeof(struct dib0700_adapter_state),
2460 },
2461 },
2462
2463 .num_device_descs = 3,
2464 .devices = {
2465 { "DiBcom STK807xP reference design",
2466 { &dib0700_usb_id_table[62], NULL },
2467 { NULL },
2468 },
2469 { "Prolink Pixelview SBTVD",
2470 { &dib0700_usb_id_table[63], NULL },
2471 { NULL },
2472 },
2473 { "EvolutePC TVWay+",
2474 { &dib0700_usb_id_table[64], NULL },
2475 { NULL },
2476 },
2477 },
2478
2479 .rc.core = {
2480 .rc_interval = DEFAULT_RC_INTERVAL,
2481 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
2482 .module_name = "dib0700",
2483 .rc_query = dib0700_rc_query_old_firmware,
2484 .rc_props = {
2485 .allowed_protos = IR_TYPE_RC5 |
2486 IR_TYPE_RC6 |
2487 IR_TYPE_NEC,
2488 .change_protocol = dib0700_change_protocol,
2489 },
2490 },
2491 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2492 .num_adapters = 2,
2493 .adapter = {
2494 {
2495 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2496 .pid_filter_count = 32,
2497 .pid_filter = stk80xx_pid_filter,
2498 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2499 .frontend_attach = stk807xpvr_frontend_attach0,
2500 .tuner_attach = dib807x_tuner_attach,
2501
2502 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2503
2504 .size_of_priv =
2505 sizeof(struct dib0700_adapter_state),
2506 },
2507 {
2508 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2509 .pid_filter_count = 32,
2510 .pid_filter = stk80xx_pid_filter,
2511 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2512 .frontend_attach = stk807xpvr_frontend_attach1,
2513 .tuner_attach = dib807x_tuner_attach,
2514
2515 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2516
2517 .size_of_priv =
2518 sizeof(struct dib0700_adapter_state),
2519 },
2520 },
2521
2522 .num_device_descs = 1,
2523 .devices = {
2524 { "DiBcom STK807xPVR reference design",
2525 { &dib0700_usb_id_table[61], NULL },
2526 { NULL },
2527 },
2528 },
2529
2530 .rc.core = {
2531 .rc_interval = DEFAULT_RC_INTERVAL,
2532 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2533 .module_name = "dib0700",
2534 .rc_query = dib0700_rc_query_old_firmware,
2535 .rc_props = {
2536 .allowed_protos = IR_TYPE_RC5 |
2537 IR_TYPE_RC6 |
2538 IR_TYPE_NEC,
2539 .change_protocol = dib0700_change_protocol,
2540 },
2541 },
2542 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2543 .num_adapters = 1,
2544 .adapter = {
2545 {
2546 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
2547 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
2548 .pid_filter_count = 32,
2549 .pid_filter = stk80xx_pid_filter,
2550 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
2551 .frontend_attach = stk809x_frontend_attach,
2552 .tuner_attach = dib809x_tuner_attach,
2553
2554 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2555
2556 .size_of_priv =
2557 sizeof(struct dib0700_adapter_state),
2558 },
2559 },
2560
2561 .num_device_descs = 1,
2562 .devices = {
2563 { "DiBcom STK8096GP reference design",
2564 { &dib0700_usb_id_table[67], NULL },
2565 { NULL },
2566 },
2567 },
2568
2569 .rc.core = {
2570 .rc_interval = DEFAULT_RC_INTERVAL,
2571 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
2572 .module_name = "dib0700",
2573 .rc_query = dib0700_rc_query_old_firmware,
2574 .rc_props = {
2575 .allowed_protos = IR_TYPE_RC5 |
2576 IR_TYPE_RC6 |
2577 IR_TYPE_NEC,
2578 .change_protocol = dib0700_change_protocol,
2579 },
2580 },
2581 },
2582 };
2583
2584 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
Linus' kernel tree