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