Merge branch 'sched-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / drivers / media / dvb / dvb-usb / dib0700_devices.c
1 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
2  *
3  *      This program is free software; you can redistribute it and/or modify it
4  *      under the terms of the GNU General Public License as published by the Free
5  *      Software Foundation, version 2.
6  *
7  *  Copyright (C) 2005-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
21 static int force_lna_activation;
22 module_param(force_lna_activation, int, 0644);
23 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
24                 "if applicable for the device (default: 0=automatic/off).");
25
26 struct dib0700_adapter_state {
27         int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
28 };
29
30 /* Hauppauge Nova-T 500 (aka Bristol)
31  *  has a LNA on GPIO0 which is enabled by setting 1 */
32 static struct mt2060_config bristol_mt2060_config[2] = {
33         {
34                 .i2c_address = 0x60,
35                 .clock_out   = 3,
36         }, {
37                 .i2c_address = 0x61,
38         }
39 };
40
41
42 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
43         .band_caps = BAND_VHF | BAND_UHF,
44         .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
45
46         .agc1_max = 42598,
47         .agc1_min = 17694,
48         .agc2_max = 45875,
49         .agc2_min = 0,
50
51         .agc1_pt1 = 0,
52         .agc1_pt2 = 59,
53
54         .agc1_slope1 = 0,
55         .agc1_slope2 = 69,
56
57         .agc2_pt1 = 0,
58         .agc2_pt2 = 59,
59
60         .agc2_slope1 = 111,
61         .agc2_slope2 = 28,
62 };
63
64 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
65         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
66                 .max_time     = 0x196,
67                 .ln_adc_level = 0x1cc7,
68                 .output_mpeg2_in_188_bytes = 1,
69         },
70         {       .agc          = &bristol_dib3000p_mt2060_agc_config,
71                 .max_time     = 0x196,
72                 .ln_adc_level = 0x1cc7,
73                 .output_mpeg2_in_188_bytes = 1,
74         }
75 };
76
77 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
78 {
79         struct dib0700_state *st = adap->dev->priv;
80         if (adap->id == 0) {
81                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
82                 dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
83                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
84                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
85
86                 if (force_lna_activation)
87                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
88                 else
89                         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
90
91                 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
92                         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
93                         return -ENODEV;
94                 }
95         }
96         st->mt2060_if1[adap->id] = 1220;
97         return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
98                 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
99 }
100
101 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
102 {
103         struct i2c_msg msg[2] = {
104                 { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
105                 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
106         };
107         if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
108         return 0;
109 }
110
111 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
112 {
113         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
114         struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
115         s8 a;
116         int if1=1220;
117         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
118                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
119                 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
120         }
121         return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
122                 if1) == NULL ? -ENODEV : 0;
123 }
124
125 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
126
127 /* MT226x */
128 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
129         {
130                 BAND_UHF, // band_caps
131
132                 /* 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,
133                 * 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 */
134                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
135
136                 1130,  // inv_gain
137                 21,  // time_stabiliz
138
139                 0,  // alpha_level
140                 118,  // thlock
141
142                 0,     // wbd_inv
143                 3530,  // wbd_ref
144                 1,     // wbd_sel
145                 0,     // wbd_alpha
146
147                 65535,  // agc1_max
148                 33770,  // agc1_min
149                 65535,  // agc2_max
150                 23592,  // agc2_min
151
152                 0,    // agc1_pt1
153                 62,   // agc1_pt2
154                 255,  // agc1_pt3
155                 64,   // agc1_slope1
156                 64,   // agc1_slope2
157                 132,  // agc2_pt1
158                 192,  // agc2_pt2
159                 80,   // agc2_slope1
160                 80,   // agc2_slope2
161
162                 17,  // alpha_mant
163                 27,  // alpha_exp
164                 23,  // beta_mant
165                 51,  // beta_exp
166
167                 1,  // perform_agc_softsplit
168         }, {
169                 BAND_VHF | BAND_LBAND, // band_caps
170
171                 /* 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,
172                 * 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 */
173                 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
174
175                 2372, // inv_gain
176                 21,   // time_stabiliz
177
178                 0,    // alpha_level
179                 118,  // thlock
180
181                 0,    // wbd_inv
182                 3530, // wbd_ref
183                 1,     // wbd_sel
184                 0,    // wbd_alpha
185
186                 65535, // agc1_max
187                 0,     // agc1_min
188                 65535, // agc2_max
189                 23592, // agc2_min
190
191                 0,    // agc1_pt1
192                 128,  // agc1_pt2
193                 128,  // agc1_pt3
194                 128,  // agc1_slope1
195                 0,    // agc1_slope2
196                 128,  // agc2_pt1
197                 253,  // agc2_pt2
198                 81,   // agc2_slope1
199                 0,    // agc2_slope2
200
201                 17,  // alpha_mant
202                 27,  // alpha_exp
203                 23,  // beta_mant
204                 51,  // beta_exp
205
206                 1,  // perform_agc_softsplit
207         }
208 };
209
210 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
211         60000, 30000, // internal, sampling
212         1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
213         0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
214         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
215         0, // ifreq
216         20452225, // timf
217 };
218
219 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
220         {       .output_mpeg2_in_188_bytes = 1,
221                 .hostbus_diversity = 1,
222                 .tuner_is_baseband = 1,
223
224                 .agc_config_count = 2,
225                 .agc = stk7700d_7000p_mt2266_agc_config,
226                 .bw  = &stk7700d_mt2266_pll_config,
227
228                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
229                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
230                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
231         },
232         {       .output_mpeg2_in_188_bytes = 1,
233                 .hostbus_diversity = 1,
234                 .tuner_is_baseband = 1,
235
236                 .agc_config_count = 2,
237                 .agc = stk7700d_7000p_mt2266_agc_config,
238                 .bw  = &stk7700d_mt2266_pll_config,
239
240                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
241                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
242                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
243         }
244 };
245
246 static struct mt2266_config stk7700d_mt2266_config[2] = {
247         {       .i2c_address = 0x60
248         },
249         {       .i2c_address = 0x60
250         }
251 };
252
253 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
254 {
255         if (adap->id == 0) {
256                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
257                 msleep(10);
258                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
259                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
260                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
261                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
262                 msleep(10);
263                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
264                 msleep(10);
265                 dib7000p_i2c_enumeration(&adap->dev->i2c_adap,1,18,stk7700d_dib7000p_mt2266_config);
266         }
267
268         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
269                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
270
271         return adap->fe == NULL ? -ENODEV : 0;
272 }
273
274 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
275 {
276         if (adap->id == 0) {
277                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
278                 msleep(10);
279                 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
280                 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
281                 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
282                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
283                 msleep(10);
284                 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
285                 msleep(10);
286                 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
287                 dib7000p_i2c_enumeration(&adap->dev->i2c_adap,2,18,stk7700d_dib7000p_mt2266_config);
288         }
289
290         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
291                                 &stk7700d_dib7000p_mt2266_config[adap->id]);
292
293         return adap->fe == NULL ? -ENODEV : 0;
294 }
295
296 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
297 {
298         struct i2c_adapter *tun_i2c;
299         tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
300         return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
301                 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;;
302 }
303
304 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
305 static struct dibx000_agc_config xc3028_agc_config = {
306         BAND_VHF | BAND_UHF,       /* band_caps */
307
308         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
309          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
310          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
311         (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
312         (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
313
314         712,    /* inv_gain */
315         21,     /* time_stabiliz */
316
317         0,      /* alpha_level */
318         118,    /* thlock */
319
320         0,      /* wbd_inv */
321         2867,   /* wbd_ref */
322         0,      /* wbd_sel */
323         2,      /* wbd_alpha */
324
325         0,      /* agc1_max */
326         0,      /* agc1_min */
327         39718,  /* agc2_max */
328         9930,   /* agc2_min */
329         0,      /* agc1_pt1 */
330         0,      /* agc1_pt2 */
331         0,      /* agc1_pt3 */
332         0,      /* agc1_slope1 */
333         0,      /* agc1_slope2 */
334         0,      /* agc2_pt1 */
335         128,    /* agc2_pt2 */
336         29,     /* agc2_slope1 */
337         29,     /* agc2_slope2 */
338
339         17,     /* alpha_mant */
340         27,     /* alpha_exp */
341         23,     /* beta_mant */
342         51,     /* beta_exp */
343
344         1,      /* perform_agc_softsplit */
345 };
346
347 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
348 static struct dibx000_bandwidth_config xc3028_bw_config = {
349         60000, 30000, /* internal, sampling */
350         1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
351         0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
352                           modulo */
353         (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
354         (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
355         20452225, /* timf */
356         30000000, /* xtal_hz */
357 };
358
359 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
360         .output_mpeg2_in_188_bytes = 1,
361         .tuner_is_baseband = 1,
362
363         .agc_config_count = 1,
364         .agc = &xc3028_agc_config,
365         .bw  = &xc3028_bw_config,
366
367         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
368         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
369         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
370 };
371
372 static int stk7700ph_xc3028_callback(void *ptr, int component,
373                                      int command, int arg)
374 {
375         struct dvb_usb_adapter *adap = ptr;
376
377         switch (command) {
378         case XC2028_TUNER_RESET:
379                 /* Send the tuner in then out of reset */
380                 dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
381                 dib7000p_set_gpio(adap->fe, 8, 0, 1);
382                 break;
383         case XC2028_RESET_CLK:
384                 break;
385         default:
386                 err("%s: unknown command %d, arg %d\n", __func__,
387                         command, arg);
388                 return -EINVAL;
389         }
390         return 0;
391 }
392
393 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
394         .fname = XC2028_DEFAULT_FIRMWARE,
395         .max_len = 64,
396         .demod = XC3028_FE_DIBCOM52,
397 };
398
399 static struct xc2028_config stk7700ph_xc3028_config = {
400         .i2c_addr = 0x61,
401         .ctrl = &stk7700ph_xc3028_ctrl,
402 };
403
404 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
405 {
406         struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
407
408         if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
409             desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
410         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
411         else
412         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
413         msleep(20);
414         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
415         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
416         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
417         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
418         msleep(10);
419         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
420         msleep(20);
421         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
422         msleep(10);
423
424         dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
425                 &stk7700ph_dib7700_xc3028_config);
426
427         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
428                 &stk7700ph_dib7700_xc3028_config);
429
430         return adap->fe == NULL ? -ENODEV : 0;
431 }
432
433 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
434 {
435         struct i2c_adapter *tun_i2c;
436
437         tun_i2c = dib7000p_get_i2c_master(adap->fe,
438                 DIBX000_I2C_INTERFACE_TUNER, 1);
439
440         stk7700ph_xc3028_config.i2c_adap = tun_i2c;
441
442         /* FIXME: generalize & move to common area */
443         adap->fe->callback = stk7700ph_xc3028_callback;
444
445         return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
446                 == NULL ? -ENODEV : 0;
447 }
448
449 #define DEFAULT_RC_INTERVAL 150
450
451 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
452
453 /* Number of keypresses to ignore before start repeating */
454 #define RC_REPEAT_DELAY 2
455 #define RC_REPEAT_DELAY_V1_20 5
456
457
458
459 /* Used by firmware versions < 1.20 (deprecated) */
460 static int dib0700_rc_query_legacy(struct dvb_usb_device *d, u32 *event,
461                                    int *state)
462 {
463         u8 key[4];
464         int i;
465         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
466         struct dib0700_state *st = d->priv;
467         *event = 0;
468         *state = REMOTE_NO_KEY_PRESSED;
469         i=dib0700_ctrl_rd(d,rc_request,2,key,4);
470         if (i<=0) {
471                 err("RC Query Failed");
472                 return -1;
473         }
474
475         /* losing half of KEY_0 events from Philipps rc5 remotes.. */
476         if (key[0]==0 && key[1]==0 && key[2]==0 && key[3]==0) return 0;
477
478         /* 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]);  */
479
480         dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
481
482         switch (dvb_usb_dib0700_ir_proto) {
483         case 0: {
484                 /* NEC protocol sends repeat code as 0 0 0 FF */
485                 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
486                     (key[3] == 0xFF)) {
487                         st->rc_counter++;
488                         if (st->rc_counter > RC_REPEAT_DELAY) {
489                                 *event = d->last_event;
490                                 *state = REMOTE_KEY_PRESSED;
491                                 st->rc_counter = RC_REPEAT_DELAY;
492                         }
493                         return 0;
494                 }
495                 for (i=0;i<d->props.rc_key_map_size; i++) {
496                         if (keymap[i].custom == key[3-2] && keymap[i].data == key[3-3]) {
497                                 st->rc_counter = 0;
498                                 *event = keymap[i].event;
499                                 *state = REMOTE_KEY_PRESSED;
500                                 d->last_event = keymap[i].event;
501                                 return 0;
502                         }
503                 }
504                 break;
505         }
506         default: {
507                 /* RC-5 protocol changes toggle bit on new keypress */
508                 for (i = 0; i < d->props.rc_key_map_size; i++) {
509                         if (keymap[i].custom == key[3-2] && keymap[i].data == key[3-3]) {
510                                 if (d->last_event == keymap[i].event &&
511                                         key[3-1] == st->rc_toggle) {
512                                         st->rc_counter++;
513                                         /* prevents unwanted double hits */
514                                         if (st->rc_counter > RC_REPEAT_DELAY) {
515                                                 *event = d->last_event;
516                                                 *state = REMOTE_KEY_PRESSED;
517                                                 st->rc_counter = RC_REPEAT_DELAY;
518                                         }
519
520                                         return 0;
521                                 }
522                                 st->rc_counter = 0;
523                                 *event = keymap[i].event;
524                                 *state = REMOTE_KEY_PRESSED;
525                                 st->rc_toggle = key[3-1];
526                                 d->last_event = keymap[i].event;
527                                 return 0;
528                         }
529                 }
530                 break;
531         }
532         }
533         err("Unknown remote controller key: %2X %2X %2X %2X", (int) key[3-2], (int) key[3-3], (int) key[3-1], (int) key[3]);
534         d->last_event = 0;
535         return 0;
536 }
537
538 /* This is the structure of the RC response packet starting in firmware 1.20 */
539 struct dib0700_rc_response {
540         u8 report_id;
541         u8 data_state;
542         u8 system_msb;
543         u8 system_lsb;
544         u8 data;
545         u8 not_data;
546 };
547
548 /* This supports the new IR response format for firmware v1.20 */
549 static int dib0700_rc_query_v1_20(struct dvb_usb_device *d, u32 *event,
550                                   int *state)
551 {
552         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
553         struct dib0700_state *st = d->priv;
554         struct dib0700_rc_response poll_reply;
555         u8 buf[6];
556         int i;
557         int status;
558         int actlen;
559         int found = 0;
560
561         /* Set initial results in case we exit the function early */
562         *event = 0;
563         *state = REMOTE_NO_KEY_PRESSED;
564
565         /* Firmware v1.20 provides RC data via bulk endpoint 1 */
566         status = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev, 1), buf,
567                               sizeof(buf), &actlen, 50);
568         if (status < 0) {
569                 /* No data available (meaning no key press) */
570                 return 0;
571         }
572
573         if (actlen != sizeof(buf)) {
574                 /* We didn't get back the 6 byte message we expected */
575                 err("Unexpected RC response size [%d]", actlen);
576                 return -1;
577         }
578
579         poll_reply.report_id  = buf[0];
580         poll_reply.data_state = buf[1];
581         poll_reply.system_msb = buf[2];
582         poll_reply.system_lsb = buf[3];
583         poll_reply.data       = buf[4];
584         poll_reply.not_data   = buf[5];
585
586         /*
587         info("rid=%02x ds=%02x sm=%02x sl=%02x d=%02x nd=%02x\n",
588              poll_reply.report_id, poll_reply.data_state,
589              poll_reply.system_msb, poll_reply.system_lsb,
590              poll_reply.data, poll_reply.not_data);
591         */
592
593         if ((poll_reply.data + poll_reply.not_data) != 0xff) {
594                 /* Key failed integrity check */
595                 err("key failed integrity check: %02x %02x %02x %02x",
596                     poll_reply.system_msb, poll_reply.system_lsb,
597                     poll_reply.data, poll_reply.not_data);
598                 return -1;
599         }
600
601         /* Find the key in the map */
602         for (i = 0; i < d->props.rc_key_map_size; i++) {
603                 if (keymap[i].custom == poll_reply.system_lsb &&
604                     keymap[i].data == poll_reply.data) {
605                         *event = keymap[i].event;
606                         found = 1;
607                         break;
608                 }
609         }
610
611         if (found == 0) {
612                 err("Unknown remote controller key: %02x %02x %02x %02x",
613                     poll_reply.system_msb, poll_reply.system_lsb,
614                     poll_reply.data, poll_reply.not_data);
615                 d->last_event = 0;
616                 return 0;
617         }
618
619         if (poll_reply.data_state == 1) {
620                 /* New key hit */
621                 st->rc_counter = 0;
622                 *event = keymap[i].event;
623                 *state = REMOTE_KEY_PRESSED;
624                 d->last_event = keymap[i].event;
625         } else if (poll_reply.data_state == 2) {
626                 /* Key repeated */
627                 st->rc_counter++;
628
629                 /* prevents unwanted double hits */
630                 if (st->rc_counter > RC_REPEAT_DELAY_V1_20) {
631                         *event = d->last_event;
632                         *state = REMOTE_KEY_PRESSED;
633                         st->rc_counter = RC_REPEAT_DELAY_V1_20;
634                 }
635         } else {
636                 err("Unknown data state [%d]", poll_reply.data_state);
637         }
638
639         return 0;
640 }
641
642 static int dib0700_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
643 {
644         struct dib0700_state *st = d->priv;
645
646         /* Because some people may have improperly named firmware files,
647            let's figure out whether to use the new firmware call or the legacy
648            call based on the firmware version embedded in the file */
649         if (st->rc_func_version == 0) {
650                 u32 hwver, romver, ramver, fwtype;
651                 int ret = dib0700_get_version(d, &hwver, &romver, &ramver,
652                                               &fwtype);
653                 if (ret < 0) {
654                         err("Could not determine version info");
655                         return -1;
656                 }
657                 if (ramver < 0x10200)
658                         st->rc_func_version = 1;
659                 else
660                         st->rc_func_version = 2;
661         }
662
663         if (st->rc_func_version == 2)
664                 return dib0700_rc_query_v1_20(d, event, state);
665         else
666                 return dib0700_rc_query_legacy(d, event, state);
667 }
668
669 static struct dvb_usb_rc_key dib0700_rc_keys[] = {
670         /* Key codes for the tiny Pinnacle remote*/
671         { 0x07, 0x00, KEY_MUTE },
672         { 0x07, 0x01, KEY_MENU }, // Pinnacle logo
673         { 0x07, 0x39, KEY_POWER },
674         { 0x07, 0x03, KEY_VOLUMEUP },
675         { 0x07, 0x09, KEY_VOLUMEDOWN },
676         { 0x07, 0x06, KEY_CHANNELUP },
677         { 0x07, 0x0c, KEY_CHANNELDOWN },
678         { 0x07, 0x0f, KEY_1 },
679         { 0x07, 0x15, KEY_2 },
680         { 0x07, 0x10, KEY_3 },
681         { 0x07, 0x18, KEY_4 },
682         { 0x07, 0x1b, KEY_5 },
683         { 0x07, 0x1e, KEY_6 },
684         { 0x07, 0x11, KEY_7 },
685         { 0x07, 0x21, KEY_8 },
686         { 0x07, 0x12, KEY_9 },
687         { 0x07, 0x27, KEY_0 },
688         { 0x07, 0x24, KEY_SCREEN }, // 'Square' key
689         { 0x07, 0x2a, KEY_TEXT },   // 'T' key
690         { 0x07, 0x2d, KEY_REWIND },
691         { 0x07, 0x30, KEY_PLAY },
692         { 0x07, 0x33, KEY_FASTFORWARD },
693         { 0x07, 0x36, KEY_RECORD },
694         { 0x07, 0x3c, KEY_STOP },
695         { 0x07, 0x3f, KEY_CANCEL }, // '?' key
696         /* Key codes for the Terratec Cinergy DT XS Diversity, similar to cinergyT2.c */
697         { 0xeb, 0x01, KEY_POWER },
698         { 0xeb, 0x02, KEY_1 },
699         { 0xeb, 0x03, KEY_2 },
700         { 0xeb, 0x04, KEY_3 },
701         { 0xeb, 0x05, KEY_4 },
702         { 0xeb, 0x06, KEY_5 },
703         { 0xeb, 0x07, KEY_6 },
704         { 0xeb, 0x08, KEY_7 },
705         { 0xeb, 0x09, KEY_8 },
706         { 0xeb, 0x0a, KEY_9 },
707         { 0xeb, 0x0b, KEY_VIDEO },
708         { 0xeb, 0x0c, KEY_0 },
709         { 0xeb, 0x0d, KEY_REFRESH },
710         { 0xeb, 0x0f, KEY_EPG },
711         { 0xeb, 0x10, KEY_UP },
712         { 0xeb, 0x11, KEY_LEFT },
713         { 0xeb, 0x12, KEY_OK },
714         { 0xeb, 0x13, KEY_RIGHT },
715         { 0xeb, 0x14, KEY_DOWN },
716         { 0xeb, 0x16, KEY_INFO },
717         { 0xeb, 0x17, KEY_RED },
718         { 0xeb, 0x18, KEY_GREEN },
719         { 0xeb, 0x19, KEY_YELLOW },
720         { 0xeb, 0x1a, KEY_BLUE },
721         { 0xeb, 0x1b, KEY_CHANNELUP },
722         { 0xeb, 0x1c, KEY_VOLUMEUP },
723         { 0xeb, 0x1d, KEY_MUTE },
724         { 0xeb, 0x1e, KEY_VOLUMEDOWN },
725         { 0xeb, 0x1f, KEY_CHANNELDOWN },
726         { 0xeb, 0x40, KEY_PAUSE },
727         { 0xeb, 0x41, KEY_HOME },
728         { 0xeb, 0x42, KEY_MENU }, /* DVD Menu */
729         { 0xeb, 0x43, KEY_SUBTITLE },
730         { 0xeb, 0x44, KEY_TEXT }, /* Teletext */
731         { 0xeb, 0x45, KEY_DELETE },
732         { 0xeb, 0x46, KEY_TV },
733         { 0xeb, 0x47, KEY_DVD },
734         { 0xeb, 0x48, KEY_STOP },
735         { 0xeb, 0x49, KEY_VIDEO },
736         { 0xeb, 0x4a, KEY_AUDIO }, /* Music */
737         { 0xeb, 0x4b, KEY_SCREEN }, /* Pic */
738         { 0xeb, 0x4c, KEY_PLAY },
739         { 0xeb, 0x4d, KEY_BACK },
740         { 0xeb, 0x4e, KEY_REWIND },
741         { 0xeb, 0x4f, KEY_FASTFORWARD },
742         { 0xeb, 0x54, KEY_PREVIOUS },
743         { 0xeb, 0x58, KEY_RECORD },
744         { 0xeb, 0x5c, KEY_NEXT },
745
746         /* Key codes for the Haupauge WinTV Nova-TD, copied from nova-t-usb2.c (Nova-T USB2) */
747         { 0x1e, 0x00, KEY_0 },
748         { 0x1e, 0x01, KEY_1 },
749         { 0x1e, 0x02, KEY_2 },
750         { 0x1e, 0x03, KEY_3 },
751         { 0x1e, 0x04, KEY_4 },
752         { 0x1e, 0x05, KEY_5 },
753         { 0x1e, 0x06, KEY_6 },
754         { 0x1e, 0x07, KEY_7 },
755         { 0x1e, 0x08, KEY_8 },
756         { 0x1e, 0x09, KEY_9 },
757         { 0x1e, 0x0a, KEY_KPASTERISK },
758         { 0x1e, 0x0b, KEY_RED },
759         { 0x1e, 0x0c, KEY_RADIO },
760         { 0x1e, 0x0d, KEY_MENU },
761         { 0x1e, 0x0e, KEY_GRAVE }, /* # */
762         { 0x1e, 0x0f, KEY_MUTE },
763         { 0x1e, 0x10, KEY_VOLUMEUP },
764         { 0x1e, 0x11, KEY_VOLUMEDOWN },
765         { 0x1e, 0x12, KEY_CHANNEL },
766         { 0x1e, 0x14, KEY_UP },
767         { 0x1e, 0x15, KEY_DOWN },
768         { 0x1e, 0x16, KEY_LEFT },
769         { 0x1e, 0x17, KEY_RIGHT },
770         { 0x1e, 0x18, KEY_VIDEO },
771         { 0x1e, 0x19, KEY_AUDIO },
772         { 0x1e, 0x1a, KEY_MEDIA },
773         { 0x1e, 0x1b, KEY_EPG },
774         { 0x1e, 0x1c, KEY_TV },
775         { 0x1e, 0x1e, KEY_NEXT },
776         { 0x1e, 0x1f, KEY_BACK },
777         { 0x1e, 0x20, KEY_CHANNELUP },
778         { 0x1e, 0x21, KEY_CHANNELDOWN },
779         { 0x1e, 0x24, KEY_LAST }, /* Skip backwards */
780         { 0x1e, 0x25, KEY_OK },
781         { 0x1e, 0x29, KEY_BLUE},
782         { 0x1e, 0x2e, KEY_GREEN },
783         { 0x1e, 0x30, KEY_PAUSE },
784         { 0x1e, 0x32, KEY_REWIND },
785         { 0x1e, 0x34, KEY_FASTFORWARD },
786         { 0x1e, 0x35, KEY_PLAY },
787         { 0x1e, 0x36, KEY_STOP },
788         { 0x1e, 0x37, KEY_RECORD },
789         { 0x1e, 0x38, KEY_YELLOW },
790         { 0x1e, 0x3b, KEY_GOTO },
791         { 0x1e, 0x3d, KEY_POWER },
792
793         /* Key codes for the Leadtek Winfast DTV Dongle */
794         { 0x00, 0x42, KEY_POWER },
795         { 0x07, 0x7c, KEY_TUNER },
796         { 0x0f, 0x4e, KEY_PRINT }, /* PREVIEW */
797         { 0x08, 0x40, KEY_SCREEN }, /* full screen toggle*/
798         { 0x0f, 0x71, KEY_DOT }, /* frequency */
799         { 0x07, 0x43, KEY_0 },
800         { 0x0c, 0x41, KEY_1 },
801         { 0x04, 0x43, KEY_2 },
802         { 0x0b, 0x7f, KEY_3 },
803         { 0x0e, 0x41, KEY_4 },
804         { 0x06, 0x43, KEY_5 },
805         { 0x09, 0x7f, KEY_6 },
806         { 0x0d, 0x7e, KEY_7 },
807         { 0x05, 0x7c, KEY_8 },
808         { 0x0a, 0x40, KEY_9 },
809         { 0x0e, 0x4e, KEY_CLEAR },
810         { 0x04, 0x7c, KEY_CHANNEL }, /* show channel number */
811         { 0x0f, 0x41, KEY_LAST }, /* recall */
812         { 0x03, 0x42, KEY_MUTE },
813         { 0x06, 0x4c, KEY_RESERVED }, /* PIP button*/
814         { 0x01, 0x72, KEY_SHUFFLE }, /* SNAPSHOT */
815         { 0x0c, 0x4e, KEY_PLAYPAUSE }, /* TIMESHIFT */
816         { 0x0b, 0x70, KEY_RECORD },
817         { 0x03, 0x7d, KEY_VOLUMEUP },
818         { 0x01, 0x7d, KEY_VOLUMEDOWN },
819         { 0x02, 0x42, KEY_CHANNELUP },
820         { 0x00, 0x7d, KEY_CHANNELDOWN },
821
822         /* Key codes for Nova-TD "credit card" remote control. */
823         { 0x1d, 0x00, KEY_0 },
824         { 0x1d, 0x01, KEY_1 },
825         { 0x1d, 0x02, KEY_2 },
826         { 0x1d, 0x03, KEY_3 },
827         { 0x1d, 0x04, KEY_4 },
828         { 0x1d, 0x05, KEY_5 },
829         { 0x1d, 0x06, KEY_6 },
830         { 0x1d, 0x07, KEY_7 },
831         { 0x1d, 0x08, KEY_8 },
832         { 0x1d, 0x09, KEY_9 },
833         { 0x1d, 0x0a, KEY_TEXT },
834         { 0x1d, 0x0d, KEY_MENU },
835         { 0x1d, 0x0f, KEY_MUTE },
836         { 0x1d, 0x10, KEY_VOLUMEUP },
837         { 0x1d, 0x11, KEY_VOLUMEDOWN },
838         { 0x1d, 0x12, KEY_CHANNEL },
839         { 0x1d, 0x14, KEY_UP },
840         { 0x1d, 0x15, KEY_DOWN },
841         { 0x1d, 0x16, KEY_LEFT },
842         { 0x1d, 0x17, KEY_RIGHT },
843         { 0x1d, 0x1c, KEY_TV },
844         { 0x1d, 0x1e, KEY_NEXT },
845         { 0x1d, 0x1f, KEY_BACK },
846         { 0x1d, 0x20, KEY_CHANNELUP },
847         { 0x1d, 0x21, KEY_CHANNELDOWN },
848         { 0x1d, 0x24, KEY_LAST },
849         { 0x1d, 0x25, KEY_OK },
850         { 0x1d, 0x30, KEY_PAUSE },
851         { 0x1d, 0x32, KEY_REWIND },
852         { 0x1d, 0x34, KEY_FASTFORWARD },
853         { 0x1d, 0x35, KEY_PLAY },
854         { 0x1d, 0x36, KEY_STOP },
855         { 0x1d, 0x37, KEY_RECORD },
856         { 0x1d, 0x3b, KEY_GOTO },
857         { 0x1d, 0x3d, KEY_POWER },
858 };
859
860 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
861 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
862         BAND_UHF | BAND_VHF,       // band_caps
863
864         /* 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,
865          * 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 */
866         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
867
868         712,  // inv_gain
869         41,  // time_stabiliz
870
871         0,  // alpha_level
872         118,  // thlock
873
874         0,     // wbd_inv
875         4095,  // wbd_ref
876         0,     // wbd_sel
877         0,     // wbd_alpha
878
879         42598,  // agc1_max
880         17694,  // agc1_min
881         45875,  // agc2_max
882         2621,  // agc2_min
883         0,  // agc1_pt1
884         76,  // agc1_pt2
885         139,  // agc1_pt3
886         52,  // agc1_slope1
887         59,  // agc1_slope2
888         107,  // agc2_pt1
889         172,  // agc2_pt2
890         57,  // agc2_slope1
891         70,  // agc2_slope2
892
893         21,  // alpha_mant
894         25,  // alpha_exp
895         28,  // beta_mant
896         48,  // beta_exp
897
898         1,  // perform_agc_softsplit
899         {  0,     // split_min
900            107,   // split_max
901            51800, // global_split_min
902            24700  // global_split_max
903         },
904 };
905
906 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
907         BAND_UHF | BAND_VHF,
908
909         /* 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,
910          * 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 */
911         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), // setup
912
913         712, // inv_gain
914         41,  // time_stabiliz
915
916         0,   // alpha_level
917         118, // thlock
918
919         0,    // wbd_inv
920         4095, // wbd_ref
921         0,    // wbd_sel
922         0,    // wbd_alpha
923
924         42598, // agc1_max
925         16384, // agc1_min
926         42598, // agc2_max
927             0, // agc2_min
928
929           0,   // agc1_pt1
930         137,   // agc1_pt2
931         255,   // agc1_pt3
932
933           0,   // agc1_slope1
934         255,   // agc1_slope2
935
936         0,     // agc2_pt1
937         0,     // agc2_pt2
938
939          0,    // agc2_slope1
940         41,    // agc2_slope2
941
942         15, // alpha_mant
943         25, // alpha_exp
944
945         28, // beta_mant
946         48, // beta_exp
947
948         0, // perform_agc_softsplit
949 };
950
951 static struct dibx000_bandwidth_config stk7700p_pll_config = {
952         60000, 30000, // internal, sampling
953         1, 8, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
954         0, 0, 1, 1, 0, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
955         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
956         60258167, // ifreq
957         20452225, // timf
958         30000000, // xtal
959 };
960
961 static struct dib7000m_config stk7700p_dib7000m_config = {
962         .dvbt_mode = 1,
963         .output_mpeg2_in_188_bytes = 1,
964         .quartz_direct = 1,
965
966         .agc_config_count = 1,
967         .agc = &stk7700p_7000m_mt2060_agc_config,
968         .bw  = &stk7700p_pll_config,
969
970         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
971         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
972         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
973 };
974
975 static struct dib7000p_config stk7700p_dib7000p_config = {
976         .output_mpeg2_in_188_bytes = 1,
977
978         .agc_config_count = 1,
979         .agc = &stk7700p_7000p_mt2060_agc_config,
980         .bw  = &stk7700p_pll_config,
981
982         .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
983         .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
984         .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
985 };
986
987 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
988 {
989         struct dib0700_state *st = adap->dev->priv;
990         /* unless there is no real power management in DVB - we leave the device on GPIO6 */
991
992         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
993         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
994
995         dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
996         dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
997
998         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
999         dib0700_ctrl_clock(adap->dev, 72, 1);
1000         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
1001
1002         dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
1003
1004         st->mt2060_if1[0] = 1220;
1005
1006         if (dib7000pc_detection(&adap->dev->i2c_adap)) {
1007                 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
1008                 st->is_dib7000pc = 1;
1009         } else
1010                 adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
1011
1012         return adap->fe == NULL ? -ENODEV : 0;
1013 }
1014
1015 static struct mt2060_config stk7700p_mt2060_config = {
1016         0x60
1017 };
1018
1019 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
1020 {
1021         struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
1022         struct dib0700_state *st = adap->dev->priv;
1023         struct i2c_adapter *tun_i2c;
1024         s8 a;
1025         int if1=1220;
1026         if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
1027                 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
1028                 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
1029         }
1030         if (st->is_dib7000pc)
1031                 tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1032         else
1033                 tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1034
1035         return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
1036                 if1) == NULL ? -ENODEV : 0;
1037 }
1038
1039 /* DIB7070 generic */
1040 static struct dibx000_agc_config dib7070_agc_config = {
1041         BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1042         /* 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,
1043          * 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 */
1044         (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), // setup
1045
1046         600, // inv_gain
1047         10,  // time_stabiliz
1048
1049         0,  // alpha_level
1050         118,  // thlock
1051
1052         0,     // wbd_inv
1053         3530,  // wbd_ref
1054         1,     // wbd_sel
1055         5,     // wbd_alpha
1056
1057         65535,  // agc1_max
1058                 0,  // agc1_min
1059
1060         65535,  // agc2_max
1061         0,      // agc2_min
1062
1063         0,      // agc1_pt1
1064         40,     // agc1_pt2
1065         183,    // agc1_pt3
1066         206,    // agc1_slope1
1067         255,    // agc1_slope2
1068         72,     // agc2_pt1
1069         152,    // agc2_pt2
1070         88,     // agc2_slope1
1071         90,     // agc2_slope2
1072
1073         17,  // alpha_mant
1074         27,  // alpha_exp
1075         23,  // beta_mant
1076         51,  // beta_exp
1077
1078         0,  // perform_agc_softsplit
1079 };
1080
1081 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1082 {
1083         return dib7000p_set_gpio(fe, 8, 0, !onoff);
1084 }
1085
1086 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1087 {
1088         return dib7000p_set_gpio(fe, 9, 0, onoff);
1089 }
1090
1091 static struct dib0070_config dib7070p_dib0070_config[2] = {
1092         {
1093                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1094                 .reset = dib7070_tuner_reset,
1095                 .sleep = dib7070_tuner_sleep,
1096                 .clock_khz = 12000,
1097                 .clock_pad_drive = 4
1098         }, {
1099                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1100                 .reset = dib7070_tuner_reset,
1101                 .sleep = dib7070_tuner_sleep,
1102                 .clock_khz = 12000,
1103
1104         }
1105 };
1106
1107 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
1108 {
1109         struct dvb_usb_adapter *adap = fe->dvb->priv;
1110         struct dib0700_adapter_state *state = adap->priv;
1111
1112         u16 offset;
1113         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1114         switch (band) {
1115                 case BAND_VHF: offset = 950; break;
1116                 case BAND_UHF:
1117                 default: offset = 550; break;
1118         }
1119         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
1120         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1121         return state->set_param_save(fe, fep);
1122 }
1123
1124 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
1125 {
1126         struct dib0700_adapter_state *st = adap->priv;
1127         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1128
1129         if (adap->id == 0) {
1130                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
1131                         return -ENODEV;
1132         } else {
1133                 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
1134                         return -ENODEV;
1135         }
1136
1137         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1138         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1139         return 0;
1140 }
1141
1142 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1143         60000, 15000, // internal, sampling
1144         1, 20, 3, 1, 0, // pll_cfg: prediv, ratio, range, reset, bypass
1145         0, 0, 1, 1, 2, // misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc, modulo
1146         (3 << 14) | (1 << 12) | (524 << 0), // sad_cfg: refsel, sel, freq_15k
1147         (0 << 25) | 0, // ifreq = 0.000000 MHz
1148         20452225, // timf
1149         12000000, // xtal_hz
1150 };
1151
1152 static struct dib7000p_config dib7070p_dib7000p_config = {
1153         .output_mpeg2_in_188_bytes = 1,
1154
1155         .agc_config_count = 1,
1156         .agc = &dib7070_agc_config,
1157         .bw  = &dib7070_bw_config_12_mhz,
1158         .tuner_is_baseband = 1,
1159         .spur_protect = 1,
1160
1161         .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1162         .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1163         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1164
1165         .hostbus_diversity = 1,
1166 };
1167
1168 /* STK7070P */
1169 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
1170 {
1171         struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
1172         if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
1173             p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
1174                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1175         else
1176                 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1177         msleep(10);
1178         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1179         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1180         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1181         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1182
1183         dib0700_ctrl_clock(adap->dev, 72, 1);
1184
1185         msleep(10);
1186         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1187         msleep(10);
1188         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1189
1190         dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1191                 &dib7070p_dib7000p_config);
1192
1193         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1194                 &dib7070p_dib7000p_config);
1195         return adap->fe == NULL ? -ENODEV : 0;
1196 }
1197
1198 /* STK7070PD */
1199 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
1200         {
1201                 .output_mpeg2_in_188_bytes = 1,
1202
1203                 .agc_config_count = 1,
1204                 .agc = &dib7070_agc_config,
1205                 .bw  = &dib7070_bw_config_12_mhz,
1206                 .tuner_is_baseband = 1,
1207                 .spur_protect = 1,
1208
1209                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1210                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1211                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1212
1213                 .hostbus_diversity = 1,
1214         }, {
1215                 .output_mpeg2_in_188_bytes = 1,
1216
1217                 .agc_config_count = 1,
1218                 .agc = &dib7070_agc_config,
1219                 .bw  = &dib7070_bw_config_12_mhz,
1220                 .tuner_is_baseband = 1,
1221                 .spur_protect = 1,
1222
1223                 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1224                 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1225                 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1226
1227                 .hostbus_diversity = 1,
1228         }
1229 };
1230
1231 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
1232 {
1233         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1234         msleep(10);
1235         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1236         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1237         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1238         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1239
1240         dib0700_ctrl_clock(adap->dev, 72, 1);
1241
1242         msleep(10);
1243         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1244         msleep(10);
1245         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1246
1247         dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, stk7070pd_dib7000p_config);
1248
1249         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
1250         return adap->fe == NULL ? -ENODEV : 0;
1251 }
1252
1253 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
1254 {
1255         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
1256         return adap->fe == NULL ? -ENODEV : 0;
1257 }
1258
1259 /* S5H1411 */
1260 static struct s5h1411_config pinnacle_801e_config = {
1261         .output_mode   = S5H1411_PARALLEL_OUTPUT,
1262         .gpio          = S5H1411_GPIO_OFF,
1263         .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
1264         .qam_if        = S5H1411_IF_44000,
1265         .vsb_if        = S5H1411_IF_44000,
1266         .inversion     = S5H1411_INVERSION_OFF,
1267         .status_mode   = S5H1411_DEMODLOCKING
1268 };
1269
1270 /* Pinnacle PCTV HD Pro 801e GPIOs map:
1271    GPIO0  - currently unknown
1272    GPIO1  - xc5000 tuner reset
1273    GPIO2  - CX25843 sleep
1274    GPIO3  - currently unknown
1275    GPIO4  - currently unknown
1276    GPIO6  - currently unknown
1277    GPIO7  - currently unknown
1278    GPIO9  - currently unknown
1279    GPIO10 - CX25843 reset
1280  */
1281 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
1282 {
1283         struct dib0700_state *st = adap->dev->priv;
1284
1285         /* Make use of the new i2c functions from FW 1.20 */
1286         st->fw_use_new_i2c_api = 1;
1287
1288         /* The s5h1411 requires the dib0700 to not be in master mode */
1289         st->disable_streaming_master_mode = 1;
1290
1291         /* All msleep values taken from Windows USB trace */
1292         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
1293         dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
1294         dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1295         msleep(400);
1296         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1297         msleep(60);
1298         dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1299         msleep(30);
1300         dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1301         dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1302         dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1303         dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1304         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
1305         msleep(30);
1306
1307         /* Put the CX25843 to sleep for now since we're in digital mode */
1308         dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
1309
1310         /* GPIOs are initialized, do the attach */
1311         adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
1312                               &adap->dev->i2c_adap);
1313         return adap->fe == NULL ? -ENODEV : 0;
1314 }
1315
1316 static int dib0700_xc5000_tuner_callback(void *priv, int component,
1317                                          int command, int arg)
1318 {
1319         struct dvb_usb_adapter *adap = priv;
1320
1321         if (command == XC5000_TUNER_RESET) {
1322                 /* Reset the tuner */
1323                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
1324                 msleep(330); /* from Windows USB trace */
1325                 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
1326                 msleep(330); /* from Windows USB trace */
1327         } else {
1328                 err("xc5000: unknown tuner callback command: %d\n", command);
1329                 return -EINVAL;
1330         }
1331
1332         return 0;
1333 }
1334
1335 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
1336         .i2c_address      = 0x64,
1337         .if_khz           = 5380,
1338 };
1339
1340 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
1341 {
1342         /* FIXME: generalize & move to common area */
1343         adap->fe->callback = dib0700_xc5000_tuner_callback;
1344
1345         return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
1346                           &s5h1411_xc5000_tunerconfig)
1347                 == NULL ? -ENODEV : 0;
1348 }
1349
1350 /* DVB-USB and USB stuff follows */
1351 struct usb_device_id dib0700_usb_id_table[] = {
1352 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
1353         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
1354         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
1355         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
1356         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
1357 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
1358         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
1359         { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
1360         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
1361         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
1362 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
1363         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
1364         { USB_DEVICE(USB_VID_TERRATEC,
1365                         USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
1366         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
1367         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
1368 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
1369         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
1370         { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
1371         { USB_DEVICE(USB_VID_PINNACLE,
1372                         USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
1373         { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
1374 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
1375         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
1376         { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
1377         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
1378         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
1379 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
1380         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
1381         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
1382         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
1383         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
1384 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
1385         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
1386         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
1387         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
1388         { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
1389 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
1390         { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
1391         { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
1392         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
1393         { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
1394 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
1395         { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
1396         { 0 }           /* Terminating entry */
1397 };
1398 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
1399
1400 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
1401         .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
1402         .usb_ctrl          = DEVICE_SPECIFIC, \
1403         .firmware          = "dvb-usb-dib0700-1.20.fw", \
1404         .download_firmware = dib0700_download_firmware, \
1405         .no_reconnect      = 1, \
1406         .size_of_priv      = sizeof(struct dib0700_state), \
1407         .i2c_algo          = &dib0700_i2c_algo, \
1408         .identify_state    = dib0700_identify_state
1409
1410 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
1411         .streaming_ctrl   = dib0700_streaming_ctrl, \
1412         .stream = { \
1413                 .type = USB_BULK, \
1414                 .count = 4, \
1415                 .endpoint = ep, \
1416                 .u = { \
1417                         .bulk = { \
1418                                 .buffersize = 39480, \
1419                         } \
1420                 } \
1421         }
1422
1423 struct dvb_usb_device_properties dib0700_devices[] = {
1424         {
1425                 DIB0700_DEFAULT_DEVICE_PROPERTIES,
1426
1427                 .num_adapters = 1,
1428                 .adapter = {
1429                         {
1430                                 .frontend_attach  = stk7700p_frontend_attach,
1431                                 .tuner_attach     = stk7700p_tuner_attach,
1432
1433                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1434                         },
1435                 },
1436
1437                 .num_device_descs = 8,
1438                 .devices = {
1439                         {   "DiBcom STK7700P reference design",
1440                                 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
1441                                 { NULL },
1442                         },
1443                         {   "Hauppauge Nova-T Stick",
1444                                 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
1445                                 { NULL },
1446                         },
1447                         {   "AVerMedia AVerTV DVB-T Volar",
1448                                 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
1449                                 { NULL },
1450                         },
1451                         {   "Compro Videomate U500",
1452                                 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
1453                                 { NULL },
1454                         },
1455                         {   "Uniwill STK7700P based (Hama and others)",
1456                                 { &dib0700_usb_id_table[7], NULL },
1457                                 { NULL },
1458                         },
1459                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
1460                                 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
1461                                 { NULL },
1462                         },
1463                         {   "AVerMedia AVerTV DVB-T Express",
1464                                 { &dib0700_usb_id_table[20] },
1465                                 { NULL },
1466                         },
1467                         {   "Gigabyte U7000",
1468                                 { &dib0700_usb_id_table[21], NULL },
1469                                 { NULL },
1470                         }
1471                 },
1472
1473                 .rc_interval      = DEFAULT_RC_INTERVAL,
1474                 .rc_key_map       = dib0700_rc_keys,
1475                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1476                 .rc_query         = dib0700_rc_query
1477         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1478
1479                 .num_adapters = 2,
1480                 .adapter = {
1481                         {
1482                                 .frontend_attach  = bristol_frontend_attach,
1483                                 .tuner_attach     = bristol_tuner_attach,
1484
1485                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1486                         }, {
1487                                 .frontend_attach  = bristol_frontend_attach,
1488                                 .tuner_attach     = bristol_tuner_attach,
1489
1490                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1491                         }
1492                 },
1493
1494                 .num_device_descs = 1,
1495                 .devices = {
1496                         {   "Hauppauge Nova-T 500 Dual DVB-T",
1497                                 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
1498                                 { NULL },
1499                         },
1500                 },
1501
1502                 .rc_interval      = DEFAULT_RC_INTERVAL,
1503                 .rc_key_map       = dib0700_rc_keys,
1504                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1505                 .rc_query         = dib0700_rc_query
1506         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1507
1508                 .num_adapters = 2,
1509                 .adapter = {
1510                         {
1511                                 .frontend_attach  = stk7700d_frontend_attach,
1512                                 .tuner_attach     = stk7700d_tuner_attach,
1513
1514                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1515                         }, {
1516                                 .frontend_attach  = stk7700d_frontend_attach,
1517                                 .tuner_attach     = stk7700d_tuner_attach,
1518
1519                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1520                         }
1521                 },
1522
1523                 .num_device_descs = 4,
1524                 .devices = {
1525                         {   "Pinnacle PCTV 2000e",
1526                                 { &dib0700_usb_id_table[11], NULL },
1527                                 { NULL },
1528                         },
1529                         {   "Terratec Cinergy DT XS Diversity",
1530                                 { &dib0700_usb_id_table[12], NULL },
1531                                 { NULL },
1532                         },
1533                         {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
1534                                 { &dib0700_usb_id_table[13], NULL },
1535                                 { NULL },
1536                         },
1537                         {   "DiBcom STK7700D reference design",
1538                                 { &dib0700_usb_id_table[14], NULL },
1539                                 { NULL },
1540                         }
1541                 },
1542
1543                 .rc_interval      = DEFAULT_RC_INTERVAL,
1544                 .rc_key_map       = dib0700_rc_keys,
1545                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1546                 .rc_query         = dib0700_rc_query
1547
1548         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1549
1550                 .num_adapters = 1,
1551                 .adapter = {
1552                         {
1553                                 .frontend_attach  = stk7700P2_frontend_attach,
1554                                 .tuner_attach     = stk7700d_tuner_attach,
1555
1556                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1557                         },
1558                 },
1559
1560                 .num_device_descs = 2,
1561                 .devices = {
1562                         {   "ASUS My Cinema U3000 Mini DVBT Tuner",
1563                                 { &dib0700_usb_id_table[23], NULL },
1564                                 { NULL },
1565                         },
1566                         {   "Yuan EC372S",
1567                                 { &dib0700_usb_id_table[31], NULL },
1568                                 { NULL },
1569                         }
1570                 },
1571
1572                 .rc_interval      = DEFAULT_RC_INTERVAL,
1573                 .rc_key_map       = dib0700_rc_keys,
1574                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1575                 .rc_query         = dib0700_rc_query
1576         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1577
1578                 .num_adapters = 1,
1579                 .adapter = {
1580                         {
1581                                 .frontend_attach  = stk7070p_frontend_attach,
1582                                 .tuner_attach     = dib7070p_tuner_attach,
1583
1584                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1585
1586                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
1587                         },
1588                 },
1589
1590                 .num_device_descs = 9,
1591                 .devices = {
1592                         {   "DiBcom STK7070P reference design",
1593                                 { &dib0700_usb_id_table[15], NULL },
1594                                 { NULL },
1595                         },
1596                         {   "Pinnacle PCTV DVB-T Flash Stick",
1597                                 { &dib0700_usb_id_table[16], NULL },
1598                                 { NULL },
1599                         },
1600                         {   "Artec T14BR DVB-T",
1601                                 { &dib0700_usb_id_table[22], NULL },
1602                                 { NULL },
1603                         },
1604                         {   "ASUS My Cinema U3100 Mini DVBT Tuner",
1605                                 { &dib0700_usb_id_table[24], NULL },
1606                                 { NULL },
1607                         },
1608                         {   "Hauppauge Nova-T Stick",
1609                                 { &dib0700_usb_id_table[25], NULL },
1610                                 { NULL },
1611                         },
1612                         {   "Hauppauge Nova-T MyTV.t",
1613                                 { &dib0700_usb_id_table[26], NULL },
1614                                 { NULL },
1615                         },
1616                         {   "Pinnacle PCTV 72e",
1617                                 { &dib0700_usb_id_table[29], NULL },
1618                                 { NULL },
1619                         },
1620                         {   "Pinnacle PCTV 73e",
1621                                 { &dib0700_usb_id_table[30], NULL },
1622                                 { NULL },
1623                         },
1624                         {   "Terratec Cinergy T USB XXS",
1625                                 { &dib0700_usb_id_table[33], NULL },
1626                                 { NULL },
1627                         },
1628                 },
1629
1630                 .rc_interval      = DEFAULT_RC_INTERVAL,
1631                 .rc_key_map       = dib0700_rc_keys,
1632                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1633                 .rc_query         = dib0700_rc_query
1634
1635         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1636
1637                 .num_adapters = 2,
1638                 .adapter = {
1639                         {
1640                                 .frontend_attach  = stk7070pd_frontend_attach0,
1641                                 .tuner_attach     = dib7070p_tuner_attach,
1642
1643                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1644
1645                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
1646                         }, {
1647                                 .frontend_attach  = stk7070pd_frontend_attach1,
1648                                 .tuner_attach     = dib7070p_tuner_attach,
1649
1650                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
1651
1652                                 .size_of_priv     = sizeof(struct dib0700_adapter_state),
1653                         }
1654                 },
1655
1656                 .num_device_descs = 4,
1657                 .devices = {
1658                         {   "DiBcom STK7070PD reference design",
1659                                 { &dib0700_usb_id_table[17], NULL },
1660                                 { NULL },
1661                         },
1662                         {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
1663                                 { &dib0700_usb_id_table[18], NULL },
1664                                 { NULL },
1665                         },
1666                         {   "Hauppauge Nova-TD Stick (52009)",
1667                                 { &dib0700_usb_id_table[35], NULL },
1668                                 { NULL },
1669                         },
1670                         {   "Hauppauge Nova-TD-500 (84xxx)",
1671                                 { &dib0700_usb_id_table[36], NULL },
1672                                 { NULL },
1673                         }
1674                 }
1675         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1676
1677                 .num_adapters = 1,
1678                 .adapter = {
1679                         {
1680                                 .frontend_attach  = stk7700ph_frontend_attach,
1681                                 .tuner_attach     = stk7700ph_tuner_attach,
1682
1683                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1684
1685                                 .size_of_priv = sizeof(struct
1686                                                 dib0700_adapter_state),
1687                         },
1688                 },
1689
1690                 .num_device_descs = 5,
1691                 .devices = {
1692                         {   "Terratec Cinergy HT USB XE",
1693                                 { &dib0700_usb_id_table[27], NULL },
1694                                 { NULL },
1695                         },
1696                         {   "Pinnacle Expresscard 320cx",
1697                                 { &dib0700_usb_id_table[28], NULL },
1698                                 { NULL },
1699                         },
1700                         {   "Terratec Cinergy HT Express",
1701                                 { &dib0700_usb_id_table[32], NULL },
1702                                 { NULL },
1703                         },
1704                         {   "Gigabyte U8000-RH",
1705                                 { &dib0700_usb_id_table[37], NULL },
1706                                 { NULL },
1707                         },
1708                         {   "YUAN High-Tech STK7700PH",
1709                                 { &dib0700_usb_id_table[38], NULL },
1710                                 { NULL },
1711                         },
1712                         {   "Asus My Cinema-U3000Hybrid",
1713                                 { &dib0700_usb_id_table[39], NULL },
1714                                 { NULL },
1715                         },
1716                 },
1717                 .rc_interval      = DEFAULT_RC_INTERVAL,
1718                 .rc_key_map       = dib0700_rc_keys,
1719                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1720                 .rc_query         = dib0700_rc_query
1721         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
1722                 .num_adapters = 1,
1723                 .adapter = {
1724                         {
1725                                 .frontend_attach  = s5h1411_frontend_attach,
1726                                 .tuner_attach     = xc5000_tuner_attach,
1727
1728                                 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
1729
1730                                 .size_of_priv = sizeof(struct
1731                                                 dib0700_adapter_state),
1732                         },
1733                 },
1734
1735                 .num_device_descs = 2,
1736                 .devices = {
1737                         {   "Pinnacle PCTV HD Pro USB Stick",
1738                                 { &dib0700_usb_id_table[40], NULL },
1739                                 { NULL },
1740                         },
1741                         {   "Pinnacle PCTV HD USB Stick",
1742                                 { &dib0700_usb_id_table[41], NULL },
1743                                 { NULL },
1744                         },
1745                 },
1746                 .rc_interval      = DEFAULT_RC_INTERVAL,
1747                 .rc_key_map       = dib0700_rc_keys,
1748                 .rc_key_map_size  = ARRAY_SIZE(dib0700_rc_keys),
1749                 .rc_query         = dib0700_rc_query
1750         },
1751 };
1752
1753 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);