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