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