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