?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.32.60
[linux-2.6.32.60-moxart.git] / drivers / media / dvb / dvb-usb / dib0700_devices.c
blob524acf51155018fca37b2c70e224e83861db7c3e
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 u8 system_msb;
562 u8 system_lsb;
563 u8 data;
564 u8 not_data;
565 };
566
567 /* This supports the new IR response format for firmware v1.20 */
568 static int dib0700_rc_query_v1_20(struct dvb_usb_device *d, u32 *event,
569 int *state)
570 {
571 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
572 struct dib0700_state *st = d->priv;
573 struct dib0700_rc_response poll_reply;
574 u8 buf[6];
575 int i;
576 int status;
577 int actlen;
578 int found = 0;
579
580 /* Set initial results in case we exit the function early */
581 *event = 0;
582 *state = REMOTE_NO_KEY_PRESSED;
583
584 /* Firmware v1.20 provides RC data via bulk endpoint 1 */
585 status = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev, 1), buf,
586 sizeof(buf), &actlen, 50);
587 if (status < 0) {
588 /* No data available (meaning no key press) */
589 return 0;
590 }
591
592 if (actlen != sizeof(buf)) {
593 /* We didn't get back the 6 byte message we expected */
594 err("Unexpected RC response size [%d]", actlen);
595 return -1;
596 }
597
598 poll_reply.report_id = buf[0];
599 poll_reply.data_state = buf[1];
600 poll_reply.system_msb = buf[2];
601 poll_reply.system_lsb = buf[3];
602 poll_reply.data = buf[4];
603 poll_reply.not_data = buf[5];
604
605 /*
606 info("rid=%02x ds=%02x sm=%02x sl=%02x d=%02x nd=%02x\n",
607 poll_reply.report_id, poll_reply.data_state,
608 poll_reply.system_msb, poll_reply.system_lsb,
609 poll_reply.data, poll_reply.not_data);
610 */
611
612 if ((poll_reply.data + poll_reply.not_data) != 0xff) {
613 /* Key failed integrity check */
614 err("key failed integrity check: %02x %02x %02x %02x",
615 poll_reply.system_msb, poll_reply.system_lsb,
616 poll_reply.data, poll_reply.not_data);
617 return -1;
618 }
619
620 /* Find the key in the map */
621 for (i = 0; i < d->props.rc_key_map_size; i++) {
622 if (rc5_custom(&keymap[i]) == poll_reply.system_lsb &&
623 rc5_data(&keymap[i]) == poll_reply.data) {
624 *event = keymap[i].event;
625 found = 1;
626 break;
627 }
628 }
629
630 if (found == 0) {
631 err("Unknown remote controller key: %02x %02x %02x %02x",
632 poll_reply.system_msb, poll_reply.system_lsb,
633 poll_reply.data, poll_reply.not_data);
634 d->last_event = 0;
635 return 0;
636 }
637
638 if (poll_reply.data_state == 1) {
639 /* New key hit */
640 st->rc_counter = 0;
641 *event = keymap[i].event;
642 *state = REMOTE_KEY_PRESSED;
643 d->last_event = keymap[i].event;
644 } else if (poll_reply.data_state == 2) {
645 /* Key repeated */
646 st->rc_counter++;
647
648 /* prevents unwanted double hits */
649 if (st->rc_counter > RC_REPEAT_DELAY_V1_20) {
650 *event = d->last_event;
651 *state = REMOTE_KEY_PRESSED;
652 st->rc_counter = RC_REPEAT_DELAY_V1_20;
653 }
654 } else {
655 err("Unknown data state [%d]", poll_reply.data_state);
656 }
657
658 return 0;
659 }
660
661 static int dib0700_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
662 {
663 struct dib0700_state *st = d->priv;
664
665 /* Because some people may have improperly named firmware files,
666 let's figure out whether to use the new firmware call or the legacy
667 call based on the firmware version embedded in the file */
668 if (st->rc_func_version == 0) {
669 u32 hwver, romver, ramver, fwtype;
670 int ret = dib0700_get_version(d, &hwver, &romver, &ramver,
671 &fwtype);
672 if (ret < 0) {
673 err("Could not determine version info");
674 return -1;
675 }
676 if (ramver < 0x10200)
677 st->rc_func_version = 1;
678 else
679 st->rc_func_version = 2;
680 }
681
682 if (st->rc_func_version == 2)
683 return dib0700_rc_query_v1_20(d, event, state);
684 else
685 return dib0700_rc_query_legacy(d, event, state);
686 }
687
688 static struct dvb_usb_rc_key dib0700_rc_keys[] = {
689 /* Key codes for the tiny Pinnacle remote*/
690 { 0x0700, KEY_MUTE },
691 { 0x0701, KEY_MENU }, /* Pinnacle logo */
692 { 0x0739, KEY_POWER },
693 { 0x0703, KEY_VOLUMEUP },
694 { 0x0709, KEY_VOLUMEDOWN },
695 { 0x0706, KEY_CHANNELUP },
696 { 0x070c, KEY_CHANNELDOWN },
697 { 0x070f, KEY_1 },
698 { 0x0715, KEY_2 },
699 { 0x0710, KEY_3 },
700 { 0x0718, KEY_4 },
701 { 0x071b, KEY_5 },
702 { 0x071e, KEY_6 },
703 { 0x0711, KEY_7 },
704 { 0x0721, KEY_8 },
705 { 0x0712, KEY_9 },
706 { 0x0727, KEY_0 },
707 { 0x0724, KEY_SCREEN }, /* 'Square' key */
708 { 0x072a, KEY_TEXT }, /* 'T' key */
709 { 0x072d, KEY_REWIND },
710 { 0x0730, KEY_PLAY },
711 { 0x0733, KEY_FASTFORWARD },
712 { 0x0736, KEY_RECORD },
713 { 0x073c, KEY_STOP },
714 { 0x073f, KEY_CANCEL }, /* '?' key */
715 /* Key codes for the Terratec Cinergy DT XS Diversity, similar to cinergyT2.c */
716 { 0xeb01, KEY_POWER },
717 { 0xeb02, KEY_1 },
718 { 0xeb03, KEY_2 },
719 { 0xeb04, KEY_3 },
720 { 0xeb05, KEY_4 },
721 { 0xeb06, KEY_5 },
722 { 0xeb07, KEY_6 },
723 { 0xeb08, KEY_7 },
724 { 0xeb09, KEY_8 },
725 { 0xeb0a, KEY_9 },
726 { 0xeb0b, KEY_VIDEO },
727 { 0xeb0c, KEY_0 },
728 { 0xeb0d, KEY_REFRESH },
729 { 0xeb0f, KEY_EPG },
730 { 0xeb10, KEY_UP },
731 { 0xeb11, KEY_LEFT },
732 { 0xeb12, KEY_OK },
733 { 0xeb13, KEY_RIGHT },
734 { 0xeb14, KEY_DOWN },
735 { 0xeb16, KEY_INFO },
736 { 0xeb17, KEY_RED },
737 { 0xeb18, KEY_GREEN },
738 { 0xeb19, KEY_YELLOW },
739 { 0xeb1a, KEY_BLUE },
740 { 0xeb1b, KEY_CHANNELUP },
741 { 0xeb1c, KEY_VOLUMEUP },
742 { 0xeb1d, KEY_MUTE },
743 { 0xeb1e, KEY_VOLUMEDOWN },
744 { 0xeb1f, KEY_CHANNELDOWN },
745 { 0xeb40, KEY_PAUSE },
746 { 0xeb41, KEY_HOME },
747 { 0xeb42, KEY_MENU }, /* DVD Menu */
748 { 0xeb43, KEY_SUBTITLE },
749 { 0xeb44, KEY_TEXT }, /* Teletext */
750 { 0xeb45, KEY_DELETE },
751 { 0xeb46, KEY_TV },
752 { 0xeb47, KEY_DVD },
753 { 0xeb48, KEY_STOP },
754 { 0xeb49, KEY_VIDEO },
755 { 0xeb4a, KEY_AUDIO }, /* Music */
756 { 0xeb4b, KEY_SCREEN }, /* Pic */
757 { 0xeb4c, KEY_PLAY },
758 { 0xeb4d, KEY_BACK },
759 { 0xeb4e, KEY_REWIND },
760 { 0xeb4f, KEY_FASTFORWARD },
761 { 0xeb54, KEY_PREVIOUS },
762 { 0xeb58, KEY_RECORD },
763 { 0xeb5c, KEY_NEXT },
764
765 /* Key codes for the Haupauge WinTV Nova-TD, copied from nova-t-usb2.c (Nova-T USB2) */
766 { 0x1e00, KEY_0 },
767 { 0x1e01, KEY_1 },
768 { 0x1e02, KEY_2 },
769 { 0x1e03, KEY_3 },
770 { 0x1e04, KEY_4 },
771 { 0x1e05, KEY_5 },
772 { 0x1e06, KEY_6 },
773 { 0x1e07, KEY_7 },
774 { 0x1e08, KEY_8 },
775 { 0x1e09, KEY_9 },
776 { 0x1e0a, KEY_KPASTERISK },
777 { 0x1e0b, KEY_RED },
778 { 0x1e0c, KEY_RADIO },
779 { 0x1e0d, KEY_MENU },
780 { 0x1e0e, KEY_GRAVE }, /* # */
781 { 0x1e0f, KEY_MUTE },
782 { 0x1e10, KEY_VOLUMEUP },
783 { 0x1e11, KEY_VOLUMEDOWN },
784 { 0x1e12, KEY_CHANNEL },
785 { 0x1e14, KEY_UP },
786 { 0x1e15, KEY_DOWN },
787 { 0x1e16, KEY_LEFT },
788 { 0x1e17, KEY_RIGHT },
789 { 0x1e18, KEY_VIDEO },
790 { 0x1e19, KEY_AUDIO },
791 { 0x1e1a, KEY_MEDIA },
792 { 0x1e1b, KEY_EPG },
793 { 0x1e1c, KEY_TV },
794 { 0x1e1e, KEY_NEXT },
795 { 0x1e1f, KEY_BACK },
796 { 0x1e20, KEY_CHANNELUP },
797 { 0x1e21, KEY_CHANNELDOWN },
798 { 0x1e24, KEY_LAST }, /* Skip backwards */
799 { 0x1e25, KEY_OK },
800 { 0x1e29, KEY_BLUE},
801 { 0x1e2e, KEY_GREEN },
802 { 0x1e30, KEY_PAUSE },
803 { 0x1e32, KEY_REWIND },
804 { 0x1e34, KEY_FASTFORWARD },
805 { 0x1e35, KEY_PLAY },
806 { 0x1e36, KEY_STOP },
807 { 0x1e37, KEY_RECORD },
808 { 0x1e38, KEY_YELLOW },
809 { 0x1e3b, KEY_GOTO },
810 { 0x1e3d, KEY_POWER },
811
812 /* Key codes for the Leadtek Winfast DTV Dongle */
813 { 0x0042, KEY_POWER },
814 { 0x077c, KEY_TUNER },
815 { 0x0f4e, KEY_PRINT }, /* PREVIEW */
816 { 0x0840, KEY_SCREEN }, /* full screen toggle*/
817 { 0x0f71, KEY_DOT }, /* frequency */
818 { 0x0743, KEY_0 },
819 { 0x0c41, KEY_1 },
820 { 0x0443, KEY_2 },
821 { 0x0b7f, KEY_3 },
822 { 0x0e41, KEY_4 },
823 { 0x0643, KEY_5 },
824 { 0x097f, KEY_6 },
825 { 0x0d7e, KEY_7 },
826 { 0x057c, KEY_8 },
827 { 0x0a40, KEY_9 },
828 { 0x0e4e, KEY_CLEAR },
829 { 0x047c, KEY_CHANNEL }, /* show channel number */
830 { 0x0f41, KEY_LAST }, /* recall */
831 { 0x0342, KEY_MUTE },
832 { 0x064c, KEY_RESERVED }, /* PIP button*/
833 { 0x0172, KEY_SHUFFLE }, /* SNAPSHOT */
834 { 0x0c4e, KEY_PLAYPAUSE }, /* TIMESHIFT */
835 { 0x0b70, KEY_RECORD },
836 { 0x037d, KEY_VOLUMEUP },
837 { 0x017d, KEY_VOLUMEDOWN },
838 { 0x0242, KEY_CHANNELUP },
839 { 0x007d, KEY_CHANNELDOWN },
840
841 /* Key codes for Nova-TD "credit card" remote control. */
842 { 0x1d00, KEY_0 },
843 { 0x1d01, KEY_1 },
844 { 0x1d02, KEY_2 },
845 { 0x1d03, KEY_3 },
846 { 0x1d04, KEY_4 },
847 { 0x1d05, KEY_5 },
848 { 0x1d06, KEY_6 },
849 { 0x1d07, KEY_7 },
850 { 0x1d08, KEY_8 },
851 { 0x1d09, KEY_9 },
852 { 0x1d0a, KEY_TEXT },
853 { 0x1d0d, KEY_MENU },
854 { 0x1d0f, KEY_MUTE },
855 { 0x1d10, KEY_VOLUMEUP },
856 { 0x1d11, KEY_VOLUMEDOWN },
857 { 0x1d12, KEY_CHANNEL },
858 { 0x1d14, KEY_UP },
859 { 0x1d15, KEY_DOWN },
860 { 0x1d16, KEY_LEFT },
861 { 0x1d17, KEY_RIGHT },
862 { 0x1d1c, KEY_TV },
863 { 0x1d1e, KEY_NEXT },
864 { 0x1d1f, KEY_BACK },
865 { 0x1d20, KEY_CHANNELUP },
866 { 0x1d21, KEY_CHANNELDOWN },
867 { 0x1d24, KEY_LAST },
868 { 0x1d25, KEY_OK },
869 { 0x1d30, KEY_PAUSE },
870 { 0x1d32, KEY_REWIND },
871 { 0x1d34, KEY_FASTFORWARD },
872 { 0x1d35, KEY_PLAY },
873 { 0x1d36, KEY_STOP },
874 { 0x1d37, KEY_RECORD },
875 { 0x1d3b, KEY_GOTO },
876 { 0x1d3d, KEY_POWER },
877
878 /* Key codes for the Elgato EyeTV Diversity silver remote,
879 set dvb_usb_dib0700_ir_proto=0 */
880 { 0x4501, KEY_POWER },
881 { 0x4502, KEY_MUTE },
882 { 0x4503, KEY_1 },
883 { 0x4504, KEY_2 },
884 { 0x4505, KEY_3 },
885 { 0x4506, KEY_4 },
886 { 0x4507, KEY_5 },
887 { 0x4508, KEY_6 },
888 { 0x4509, KEY_7 },
889 { 0x450a, KEY_8 },
890 { 0x450b, KEY_9 },
891 { 0x450c, KEY_LAST },
892 { 0x450d, KEY_0 },
893 { 0x450e, KEY_ENTER },
894 { 0x450f, KEY_RED },
895 { 0x4510, KEY_CHANNELUP },
896 { 0x4511, KEY_GREEN },
897 { 0x4512, KEY_VOLUMEDOWN },
898 { 0x4513, KEY_OK },
899 { 0x4514, KEY_VOLUMEUP },
900 { 0x4515, KEY_YELLOW },
901 { 0x4516, KEY_CHANNELDOWN },
902 { 0x4517, KEY_BLUE },
903 { 0x4518, KEY_LEFT }, /* Skip backwards */
904 { 0x4519, KEY_PLAYPAUSE },
905 { 0x451a, KEY_RIGHT }, /* Skip forward */
906 { 0x451b, KEY_REWIND },
907 { 0x451c, KEY_L }, /* Live */
908 { 0x451d, KEY_FASTFORWARD },
909 { 0x451e, KEY_STOP }, /* 'Reveal' for Teletext */
910 { 0x451f, KEY_MENU }, /* KEY_TEXT for Teletext */
911 { 0x4540, KEY_RECORD }, /* Font 'Size' for Teletext */
912 { 0x4541, KEY_SCREEN }, /* Full screen toggle, 'Hold' for Teletext */
913 { 0x4542, KEY_SELECT }, /* Select video input, 'Select' for Teletext */
914 };
915
916 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
917 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
918 BAND_UHF | BAND_VHF, // band_caps
919
920 /* 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,
921 * 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 */
922 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
923
924 712, // inv_gain
925 41, // time_stabiliz
926
927 0, // alpha_level
928 118, // thlock
929
930 0, // wbd_inv
931 4095, // wbd_ref
932 0, // wbd_sel
933 0, // wbd_alpha
934
935 42598, // agc1_max
936 17694, // agc1_min
937 45875, // agc2_max
938 2621, // agc2_min
939 0, // agc1_pt1
940 76, // agc1_pt2
941 139, // agc1_pt3
942 52, // agc1_slope1
943 59, // agc1_slope2
944 107, // agc2_pt1
945 172, // agc2_pt2
946 57, // agc2_slope1
947 70, // agc2_slope2
948
949 21, // alpha_mant
950 25, // alpha_exp
951 28, // beta_mant
952 48, // beta_exp
953
954 1, // perform_agc_softsplit
955 { 0, // split_min
956 107, // split_max
957 51800, // global_split_min
958 24700 // global_split_max
959 },
960 };
961
962 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
963 BAND_UHF | BAND_VHF,
964
965 /* 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,
966 * 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 */
967 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
968
969 712, // inv_gain
970 41, // time_stabiliz
971
972 0, // alpha_level
973 118, // thlock
974
975 0, // wbd_inv
976 4095, // wbd_ref
977 0, // wbd_sel
978 0, // wbd_alpha
979
980 42598, // agc1_max
981 16384, // agc1_min
982 42598, // agc2_max
983 0, // agc2_min
984
985 0, // agc1_pt1
986 137, // agc1_pt2
987 255, // agc1_pt3
988
989 0, // agc1_slope1
990 255, // agc1_slope2
991
992 0, // agc2_pt1
993 0, // agc2_pt2
994
995 0, // agc2_slope1
996 41, // agc2_slope2
997
998 15, // alpha_mant
999 25, // alpha_exp
1000
1001 28, // beta_mant
1002 48, // beta_exp
1003
1004 0, // perform_agc_softsplit
1005 };
1006
1007 static struct dibx000_bandwidth_config stk7700p_pll_config = {
1008 60000, 30000, // internal, sampling
1009 1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
1010 0, 0, 1, 1, 0, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
1011 (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
1012 60258167, // ifreq
1013 20452225, // timf
1014 30000000, // xtal
1015 };
1016
1017 static struct dib7000m_config stk7700p_dib7000m_config = {
1018 .dvbt_mode = 1,
1019 .output_mpeg2_in_188_bytes = 1,
1020 .quartz_direct = 1,
1021
1022 .agc_config_count = 1,
1023 .agc = &stk7700p_7000m_mt2060_agc_config,
1024 .bw = &stk7700p_pll_config,
1025
1026 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
1027 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
1028 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
1029 };
1030
1031 static struct dib7000p_config stk7700p_dib7000p_config = {
1032 .output_mpeg2_in_188_bytes = 1,
1033
1034 .agc_config_count = 1,
1035 .agc = &stk7700p_7000p_mt2060_agc_config,
1036 .bw = &stk7700p_pll_config,
1037
1038 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
1039 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
1040 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
1041 };
1042
1043 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
1044 {
1045 struct dib0700_state *st = adap->dev->priv;
1046 /* unless there is no real power management in DVB - we leave the device on GPIO6 */
1047
1048 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1049 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(50);
1050
1051 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
1052 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1053
1054 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
1055 dib0700_ctrl_clock(adap->dev, 72, 1);
1056 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
1057
1058 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1059
1060 st->mt2060_if1[0] = 1220;
1061
1062 if (dib7000pc_detection(&adap->dev->i2c_adap)) {
1063 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
1064 st->is_dib7000pc = 1;
1065 } else
1066 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
1067
1068 return adap->fe == NULL ? -ENODEV : 0;
1069 }
1070
1071 static struct mt2060_config stk7700p_mt2060_config = {
1072 0x60
1073 };
1074
1075 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
1076 {
1077 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
1078 struct dib0700_state *st = adap->dev->priv;
1079 struct i2c_adapter *tun_i2c;
1080 s8 a;
1081 int if1=1220;
1082 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
1083 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
1084 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
1085 }
1086 if (st->is_dib7000pc)
1087 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1088 else
1089 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1090
1091 return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
1092 if1) == NULL ? -ENODEV : 0;
1093 }
1094
1095 /* DIB7070 generic */
1096 static struct dibx000_agc_config dib7070_agc_config = {
1097 BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1098 /* 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,
1099 * 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 */
1100 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
1101
1102 600, // inv_gain
1103 10, // time_stabiliz
1104
1105 0, // alpha_level
1106 118, // thlock
1107
1108 0, // wbd_inv
1109 3530, // wbd_ref
1110 1, // wbd_sel
1111 5, // wbd_alpha
1112
1113 65535, // agc1_max
1114 0, // agc1_min
1115
1116 65535, // agc2_max
1117 0, // agc2_min
1118
1119 0, // agc1_pt1
1120 40, // agc1_pt2
1121 183, // agc1_pt3
1122 206, // agc1_slope1
1123 255, // agc1_slope2
1124 72, // agc2_pt1
1125 152, // agc2_pt2
1126 88, // agc2_slope1
1127 90, // agc2_slope2
1128
1129 17, // alpha_mant
1130 27, // alpha_exp
1131 23, // beta_mant
1132 51, // beta_exp
1133
1134 0, // perform_agc_softsplit
1135 };
1136
1137 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1138 {
1139 deb_info("reset: %d", onoff);
1140 return dib7000p_set_gpio(fe, 8, 0, !onoff);
1141 }
1142
1143 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1144 {
1145 deb_info("sleep: %d", onoff);
1146 return dib7000p_set_gpio(fe, 9, 0, onoff);
1147 }
1148
1149 static struct dib0070_config dib7070p_dib0070_config[2] = {
1150 {
1151 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1152 .reset = dib7070_tuner_reset,
1153 .sleep = dib7070_tuner_sleep,
1154 .clock_khz = 12000,
1155 .clock_pad_drive = 4,
1156 .charge_pump = 2,
1157 }, {
1158 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1159 .reset = dib7070_tuner_reset,
1160 .sleep = dib7070_tuner_sleep,
1161 .clock_khz = 12000,
1162 .charge_pump = 2,
1163 }
1164 };
1165
1166 static struct dib0070_config dib7770p_dib0070_config = {
1167 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1168 .reset = dib7070_tuner_reset,
1169 .sleep = dib7070_tuner_sleep,
1170 .clock_khz = 12000,
1171 .clock_pad_drive = 0,
1172 .flip_chip = 1,
1173 };
1174
1175 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
1176 {
1177 struct dvb_usb_adapter *adap = fe->dvb->priv;
1178 struct dib0700_adapter_state *state = adap->priv;
1179
1180 u16 offset;
1181 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1182 switch (band) {
1183 case BAND_VHF: offset = 950; break;
1184 case BAND_UHF:
1185 default: offset = 550; break;
1186 }
1187 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
1188 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1189 return state->set_param_save(fe, fep);
1190 }
1191
1192 static int dib7770_set_param_override(struct dvb_frontend *fe,
1193 struct dvb_frontend_parameters *fep)
1194 {
1195 struct dvb_usb_adapter *adap = fe->dvb->priv;
1196 struct dib0700_adapter_state *state = adap->priv;
1197
1198 u16 offset;
1199 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1200 switch (band) {
1201 case BAND_VHF:
1202 dib7000p_set_gpio(fe, 0, 0, 1);
1203 offset = 850;
1204 break;
1205 case BAND_UHF:
1206 default:
1207 dib7000p_set_gpio(fe, 0, 0, 0);
1208 offset = 250;
1209 break;
1210 }
1211 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
1212 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1213 return state->set_param_save(fe, fep);
1214 }
1215
1216 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
1217 {
1218 struct dib0700_adapter_state *st = adap->priv;
1219 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
1220 DIBX000_I2C_INTERFACE_TUNER, 1);
1221
1222 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1223 &dib7770p_dib0070_config) == NULL)
1224 return -ENODEV;
1225
1226 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1227 adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
1228 return 0;
1229 }
1230
1231 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
1232 {
1233 struct dib0700_adapter_state *st = adap->priv;
1234 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1235
1236 if (adap->id == 0) {
1237 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
1238 return -ENODEV;
1239 } else {
1240 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
1241 return -ENODEV;
1242 }
1243
1244 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1245 adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1246 return 0;
1247 }
1248
1249 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1250 60000, 15000, // internal, sampling
1251 1, 20, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
1252 0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
1253 (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
1254 (0 << 25) | 0, // ifreq = 0.000000 MHz
1255 20452225, // timf
1256 12000000, // xtal_hz
1257 };
1258
1259 static struct dib7000p_config dib7070p_dib7000p_config = {
1260 .output_mpeg2_in_188_bytes = 1,
1261
1262 .agc_config_count = 1,
1263 .agc = &dib7070_agc_config,
1264 .bw = &dib7070_bw_config_12_mhz,
1265 .tuner_is_baseband = 1,
1266 .spur_protect = 1,
1267
1268 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1269 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1270 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1271
1272 .hostbus_diversity = 1,
1273 };
1274
1275 /* STK7070P */
1276 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
1277 {
1278 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
1279 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
1280 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
1281 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1282 else
1283 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1284 msleep(10);
1285 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1286 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1287 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1288 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1289
1290 dib0700_ctrl_clock(adap->dev, 72, 1);
1291
1292 msleep(10);
1293 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1294 msleep(10);
1295 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1296
1297 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1298 &dib7070p_dib7000p_config) != 0) {
1299 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
1300 __func__);
1301 return -ENODEV;
1302 }
1303
1304 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1305 &dib7070p_dib7000p_config);
1306 return adap->fe == NULL ? -ENODEV : 0;
1307 }
1308
1309 /* DIB807x generic */
1310 static struct dibx000_agc_config dib807x_agc_config[2] = {
1311 {
1312 BAND_VHF,
1313 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1314 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1315 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1316 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1317 * P_agc_write=0 */
1318 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1319 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1320 (0 << 0), /* setup*/
1321
1322 600, /* inv_gain*/
1323 10, /* time_stabiliz*/
1324
1325 0, /* alpha_level*/
1326 118, /* thlock*/
1327
1328 0, /* wbd_inv*/
1329 3530, /* wbd_ref*/
1330 1, /* wbd_sel*/
1331 5, /* wbd_alpha*/
1332
1333 65535, /* agc1_max*/
1334 0, /* agc1_min*/
1335
1336 65535, /* agc2_max*/
1337 0, /* agc2_min*/
1338
1339 0, /* agc1_pt1*/
1340 40, /* agc1_pt2*/
1341 183, /* agc1_pt3*/
1342 206, /* agc1_slope1*/
1343 255, /* agc1_slope2*/
1344 72, /* agc2_pt1*/
1345 152, /* agc2_pt2*/
1346 88, /* agc2_slope1*/
1347 90, /* agc2_slope2*/
1348
1349 17, /* alpha_mant*/
1350 27, /* alpha_exp*/
1351 23, /* beta_mant*/
1352 51, /* beta_exp*/
1353
1354 0, /* perform_agc_softsplit*/
1355 }, {
1356 BAND_UHF,
1357 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1358 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1359 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1360 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1361 * P_agc_write=0 */
1362 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1363 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1364 (0 << 0), /* setup */
1365
1366 600, /* inv_gain*/
1367 10, /* time_stabiliz*/
1368
1369 0, /* alpha_level*/
1370 118, /* thlock*/
1371
1372 0, /* wbd_inv*/
1373 3530, /* wbd_ref*/
1374 1, /* wbd_sel*/
1375 5, /* wbd_alpha*/
1376
1377 65535, /* agc1_max*/
1378 0, /* agc1_min*/
1379
1380 65535, /* agc2_max*/
1381 0, /* agc2_min*/
1382
1383 0, /* agc1_pt1*/
1384 40, /* agc1_pt2*/
1385 183, /* agc1_pt3*/
1386 206, /* agc1_slope1*/
1387 255, /* agc1_slope2*/
1388 72, /* agc2_pt1*/
1389 152, /* agc2_pt2*/
1390 88, /* agc2_slope1*/
1391 90, /* agc2_slope2*/
1392
1393 17, /* alpha_mant*/
1394 27, /* alpha_exp*/
1395 23, /* beta_mant*/
1396 51, /* beta_exp*/
1397
1398 0, /* perform_agc_softsplit*/
1399 }
1400 };
1401
1402 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1403 60000, 15000, /* internal, sampling*/
1404 1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1405 0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1406 ADClkSrc, modulo */
1407 (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1408 (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1409 18179755, /* timf*/
1410 12000000, /* xtal_hz*/
1411 };
1412
1413 static struct dib8000_config dib807x_dib8000_config[2] = {
1414 {
1415 .output_mpeg2_in_188_bytes = 1,
1416
1417 .agc_config_count = 2,
1418 .agc = dib807x_agc_config,
1419 .pll = &dib807x_bw_config_12_mhz,
1420 .tuner_is_baseband = 1,
1421
1422 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1423 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1424 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1425
1426 .hostbus_diversity = 1,
1427 .div_cfg = 1,
1428 .agc_control = &dib0070_ctrl_agc_filter,
1429 .output_mode = OUTMODE_MPEG2_FIFO,
1430 .drives = 0x2d98,
1431 }, {
1432 .output_mpeg2_in_188_bytes = 1,
1433
1434 .agc_config_count = 2,
1435 .agc = dib807x_agc_config,
1436 .pll = &dib807x_bw_config_12_mhz,
1437 .tuner_is_baseband = 1,
1438
1439 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1440 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1441 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1442
1443 .hostbus_diversity = 1,
1444 .agc_control = &dib0070_ctrl_agc_filter,
1445 .output_mode = OUTMODE_MPEG2_FIFO,
1446 .drives = 0x2d98,
1447 }
1448 };
1449
1450 static int dib807x_tuner_reset(struct dvb_frontend *fe, int onoff)
1451 {
1452 return dib8000_set_gpio(fe, 5, 0, !onoff);
1453 }
1454
1455 static int dib807x_tuner_sleep(struct dvb_frontend *fe, int onoff)
1456 {
1457 return dib8000_set_gpio(fe, 0, 0, onoff);
1458 }
1459
1460 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1461 { 240, 7},
1462 { 0xffff, 6},
1463 };
1464
1465 static struct dib0070_config dib807x_dib0070_config[2] = {
1466 {
1467 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1468 .reset = dib807x_tuner_reset,
1469 .sleep = dib807x_tuner_sleep,
1470 .clock_khz = 12000,
1471 .clock_pad_drive = 4,
1472 .vga_filter = 1,
1473 .force_crystal_mode = 1,
1474 .enable_third_order_filter = 1,
1475 .charge_pump = 0,
1476 .wbd_gain = dib8070_wbd_gain_cfg,
1477 .osc_buffer_state = 0,
1478 .freq_offset_khz_uhf = -100,
1479 .freq_offset_khz_vhf = -100,
1480 }, {
1481 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1482 .reset = dib807x_tuner_reset,
1483 .sleep = dib807x_tuner_sleep,
1484 .clock_khz = 12000,
1485 .clock_pad_drive = 2,
1486 .vga_filter = 1,
1487 .force_crystal_mode = 1,
1488 .enable_third_order_filter = 1,
1489 .charge_pump = 0,
1490 .wbd_gain = dib8070_wbd_gain_cfg,
1491 .osc_buffer_state = 0,
1492 .freq_offset_khz_uhf = -25,
1493 .freq_offset_khz_vhf = -25,
1494 }
1495 };
1496
1497 static int dib807x_set_param_override(struct dvb_frontend *fe,
1498 struct dvb_frontend_parameters *fep)
1499 {
1500 struct dvb_usb_adapter *adap = fe->dvb->priv;
1501 struct dib0700_adapter_state *state = adap->priv;
1502
1503 u16 offset = dib0070_wbd_offset(fe);
1504 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1505 switch (band) {
1506 case BAND_VHF:
1507 offset += 750;
1508 break;
1509 case BAND_UHF: /* fall-thru wanted */
1510 default:
1511 offset += 250; break;
1512 }
1513 deb_info("WBD for DiB8000: %d\n", offset);
1514 dib8000_set_wbd_ref(fe, offset);
1515
1516 return state->set_param_save(fe, fep);
1517 }
1518
1519 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1520 {
1521 struct dib0700_adapter_state *st = adap->priv;
1522 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
1523 DIBX000_I2C_INTERFACE_TUNER, 1);
1524
1525 if (adap->id == 0) {
1526 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1527 &dib807x_dib0070_config[0]) == NULL)
1528 return -ENODEV;
1529 } else {
1530 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1531 &dib807x_dib0070_config[1]) == NULL)
1532 return -ENODEV;
1533 }
1534
1535 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1536 adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1537 return 0;
1538 }
1539
1540
1541 /* STK807x */
1542 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1543 {
1544 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1545 msleep(10);
1546 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1547 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1548 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1549
1550 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1551
1552 dib0700_ctrl_clock(adap->dev, 72, 1);
1553
1554 msleep(10);
1555 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1556 msleep(10);
1557 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1558
1559 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1560 0x80);
1561
1562 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1563 &dib807x_dib8000_config[0]);
1564
1565 return adap->fe == NULL ? -ENODEV : 0;
1566 }
1567
1568 /* STK807xPVR */
1569 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1570 {
1571 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1572 msleep(30);
1573 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1574 msleep(500);
1575 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1576 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1577 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1578
1579 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1580
1581 dib0700_ctrl_clock(adap->dev, 72, 1);
1582
1583 msleep(10);
1584 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1585 msleep(10);
1586 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1587
1588 /* initialize IC 0 */
1589 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x80);
1590
1591 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1592 &dib807x_dib8000_config[0]);
1593
1594 return adap->fe == NULL ? -ENODEV : 0;
1595 }
1596
1597 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1598 {
1599 /* initialize IC 1 */
1600 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x82);
1601
1602 adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1603 &dib807x_dib8000_config[1]);
1604
1605 return adap->fe == NULL ? -ENODEV : 0;
1606 }
1607
1608
1609 /* STK7070PD */
1610 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
1611 {
1612 .output_mpeg2_in_188_bytes = 1,
1613
1614 .agc_config_count = 1,
1615 .agc = &dib7070_agc_config,
1616 .bw = &dib7070_bw_config_12_mhz,
1617 .tuner_is_baseband = 1,
1618 .spur_protect = 1,
1619
1620 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1621 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1622 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1623
1624 .hostbus_diversity = 1,
1625 }, {
1626 .output_mpeg2_in_188_bytes = 1,
1627
1628 .agc_config_count = 1,
1629 .agc = &dib7070_agc_config,
1630 .bw = &dib7070_bw_config_12_mhz,
1631 .tuner_is_baseband = 1,
1632 .spur_protect = 1,
1633
1634 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1635 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1636 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1637
1638 .hostbus_diversity = 1,
1639 }
1640 };
1641
1642 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
1643 {
1644 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1645 msleep(10);
1646 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1647 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1648 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1649 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1650
1651 dib0700_ctrl_clock(adap->dev, 72, 1);
1652
1653 msleep(10);
1654 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1655 msleep(10);
1656 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1657
1658 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
1659 stk7070pd_dib7000p_config) != 0) {
1660 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
1661 __func__);
1662 return -ENODEV;
1663 }
1664
1665 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
1666 return adap->fe == NULL ? -ENODEV : 0;
1667 }
1668
1669 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
1670 {
1671 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
1672 return adap->fe == NULL ? -ENODEV : 0;
1673 }
1674
1675 /* S5H1411 */
1676 static struct s5h1411_config pinnacle_801e_config = {
1677 .output_mode = S5H1411_PARALLEL_OUTPUT,
1678 .gpio = S5H1411_GPIO_OFF,
1679 .mpeg_timing = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
1680 .qam_if = S5H1411_IF_44000,
1681 .vsb_if = S5H1411_IF_44000,
1682 .inversion = S5H1411_INVERSION_OFF,
1683 .status_mode = S5H1411_DEMODLOCKING
1684 };
1685
1686 /* Pinnacle PCTV HD Pro 801e GPIOs map:
1687 GPIO0 - currently unknown
1688 GPIO1 - xc5000 tuner reset
1689 GPIO2 - CX25843 sleep
1690 GPIO3 - currently unknown
1691 GPIO4 - currently unknown
1692 GPIO6 - currently unknown
1693 GPIO7 - currently unknown
1694 GPIO9 - currently unknown
1695 GPIO10 - CX25843 reset
1696 */
1697 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
1698 {
1699 struct dib0700_state *st = adap->dev->priv;
1700
1701 /* Make use of the new i2c functions from FW 1.20 */
1702 st->fw_use_new_i2c_api = 1;
1703
1704 /* The s5h1411 requires the dib0700 to not be in master mode */
1705 st->disable_streaming_master_mode = 1;
1706
1707 /* All msleep values taken from Windows USB trace */
1708 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
1709 dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
1710 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1711 msleep(400);
1712 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1713 msleep(60);
1714 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1715 msleep(30);
1716 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1717 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1718 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1719 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1720 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
1721 msleep(30);
1722
1723 /* Put the CX25843 to sleep for now since we're in digital mode */
1724 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
1725
1726 /* GPIOs are initialized, do the attach */
1727 adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
1728 &adap->dev->i2c_adap);
1729 return adap->fe == NULL ? -ENODEV : 0;
1730 }
1731
1732 static int dib0700_xc5000_tuner_callback(void *priv, int component,
1733 int command, int arg)
1734 {
1735 struct dvb_usb_adapter *adap = priv;
1736
1737 if (command == XC5000_TUNER_RESET) {
1738 /* Reset the tuner */
1739 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
1740 msleep(10);
1741 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
1742 msleep(10);
1743 } else {
1744 err("xc5000: unknown tuner callback command: %d\n", command);
1745 return -EINVAL;
1746 }
1747
1748 return 0;
1749 }
1750
1751 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
1752 .i2c_address = 0x64,
1753 .if_khz = 5380,
1754 };
1755
1756 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
1757 {
1758 /* FIXME: generalize & move to common area */
1759 adap->fe->callback = dib0700_xc5000_tuner_callback;
1760
1761 return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
1762 &s5h1411_xc5000_tunerconfig)
1763 == NULL ? -ENODEV : 0;
1764 }
1765
1766 static struct lgdt3305_config hcw_lgdt3305_config = {
1767 .i2c_addr = 0x0e,
1768 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
1769 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
1770 .tpvalid_polarity = LGDT3305_TP_VALID_LOW,
1771 .deny_i2c_rptr = 0,
1772 .spectral_inversion = 1,
1773 .qam_if_khz = 6000,
1774 .vsb_if_khz = 6000,
1775 .usref_8vsb = 0x0500,
1776 };
1777
1778 static struct mxl5007t_config hcw_mxl5007t_config = {
1779 .xtal_freq_hz = MxL_XTAL_25_MHZ,
1780 .if_freq_hz = MxL_IF_6_MHZ,
1781 .invert_if = 1,
1782 };
1783
1784 /* TIGER-ATSC map:
1785 GPIO0 - LNA_CTR (H: LNA power enabled, L: LNA power disabled)
1786 GPIO1 - ANT_SEL (H: VPA, L: MCX)
1787 GPIO4 - SCL2
1788 GPIO6 - EN_TUNER
1789 GPIO7 - SDA2
1790 GPIO10 - DEM_RST
1791
1792 MXL is behind LG's i2c repeater. LG is on SCL2/SDA2 gpios on the DIB
1793 */
1794 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
1795 {
1796 struct dib0700_state *st = adap->dev->priv;
1797
1798 /* Make use of the new i2c functions from FW 1.20 */
1799 st->fw_use_new_i2c_api = 1;
1800
1801 st->disable_streaming_master_mode = 1;
1802
1803 /* fe power enable */
1804 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1805 msleep(30);
1806 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1807 msleep(30);
1808
1809 /* demod reset */
1810 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1811 msleep(30);
1812 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1813 msleep(30);
1814 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1815 msleep(30);
1816
1817 adap->fe = dvb_attach(lgdt3305_attach,
1818 &hcw_lgdt3305_config,
1819 &adap->dev->i2c_adap);
1820
1821 return adap->fe == NULL ? -ENODEV : 0;
1822 }
1823
1824 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
1825 {
1826 return dvb_attach(mxl5007t_attach, adap->fe,
1827 &adap->dev->i2c_adap, 0x60,
1828 &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
1829 }
1830
1831
1832 /* DVB-USB and USB stuff follows */
1833 struct usb_device_id dib0700_usb_id_table[] = {
1834 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) },
1835 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P_PC) },
1836 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
1837 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
1838 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
1839 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
1840 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500) },
1841 { USB_DEVICE(USB_VID_UNIWILL, USB_PID_UNIWILL_STK7700P) },
1842 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
1843 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
1844 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
1845 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV2000E) },
1846 { USB_DEVICE(USB_VID_TERRATEC,
1847 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
1848 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
1849 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700D) },
1850 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070P) },
1851 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
1852 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070PD) },
1853 { USB_DEVICE(USB_VID_PINNACLE,
1854 USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
1855 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500_PC) },
1856 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
1857 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
1858 { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
1859 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000) },
1860 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100) },
1861 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
1862 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
1863 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
1864 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_EXPRESSCARD_320CX) },
1865 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV72E) },
1866 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73E) },
1867 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_EC372S) },
1868 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
1869 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS) },
1870 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
1871 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
1872 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
1873 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U8000) },
1874 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700PH) },
1875 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000H) },
1876 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E) },
1877 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E_SE) },
1878 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
1879 { USB_DEVICE(USB_VID_TERRATEC,
1880 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
1881 { USB_DEVICE(USB_VID_SONY, USB_PID_SONY_PLAYTV) },
1882 /* 45 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_PD378S) },
1883 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
1884 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
1885 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_MC770) },
1886 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT) },
1887 /* 50 */{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_Dlx) },
1888 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_H) },
1889 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T3) },
1890 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T5) },
1891 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D) },
1892 /* 55 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D_2) },
1893 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73A) },
1894 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73ESE) },
1895 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV282E) },
1896 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7770P) },
1897 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS_2) },
1898 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XPVR) },
1899 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XP) },
1900 { USB_DEVICE(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD) },
1901 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DIVERSITY) },
1902 { 0 } /* Terminating entry */
1903 };
1904 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
1905
1906 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
1907 .caps = DVB_USB_IS_AN_I2C_ADAPTER, \
1908 .usb_ctrl = DEVICE_SPECIFIC, \
1909 .firmware = "dvb-usb-dib0700-1.20.fw", \
1910 .download_firmware = dib0700_download_firmware, \
1911 .no_reconnect = 1, \
1912 .size_of_priv = sizeof(struct dib0700_state), \
1913 .i2c_algo = &dib0700_i2c_algo, \
1914 .identify_state = dib0700_identify_state
1915
1916 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
1917 .streaming_ctrl = dib0700_streaming_ctrl, \
1918 .stream = { \
1919 .type = USB_BULK, \
1920 .count = 4, \
1921 .endpoint = ep, \
1922 .u = { \
1923 .bulk = { \
1924 .buffersize = 39480, \
1925 } \
1926 } \
1927 }
1928
1929 struct dvb_usb_device_properties dib0700_devices[] = {
1930 {
1931 DIB0700_DEFAULT_DEVICE_PROPERTIES,
1932
1933 .num_adapters = 1,
1934 .adapter = {
1935 {
1936 .frontend_attach = stk7700p_frontend_attach,
1937 .tuner_attach = stk7700p_tuner_attach,
1938
1939 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1940 },
1941 },
1942
1943 .num_device_descs = 8,
1944 .devices = {
1945 { "DiBcom STK7700P reference design",
1946 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
1947 { NULL },
1948 },
1949 { "Hauppauge Nova-T Stick",
1950 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
1951 { NULL },
1952 },
1953 { "AVerMedia AVerTV DVB-T Volar",
1954 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
1955 { NULL },
1956 },
1957 { "Compro Videomate U500",
1958 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
1959 { NULL },
1960 },
1961 { "Uniwill STK7700P based (Hama and others)",
1962 { &dib0700_usb_id_table[7], NULL },
1963 { NULL },
1964 },
1965 { "Leadtek Winfast DTV Dongle (STK7700P based)",
1966 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
1967 { NULL },
1968 },
1969 { "AVerMedia AVerTV DVB-T Express",
1970 { &dib0700_usb_id_table[20] },
1971 { NULL },
1972 },
1973 { "Gigabyte U7000",
1974 { &dib0700_usb_id_table[21], NULL },
1975 { NULL },
1976 }
1977 },
1978
1979 .rc_interval = DEFAULT_RC_INTERVAL,
1980 .rc_key_map = dib0700_rc_keys,
1981 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
1982 .rc_query = dib0700_rc_query
1983 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1984
1985 .num_adapters = 2,
1986 .adapter = {
1987 {
1988 .frontend_attach = bristol_frontend_attach,
1989 .tuner_attach = bristol_tuner_attach,
1990
1991 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1992 }, {
1993 .frontend_attach = bristol_frontend_attach,
1994 .tuner_attach = bristol_tuner_attach,
1995
1996 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1997 }
1998 },
1999
2000 .num_device_descs = 1,
2001 .devices = {
2002 { "Hauppauge Nova-T 500 Dual DVB-T",
2003 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
2004 { NULL },
2005 },
2006 },
2007
2008 .rc_interval = DEFAULT_RC_INTERVAL,
2009 .rc_key_map = dib0700_rc_keys,
2010 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2011 .rc_query = dib0700_rc_query
2012 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2013
2014 .num_adapters = 2,
2015 .adapter = {
2016 {
2017 .frontend_attach = stk7700d_frontend_attach,
2018 .tuner_attach = stk7700d_tuner_attach,
2019
2020 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2021 }, {
2022 .frontend_attach = stk7700d_frontend_attach,
2023 .tuner_attach = stk7700d_tuner_attach,
2024
2025 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2026 }
2027 },
2028
2029 .num_device_descs = 5,
2030 .devices = {
2031 { "Pinnacle PCTV 2000e",
2032 { &dib0700_usb_id_table[11], NULL },
2033 { NULL },
2034 },
2035 { "Terratec Cinergy DT XS Diversity",
2036 { &dib0700_usb_id_table[12], NULL },
2037 { NULL },
2038 },
2039 { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
2040 { &dib0700_usb_id_table[13], NULL },
2041 { NULL },
2042 },
2043 { "DiBcom STK7700D reference design",
2044 { &dib0700_usb_id_table[14], NULL },
2045 { NULL },
2046 },
2047 { "YUAN High-Tech DiBcom STK7700D",
2048 { &dib0700_usb_id_table[55], NULL },
2049 { NULL },
2050 },
2051
2052 },
2053
2054 .rc_interval = DEFAULT_RC_INTERVAL,
2055 .rc_key_map = dib0700_rc_keys,
2056 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2057 .rc_query = dib0700_rc_query
2058
2059 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2060
2061 .num_adapters = 1,
2062 .adapter = {
2063 {
2064 .frontend_attach = stk7700P2_frontend_attach,
2065 .tuner_attach = stk7700d_tuner_attach,
2066
2067 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2068 },
2069 },
2070
2071 .num_device_descs = 3,
2072 .devices = {
2073 { "ASUS My Cinema U3000 Mini DVBT Tuner",
2074 { &dib0700_usb_id_table[23], NULL },
2075 { NULL },
2076 },
2077 { "Yuan EC372S",
2078 { &dib0700_usb_id_table[31], NULL },
2079 { NULL },
2080 },
2081 { "Terratec Cinergy T Express",
2082 { &dib0700_usb_id_table[42], NULL },
2083 { NULL },
2084 }
2085 },
2086
2087 .rc_interval = DEFAULT_RC_INTERVAL,
2088 .rc_key_map = dib0700_rc_keys,
2089 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2090 .rc_query = dib0700_rc_query
2091 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2092
2093 .num_adapters = 1,
2094 .adapter = {
2095 {
2096 .frontend_attach = stk7070p_frontend_attach,
2097 .tuner_attach = dib7070p_tuner_attach,
2098
2099 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2100
2101 .size_of_priv = sizeof(struct dib0700_adapter_state),
2102 },
2103 },
2104
2105 .num_device_descs = 11,
2106 .devices = {
2107 { "DiBcom STK7070P reference design",
2108 { &dib0700_usb_id_table[15], NULL },
2109 { NULL },
2110 },
2111 { "Pinnacle PCTV DVB-T Flash Stick",
2112 { &dib0700_usb_id_table[16], NULL },
2113 { NULL },
2114 },
2115 { "Artec T14BR DVB-T",
2116 { &dib0700_usb_id_table[22], NULL },
2117 { NULL },
2118 },
2119 { "ASUS My Cinema U3100 Mini DVBT Tuner",
2120 { &dib0700_usb_id_table[24], NULL },
2121 { NULL },
2122 },
2123 { "Hauppauge Nova-T Stick",
2124 { &dib0700_usb_id_table[25], NULL },
2125 { NULL },
2126 },
2127 { "Hauppauge Nova-T MyTV.t",
2128 { &dib0700_usb_id_table[26], NULL },
2129 { NULL },
2130 },
2131 { "Pinnacle PCTV 72e",
2132 { &dib0700_usb_id_table[29], NULL },
2133 { NULL },
2134 },
2135 { "Pinnacle PCTV 73e",
2136 { &dib0700_usb_id_table[30], NULL },
2137 { NULL },
2138 },
2139 { "Elgato EyeTV DTT",
2140 { &dib0700_usb_id_table[49], NULL },
2141 { NULL },
2142 },
2143 { "Yuan PD378S",
2144 { &dib0700_usb_id_table[45], NULL },
2145 { NULL },
2146 },
2147 { "Elgato EyeTV Dtt Dlx PD378S",
2148 { &dib0700_usb_id_table[50], NULL },
2149 { NULL },
2150 },
2151 },
2152
2153 .rc_interval = DEFAULT_RC_INTERVAL,
2154 .rc_key_map = dib0700_rc_keys,
2155 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2156 .rc_query = dib0700_rc_query
2157
2158 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2159
2160 .num_adapters = 1,
2161 .adapter = {
2162 {
2163 .frontend_attach = stk7070p_frontend_attach,
2164 .tuner_attach = dib7070p_tuner_attach,
2165
2166 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2167
2168 .size_of_priv = sizeof(struct dib0700_adapter_state),
2169 },
2170 },
2171
2172 .num_device_descs = 3,
2173 .devices = {
2174 { "Pinnacle PCTV 73A",
2175 { &dib0700_usb_id_table[56], NULL },
2176 { NULL },
2177 },
2178 { "Pinnacle PCTV 73e SE",
2179 { &dib0700_usb_id_table[57], NULL },
2180 { NULL },
2181 },
2182 { "Pinnacle PCTV 282e",
2183 { &dib0700_usb_id_table[58], NULL },
2184 { NULL },
2185 },
2186 },
2187
2188 .rc_interval = DEFAULT_RC_INTERVAL,
2189 .rc_key_map = dib0700_rc_keys,
2190 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2191 .rc_query = dib0700_rc_query
2192
2193 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2194
2195 .num_adapters = 2,
2196 .adapter = {
2197 {
2198 .frontend_attach = stk7070pd_frontend_attach0,
2199 .tuner_attach = dib7070p_tuner_attach,
2200
2201 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2202
2203 .size_of_priv = sizeof(struct dib0700_adapter_state),
2204 }, {
2205 .frontend_attach = stk7070pd_frontend_attach1,
2206 .tuner_attach = dib7070p_tuner_attach,
2207
2208 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2209
2210 .size_of_priv = sizeof(struct dib0700_adapter_state),
2211 }
2212 },
2213
2214 .num_device_descs = 7,
2215 .devices = {
2216 { "DiBcom STK7070PD reference design",
2217 { &dib0700_usb_id_table[17], NULL },
2218 { NULL },
2219 },
2220 { "Pinnacle PCTV Dual DVB-T Diversity Stick",
2221 { &dib0700_usb_id_table[18], NULL },
2222 { NULL },
2223 },
2224 { "Hauppauge Nova-TD Stick (52009)",
2225 { &dib0700_usb_id_table[35], NULL },
2226 { NULL },
2227 },
2228 { "Hauppauge Nova-TD-500 (84xxx)",
2229 { &dib0700_usb_id_table[36], NULL },
2230 { NULL },
2231 },
2232 { "Terratec Cinergy DT USB XS Diversity/ T5",
2233 { &dib0700_usb_id_table[43],
2234 &dib0700_usb_id_table[53], NULL},
2235 { NULL },
2236 },
2237 { "Sony PlayTV",
2238 { &dib0700_usb_id_table[44], NULL },
2239 { NULL },
2240 },
2241 { "Elgato EyeTV Diversity",
2242 { &dib0700_usb_id_table[64], NULL },
2243 { NULL },
2244 },
2245 },
2246 .rc_interval = DEFAULT_RC_INTERVAL,
2247 .rc_key_map = dib0700_rc_keys,
2248 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2249 .rc_query = dib0700_rc_query
2250 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2251
2252 .num_adapters = 1,
2253 .adapter = {
2254 {
2255 .frontend_attach = stk7700ph_frontend_attach,
2256 .tuner_attach = stk7700ph_tuner_attach,
2257
2258 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2259
2260 .size_of_priv = sizeof(struct
2261 dib0700_adapter_state),
2262 },
2263 },
2264
2265 .num_device_descs = 9,
2266 .devices = {
2267 { "Terratec Cinergy HT USB XE",
2268 { &dib0700_usb_id_table[27], NULL },
2269 { NULL },
2270 },
2271 { "Pinnacle Expresscard 320cx",
2272 { &dib0700_usb_id_table[28], NULL },
2273 { NULL },
2274 },
2275 { "Terratec Cinergy HT Express",
2276 { &dib0700_usb_id_table[32], NULL },
2277 { NULL },
2278 },
2279 { "Gigabyte U8000-RH",
2280 { &dib0700_usb_id_table[37], NULL },
2281 { NULL },
2282 },
2283 { "YUAN High-Tech STK7700PH",
2284 { &dib0700_usb_id_table[38], NULL },
2285 { NULL },
2286 },
2287 { "Asus My Cinema-U3000Hybrid",
2288 { &dib0700_usb_id_table[39], NULL },
2289 { NULL },
2290 },
2291 { "YUAN High-Tech MC770",
2292 { &dib0700_usb_id_table[48], NULL },
2293 { NULL },
2294 },
2295 { "Leadtek WinFast DTV Dongle H",
2296 { &dib0700_usb_id_table[51], NULL },
2297 { NULL },
2298 },
2299 { "YUAN High-Tech STK7700D",
2300 { &dib0700_usb_id_table[54], NULL },
2301 { NULL },
2302 },
2303 },
2304 .rc_interval = DEFAULT_RC_INTERVAL,
2305 .rc_key_map = dib0700_rc_keys,
2306 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2307 .rc_query = dib0700_rc_query
2308 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2309 .num_adapters = 1,
2310 .adapter = {
2311 {
2312 .frontend_attach = s5h1411_frontend_attach,
2313 .tuner_attach = xc5000_tuner_attach,
2314
2315 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2316
2317 .size_of_priv = sizeof(struct
2318 dib0700_adapter_state),
2319 },
2320 },
2321
2322 .num_device_descs = 2,
2323 .devices = {
2324 { "Pinnacle PCTV HD Pro USB Stick",
2325 { &dib0700_usb_id_table[40], NULL },
2326 { NULL },
2327 },
2328 { "Pinnacle PCTV HD USB Stick",
2329 { &dib0700_usb_id_table[41], NULL },
2330 { NULL },
2331 },
2332 },
2333 .rc_interval = DEFAULT_RC_INTERVAL,
2334 .rc_key_map = dib0700_rc_keys,
2335 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2336 .rc_query = dib0700_rc_query
2337 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2338 .num_adapters = 1,
2339 .adapter = {
2340 {
2341 .frontend_attach = lgdt3305_frontend_attach,
2342 .tuner_attach = mxl5007t_tuner_attach,
2343
2344 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2345
2346 .size_of_priv = sizeof(struct
2347 dib0700_adapter_state),
2348 },
2349 },
2350
2351 .num_device_descs = 2,
2352 .devices = {
2353 { "Hauppauge ATSC MiniCard (B200)",
2354 { &dib0700_usb_id_table[46], NULL },
2355 { NULL },
2356 },
2357 { "Hauppauge ATSC MiniCard (B210)",
2358 { &dib0700_usb_id_table[47], NULL },
2359 { NULL },
2360 },
2361 },
2362 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2363
2364 .num_adapters = 1,
2365 .adapter = {
2366 {
2367 .frontend_attach = stk7070p_frontend_attach,
2368 .tuner_attach = dib7770p_tuner_attach,
2369
2370 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2371
2372 .size_of_priv =
2373 sizeof(struct dib0700_adapter_state),
2374 },
2375 },
2376
2377 .num_device_descs = 2,
2378 .devices = {
2379 { "DiBcom STK7770P reference design",
2380 { &dib0700_usb_id_table[59], NULL },
2381 { NULL },
2382 },
2383 { "Terratec Cinergy T USB XXS (HD)/ T3",
2384 { &dib0700_usb_id_table[33],
2385 &dib0700_usb_id_table[52],
2386 &dib0700_usb_id_table[60], NULL},
2387 { NULL },
2388 },
2389 },
2390 .rc_interval = DEFAULT_RC_INTERVAL,
2391 .rc_key_map = dib0700_rc_keys,
2392 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2393 .rc_query = dib0700_rc_query
2394 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2395 .num_adapters = 1,
2396 .adapter = {
2397 {
2398 .frontend_attach = stk807x_frontend_attach,
2399 .tuner_attach = dib807x_tuner_attach,
2400
2401 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2402
2403 .size_of_priv =
2404 sizeof(struct dib0700_adapter_state),
2405 },
2406 },
2407
2408 .num_device_descs = 2,
2409 .devices = {
2410 { "DiBcom STK807xP reference design",
2411 { &dib0700_usb_id_table[62], NULL },
2412 { NULL },
2413 },
2414 { "Prolink Pixelview SBTVD",
2415 { &dib0700_usb_id_table[63], NULL },
2416 { NULL },
2417 },
2418 },
2419
2420 .rc_interval = DEFAULT_RC_INTERVAL,
2421 .rc_key_map = dib0700_rc_keys,
2422 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2423 .rc_query = dib0700_rc_query
2424
2425 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
2426 .num_adapters = 2,
2427 .adapter = {
2428 {
2429 .frontend_attach = stk807xpvr_frontend_attach0,
2430 .tuner_attach = dib807x_tuner_attach,
2431
2432 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
2433
2434 .size_of_priv =
2435 sizeof(struct dib0700_adapter_state),
2436 },
2437 {
2438 .frontend_attach = stk807xpvr_frontend_attach1,
2439 .tuner_attach = dib807x_tuner_attach,
2440
2441 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
2442
2443 .size_of_priv =
2444 sizeof(struct dib0700_adapter_state),
2445 },
2446 },
2447
2448 .num_device_descs = 1,
2449 .devices = {
2450 { "DiBcom STK807xPVR reference design",
2451 { &dib0700_usb_id_table[61], NULL },
2452 { NULL },
2453 },
2454 },
2455
2456 .rc_interval = DEFAULT_RC_INTERVAL,
2457 .rc_key_map = dib0700_rc_keys,
2458 .rc_key_map_size = ARRAY_SIZE(dib0700_rc_keys),
2459 .rc_query = dib0700_rc_query
2460 },
2461 };
2462
2463 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
Linux ARM platform port for MOXA ART SoC