projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cfq-iosched: fix use-after-free of cfqq
[deliverable/linux.git] / drivers / media / dvb / dvb-usb / dib0700_devices.c
1 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
2 *
3 * This program is free software; you can redistribute it and/or modify it
4 * under the terms of the GNU General Public License as published by the Free
5 * Software Foundation, version 2.
6 *
7 * Copyright (C) 2005-9 DiBcom, SA et al
8 */
9 #include "dib0700.h"
10
11 #include "dib3000mc.h"
12 #include "dib7000m.h"
13 #include "dib7000p.h"
14 #include "dib8000.h"
15 #include "dib9000.h"
16 #include "mt2060.h"
17 #include "mt2266.h"
18 #include "tuner-xc2028.h"
19 #include "xc5000.h"
20 #include "xc4000.h"
21 #include "s5h1411.h"
22 #include "dib0070.h"
23 #include "dib0090.h"
24 #include "lgdt3305.h"
25 #include "mxl5007t.h"
26
27 static int force_lna_activation;
28 module_param(force_lna_activation, int, 0644);
29 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
30 "if applicable for the device (default: 0=automatic/off).");
31
32 struct dib0700_adapter_state {
33 int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
34 const struct firmware *frontend_firmware;
35 };
36
37 /* Hauppauge Nova-T 500 (aka Bristol)
38 * has a LNA on GPIO0 which is enabled by setting 1 */
39 static struct mt2060_config bristol_mt2060_config[2] = {
40 {
41 .i2c_address = 0x60,
42 .clock_out = 3,
43 }, {
44 .i2c_address = 0x61,
45 }
46 };
47
48
49 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
50 .band_caps = BAND_VHF | BAND_UHF,
51 .setup = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
52
53 .agc1_max = 42598,
54 .agc1_min = 17694,
55 .agc2_max = 45875,
56 .agc2_min = 0,
57
58 .agc1_pt1 = 0,
59 .agc1_pt2 = 59,
60
61 .agc1_slope1 = 0,
62 .agc1_slope2 = 69,
63
64 .agc2_pt1 = 0,
65 .agc2_pt2 = 59,
66
67 .agc2_slope1 = 111,
68 .agc2_slope2 = 28,
69 };
70
71 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
72 { .agc = &bristol_dib3000p_mt2060_agc_config,
73 .max_time = 0x196,
74 .ln_adc_level = 0x1cc7,
75 .output_mpeg2_in_188_bytes = 1,
76 },
77 { .agc = &bristol_dib3000p_mt2060_agc_config,
78 .max_time = 0x196,
79 .ln_adc_level = 0x1cc7,
80 .output_mpeg2_in_188_bytes = 1,
81 }
82 };
83
84 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
85 {
86 struct dib0700_state *st = adap->dev->priv;
87 if (adap->id == 0) {
88 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
89 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
90 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
91 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
92
93 if (force_lna_activation)
94 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
95 else
96 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
97
98 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
99 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
100 return -ENODEV;
101 }
102 }
103 st->mt2060_if1[adap->id] = 1220;
104 return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
105 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
106 }
107
108 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
109 {
110 struct i2c_msg msg[2] = {
111 { .addr = 0x50, .flags = 0, .buf = &adrs, .len = 1 },
112 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval, .len = 1 },
113 };
114 if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
115 return 0;
116 }
117
118 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
119 {
120 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
121 struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
122 s8 a;
123 int if1=1220;
124 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
125 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
126 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
127 }
128 return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
129 &bristol_mt2060_config[adap->id], if1) == NULL ?
130 -ENODEV : 0;
131 }
132
133 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
134
135 /* MT226x */
136 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
137 {
138 BAND_UHF,
139
140 /* 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,
141 * 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 */
142 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
143 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
144
145 1130,
146 21,
147
148 0,
149 118,
150
151 0,
152 3530,
153 1,
154 0,
155
156 65535,
157 33770,
158 65535,
159 23592,
160
161 0,
162 62,
163 255,
164 64,
165 64,
166 132,
167 192,
168 80,
169 80,
170
171 17,
172 27,
173 23,
174 51,
175
176 1,
177 }, {
178 BAND_VHF | BAND_LBAND,
179
180 /* 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,
181 * 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 */
182 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
183 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
184
185 2372,
186 21,
187
188 0,
189 118,
190
191 0,
192 3530,
193 1,
194 0,
195
196 65535,
197 0,
198 65535,
199 23592,
200
201 0,
202 128,
203 128,
204 128,
205 0,
206 128,
207 253,
208 81,
209 0,
210
211 17,
212 27,
213 23,
214 51,
215
216 1,
217 }
218 };
219
220 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
221 60000, 30000,
222 1, 8, 3, 1, 0,
223 0, 0, 1, 1, 2,
224 (3 << 14) | (1 << 12) | (524 << 0),
225 0,
226 20452225,
227 };
228
229 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
230 { .output_mpeg2_in_188_bytes = 1,
231 .hostbus_diversity = 1,
232 .tuner_is_baseband = 1,
233
234 .agc_config_count = 2,
235 .agc = stk7700d_7000p_mt2266_agc_config,
236 .bw = &stk7700d_mt2266_pll_config,
237
238 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
239 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
240 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
241 },
242 { .output_mpeg2_in_188_bytes = 1,
243 .hostbus_diversity = 1,
244 .tuner_is_baseband = 1,
245
246 .agc_config_count = 2,
247 .agc = stk7700d_7000p_mt2266_agc_config,
248 .bw = &stk7700d_mt2266_pll_config,
249
250 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
251 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
252 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
253 }
254 };
255
256 static struct mt2266_config stk7700d_mt2266_config[2] = {
257 { .i2c_address = 0x60
258 },
259 { .i2c_address = 0x60
260 }
261 };
262
263 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
264 {
265 if (adap->id == 0) {
266 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
267 msleep(10);
268 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
269 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
270 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
271 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
272 msleep(10);
273 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
274 msleep(10);
275 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
276 stk7700d_dib7000p_mt2266_config)
277 != 0) {
278 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
279 return -ENODEV;
280 }
281 }
282
283 adap->fe_adap[0].fe =
284 dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
285 0x80 + (adap->id << 1),
286 &stk7700d_dib7000p_mt2266_config[adap->id]);
287
288 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
289 }
290
291 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
292 {
293 if (adap->id == 0) {
294 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
295 msleep(10);
296 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
297 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
298 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
299 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
300 msleep(10);
301 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
302 msleep(10);
303 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
304 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
305 stk7700d_dib7000p_mt2266_config)
306 != 0) {
307 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
308 return -ENODEV;
309 }
310 }
311
312 adap->fe_adap[0].fe =
313 dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
314 0x80 + (adap->id << 1),
315 &stk7700d_dib7000p_mt2266_config[adap->id]);
316
317 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
318 }
319
320 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
321 {
322 struct i2c_adapter *tun_i2c;
323 tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
324 return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
325 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
326 }
327
328 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
329 static struct dibx000_agc_config xc3028_agc_config = {
330 BAND_VHF | BAND_UHF, /* band_caps */
331
332 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
333 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
334 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
335 (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
336 (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
337
338 712, /* inv_gain */
339 21, /* time_stabiliz */
340
341 0, /* alpha_level */
342 118, /* thlock */
343
344 0, /* wbd_inv */
345 2867, /* wbd_ref */
346 0, /* wbd_sel */
347 2, /* wbd_alpha */
348
349 0, /* agc1_max */
350 0, /* agc1_min */
351 39718, /* agc2_max */
352 9930, /* agc2_min */
353 0, /* agc1_pt1 */
354 0, /* agc1_pt2 */
355 0, /* agc1_pt3 */
356 0, /* agc1_slope1 */
357 0, /* agc1_slope2 */
358 0, /* agc2_pt1 */
359 128, /* agc2_pt2 */
360 29, /* agc2_slope1 */
361 29, /* agc2_slope2 */
362
363 17, /* alpha_mant */
364 27, /* alpha_exp */
365 23, /* beta_mant */
366 51, /* beta_exp */
367
368 1, /* perform_agc_softsplit */
369 };
370
371 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
372 static struct dibx000_bandwidth_config xc3028_bw_config = {
373 60000, 30000, /* internal, sampling */
374 1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
375 0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
376 modulo */
377 (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
378 (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
379 20452225, /* timf */
380 30000000, /* xtal_hz */
381 };
382
383 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
384 .output_mpeg2_in_188_bytes = 1,
385 .tuner_is_baseband = 1,
386
387 .agc_config_count = 1,
388 .agc = &xc3028_agc_config,
389 .bw = &xc3028_bw_config,
390
391 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
392 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
393 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
394 };
395
396 static int stk7700ph_xc3028_callback(void *ptr, int component,
397 int command, int arg)
398 {
399 struct dvb_usb_adapter *adap = ptr;
400
401 switch (command) {
402 case XC2028_TUNER_RESET:
403 /* Send the tuner in then out of reset */
404 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 0); msleep(10);
405 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
406 break;
407 case XC2028_RESET_CLK:
408 break;
409 default:
410 err("%s: unknown command %d, arg %d\n", __func__,
411 command, arg);
412 return -EINVAL;
413 }
414 return 0;
415 }
416
417 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
418 .fname = XC2028_DEFAULT_FIRMWARE,
419 .max_len = 64,
420 .demod = XC3028_FE_DIBCOM52,
421 };
422
423 static struct xc2028_config stk7700ph_xc3028_config = {
424 .i2c_addr = 0x61,
425 .ctrl = &stk7700ph_xc3028_ctrl,
426 };
427
428 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
429 {
430 struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
431
432 if (desc->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
433 desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
434 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
435 else
436 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
437 msleep(20);
438 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
439 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
440 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
441 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
442 msleep(10);
443 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
444 msleep(20);
445 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
446 msleep(10);
447
448 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
449 &stk7700ph_dib7700_xc3028_config) != 0) {
450 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
451 __func__);
452 return -ENODEV;
453 }
454
455 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
456 &stk7700ph_dib7700_xc3028_config);
457
458 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
459 }
460
461 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
462 {
463 struct i2c_adapter *tun_i2c;
464
465 tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
466 DIBX000_I2C_INTERFACE_TUNER, 1);
467
468 stk7700ph_xc3028_config.i2c_adap = tun_i2c;
469
470 /* FIXME: generalize & move to common area */
471 adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback;
472
473 return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config)
474 == NULL ? -ENODEV : 0;
475 }
476
477 #define DEFAULT_RC_INTERVAL 50
478
479 static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
480
481 /* Number of keypresses to ignore before start repeating */
482 #define RC_REPEAT_DELAY 6
483
484 /*
485 * This function is used only when firmware is < 1.20 version. Newer
486 * firmwares use bulk mode, with functions implemented at dib0700_core,
487 * at dib0700_rc_urb_completion()
488 */
489 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
490 {
491 u8 key[4];
492 u32 keycode;
493 u8 toggle;
494 int i;
495 struct dib0700_state *st = d->priv;
496
497 if (st->fw_version >= 0x10200) {
498 /* For 1.20 firmware , We need to keep the RC polling
499 callback so we can reuse the input device setup in
500 dvb-usb-remote.c. However, the actual work is being done
501 in the bulk URB completion handler. */
502 return 0;
503 }
504
505 i = dib0700_ctrl_rd(d, rc_request, 2, key, 4);
506 if (i <= 0) {
507 err("RC Query Failed");
508 return -1;
509 }
510
511 /* losing half of KEY_0 events from Philipps rc5 remotes.. */
512 if (key[0] == 0 && key[1] == 0 && key[2] == 0 && key[3] == 0)
513 return 0;
514
515 /* 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]); */
516
517 dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
518
519 d->last_event = 0;
520 switch (d->props.rc.core.protocol) {
521 case RC_TYPE_NEC:
522 /* NEC protocol sends repeat code as 0 0 0 FF */
523 if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
524 (key[3] == 0xff))
525 keycode = d->last_event;
526 else {
527 keycode = key[3-2] << 8 | key[3-3];
528 d->last_event = keycode;
529 }
530
531 rc_keydown(d->rc_dev, keycode, 0);
532 break;
533 default:
534 /* RC-5 protocol changes toggle bit on new keypress */
535 keycode = key[3-2] << 8 | key[3-3];
536 toggle = key[3-1];
537 rc_keydown(d->rc_dev, keycode, toggle);
538
539 break;
540 }
541 return 0;
542 }
543
544 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
545 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
546 BAND_UHF | BAND_VHF,
547
548 /* 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,
549 * 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 */
550 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
551 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
552
553 712,
554 41,
555
556 0,
557 118,
558
559 0,
560 4095,
561 0,
562 0,
563
564 42598,
565 17694,
566 45875,
567 2621,
568 0,
569 76,
570 139,
571 52,
572 59,
573 107,
574 172,
575 57,
576 70,
577
578 21,
579 25,
580 28,
581 48,
582
583 1,
584 { 0,
585 107,
586 51800,
587 24700
588 },
589 };
590
591 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
592 BAND_UHF | BAND_VHF,
593
594 /* 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,
595 * 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 */
596 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
597 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
598
599 712,
600 41,
601
602 0,
603 118,
604
605 0,
606 4095,
607 0,
608 0,
609
610 42598,
611 16384,
612 42598,
613 0,
614
615 0,
616 137,
617 255,
618
619 0,
620 255,
621
622 0,
623 0,
624
625 0,
626 41,
627
628 15,
629 25,
630
631 28,
632 48,
633
634 0,
635 };
636
637 static struct dibx000_bandwidth_config stk7700p_pll_config = {
638 60000, 30000,
639 1, 8, 3, 1, 0,
640 0, 0, 1, 1, 0,
641 (3 << 14) | (1 << 12) | (524 << 0),
642 60258167,
643 20452225,
644 30000000,
645 };
646
647 static struct dib7000m_config stk7700p_dib7000m_config = {
648 .dvbt_mode = 1,
649 .output_mpeg2_in_188_bytes = 1,
650 .quartz_direct = 1,
651
652 .agc_config_count = 1,
653 .agc = &stk7700p_7000m_mt2060_agc_config,
654 .bw = &stk7700p_pll_config,
655
656 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
657 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
658 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
659 };
660
661 static struct dib7000p_config stk7700p_dib7000p_config = {
662 .output_mpeg2_in_188_bytes = 1,
663
664 .agc_config_count = 1,
665 .agc = &stk7700p_7000p_mt2060_agc_config,
666 .bw = &stk7700p_pll_config,
667
668 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
669 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
670 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
671 };
672
673 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
674 {
675 struct dib0700_state *st = adap->dev->priv;
676 /* unless there is no real power management in DVB - we leave the device on GPIO6 */
677
678 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
679 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(50);
680
681 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
682 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
683
684 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
685 dib0700_ctrl_clock(adap->dev, 72, 1);
686 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
687
688 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
689
690 st->mt2060_if1[0] = 1220;
691
692 if (dib7000pc_detection(&adap->dev->i2c_adap)) {
693 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
694 st->is_dib7000pc = 1;
695 } else
696 adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
697
698 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
699 }
700
701 static struct mt2060_config stk7700p_mt2060_config = {
702 0x60
703 };
704
705 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
706 {
707 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
708 struct dib0700_state *st = adap->dev->priv;
709 struct i2c_adapter *tun_i2c;
710 s8 a;
711 int if1=1220;
712 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
713 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
714 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
715 }
716 if (st->is_dib7000pc)
717 tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
718 else
719 tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
720
721 return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config,
722 if1) == NULL ? -ENODEV : 0;
723 }
724
725 /* DIB7070 generic */
726 static struct dibx000_agc_config dib7070_agc_config = {
727 BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
728 /* 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,
729 * 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 */
730 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
731 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
732
733 600,
734 10,
735
736 0,
737 118,
738
739 0,
740 3530,
741 1,
742 5,
743
744 65535,
745 0,
746
747 65535,
748 0,
749
750 0,
751 40,
752 183,
753 206,
754 255,
755 72,
756 152,
757 88,
758 90,
759
760 17,
761 27,
762 23,
763 51,
764
765 0,
766 };
767
768 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
769 {
770 deb_info("reset: %d", onoff);
771 return dib7000p_set_gpio(fe, 8, 0, !onoff);
772 }
773
774 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
775 {
776 deb_info("sleep: %d", onoff);
777 return dib7000p_set_gpio(fe, 9, 0, onoff);
778 }
779
780 static struct dib0070_config dib7070p_dib0070_config[2] = {
781 {
782 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
783 .reset = dib7070_tuner_reset,
784 .sleep = dib7070_tuner_sleep,
785 .clock_khz = 12000,
786 .clock_pad_drive = 4,
787 .charge_pump = 2,
788 }, {
789 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
790 .reset = dib7070_tuner_reset,
791 .sleep = dib7070_tuner_sleep,
792 .clock_khz = 12000,
793 .charge_pump = 2,
794 }
795 };
796
797 static struct dib0070_config dib7770p_dib0070_config = {
798 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
799 .reset = dib7070_tuner_reset,
800 .sleep = dib7070_tuner_sleep,
801 .clock_khz = 12000,
802 .clock_pad_drive = 0,
803 .flip_chip = 1,
804 .charge_pump = 2,
805 };
806
807 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
808 {
809 struct dvb_usb_adapter *adap = fe->dvb->priv;
810 struct dib0700_adapter_state *state = adap->priv;
811
812 u16 offset;
813 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
814 switch (band) {
815 case BAND_VHF: offset = 950; break;
816 case BAND_UHF:
817 default: offset = 550; break;
818 }
819 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
820 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
821 return state->set_param_save(fe, fep);
822 }
823
824 static int dib7770_set_param_override(struct dvb_frontend *fe,
825 struct dvb_frontend_parameters *fep)
826 {
827 struct dvb_usb_adapter *adap = fe->dvb->priv;
828 struct dib0700_adapter_state *state = adap->priv;
829
830 u16 offset;
831 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
832 switch (band) {
833 case BAND_VHF:
834 dib7000p_set_gpio(fe, 0, 0, 1);
835 offset = 850;
836 break;
837 case BAND_UHF:
838 default:
839 dib7000p_set_gpio(fe, 0, 0, 0);
840 offset = 250;
841 break;
842 }
843 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
844 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
845 return state->set_param_save(fe, fep);
846 }
847
848 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
849 {
850 struct dib0700_adapter_state *st = adap->priv;
851 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
852 DIBX000_I2C_INTERFACE_TUNER, 1);
853
854 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
855 &dib7770p_dib0070_config) == NULL)
856 return -ENODEV;
857
858 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
859 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
860 return 0;
861 }
862
863 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
864 {
865 struct dib0700_adapter_state *st = adap->priv;
866 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
867
868 if (adap->id == 0) {
869 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
870 return -ENODEV;
871 } else {
872 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
873 return -ENODEV;
874 }
875
876 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
877 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
878 return 0;
879 }
880
881 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
882 u16 pid, int onoff)
883 {
884 struct dib0700_state *st = adapter->dev->priv;
885 if (st->is_dib7000pc)
886 return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
887 return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
888 }
889
890 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
891 {
892 struct dib0700_state *st = adapter->dev->priv;
893 if (st->is_dib7000pc)
894 return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
895 return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
896 }
897
898 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
899 {
900 return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
901 }
902
903 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
904 {
905 return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
906 }
907
908 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
909 60000, 15000,
910 1, 20, 3, 1, 0,
911 0, 0, 1, 1, 2,
912 (3 << 14) | (1 << 12) | (524 << 0),
913 (0 << 25) | 0,
914 20452225,
915 12000000,
916 };
917
918 static struct dib7000p_config dib7070p_dib7000p_config = {
919 .output_mpeg2_in_188_bytes = 1,
920
921 .agc_config_count = 1,
922 .agc = &dib7070_agc_config,
923 .bw = &dib7070_bw_config_12_mhz,
924 .tuner_is_baseband = 1,
925 .spur_protect = 1,
926
927 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
928 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
929 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
930
931 .hostbus_diversity = 1,
932 };
933
934 /* STK7070P */
935 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
936 {
937 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
938 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
939 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
940 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
941 else
942 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
943 msleep(10);
944 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
945 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
946 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
947 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
948
949 dib0700_ctrl_clock(adap->dev, 72, 1);
950
951 msleep(10);
952 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
953 msleep(10);
954 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
955
956 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
957 &dib7070p_dib7000p_config) != 0) {
958 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
959 __func__);
960 return -ENODEV;
961 }
962
963 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
964 &dib7070p_dib7000p_config);
965 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
966 }
967
968 /* STK7770P */
969 static struct dib7000p_config dib7770p_dib7000p_config = {
970 .output_mpeg2_in_188_bytes = 1,
971
972 .agc_config_count = 1,
973 .agc = &dib7070_agc_config,
974 .bw = &dib7070_bw_config_12_mhz,
975 .tuner_is_baseband = 1,
976 .spur_protect = 1,
977
978 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
979 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
980 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
981
982 .hostbus_diversity = 1,
983 .enable_current_mirror = 1,
984 .disable_sample_and_hold = 0,
985 };
986
987 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
988 {
989 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
990 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
991 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
992 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
993 else
994 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
995 msleep(10);
996 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
997 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
998 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
999 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1000
1001 dib0700_ctrl_clock(adap->dev, 72, 1);
1002
1003 msleep(10);
1004 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1005 msleep(10);
1006 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1007
1008 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1009 &dib7770p_dib7000p_config) != 0) {
1010 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
1011 __func__);
1012 return -ENODEV;
1013 }
1014
1015 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1016 &dib7770p_dib7000p_config);
1017 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1018 }
1019
1020 /* DIB807x generic */
1021 static struct dibx000_agc_config dib807x_agc_config[2] = {
1022 {
1023 BAND_VHF,
1024 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1025 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1026 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1027 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1028 * P_agc_write=0 */
1029 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1030 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1031 (0 << 0), /* setup*/
1032
1033 600, /* inv_gain*/
1034 10, /* time_stabiliz*/
1035
1036 0, /* alpha_level*/
1037 118, /* thlock*/
1038
1039 0, /* wbd_inv*/
1040 3530, /* wbd_ref*/
1041 1, /* wbd_sel*/
1042 5, /* wbd_alpha*/
1043
1044 65535, /* agc1_max*/
1045 0, /* agc1_min*/
1046
1047 65535, /* agc2_max*/
1048 0, /* agc2_min*/
1049
1050 0, /* agc1_pt1*/
1051 40, /* agc1_pt2*/
1052 183, /* agc1_pt3*/
1053 206, /* agc1_slope1*/
1054 255, /* agc1_slope2*/
1055 72, /* agc2_pt1*/
1056 152, /* agc2_pt2*/
1057 88, /* agc2_slope1*/
1058 90, /* agc2_slope2*/
1059
1060 17, /* alpha_mant*/
1061 27, /* alpha_exp*/
1062 23, /* beta_mant*/
1063 51, /* beta_exp*/
1064
1065 0, /* perform_agc_softsplit*/
1066 }, {
1067 BAND_UHF,
1068 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1069 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1070 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1071 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1072 * P_agc_write=0 */
1073 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1074 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1075 (0 << 0), /* setup */
1076
1077 600, /* inv_gain*/
1078 10, /* time_stabiliz*/
1079
1080 0, /* alpha_level*/
1081 118, /* thlock*/
1082
1083 0, /* wbd_inv*/
1084 3530, /* wbd_ref*/
1085 1, /* wbd_sel*/
1086 5, /* wbd_alpha*/
1087
1088 65535, /* agc1_max*/
1089 0, /* agc1_min*/
1090
1091 65535, /* agc2_max*/
1092 0, /* agc2_min*/
1093
1094 0, /* agc1_pt1*/
1095 40, /* agc1_pt2*/
1096 183, /* agc1_pt3*/
1097 206, /* agc1_slope1*/
1098 255, /* agc1_slope2*/
1099 72, /* agc2_pt1*/
1100 152, /* agc2_pt2*/
1101 88, /* agc2_slope1*/
1102 90, /* agc2_slope2*/
1103
1104 17, /* alpha_mant*/
1105 27, /* alpha_exp*/
1106 23, /* beta_mant*/
1107 51, /* beta_exp*/
1108
1109 0, /* perform_agc_softsplit*/
1110 }
1111 };
1112
1113 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1114 60000, 15000, /* internal, sampling*/
1115 1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1116 0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1117 ADClkSrc, modulo */
1118 (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1119 (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1120 18179755, /* timf*/
1121 12000000, /* xtal_hz*/
1122 };
1123
1124 static struct dib8000_config dib807x_dib8000_config[2] = {
1125 {
1126 .output_mpeg2_in_188_bytes = 1,
1127
1128 .agc_config_count = 2,
1129 .agc = dib807x_agc_config,
1130 .pll = &dib807x_bw_config_12_mhz,
1131 .tuner_is_baseband = 1,
1132
1133 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1134 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1135 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1136
1137 .hostbus_diversity = 1,
1138 .div_cfg = 1,
1139 .agc_control = &dib0070_ctrl_agc_filter,
1140 .output_mode = OUTMODE_MPEG2_FIFO,
1141 .drives = 0x2d98,
1142 }, {
1143 .output_mpeg2_in_188_bytes = 1,
1144
1145 .agc_config_count = 2,
1146 .agc = dib807x_agc_config,
1147 .pll = &dib807x_bw_config_12_mhz,
1148 .tuner_is_baseband = 1,
1149
1150 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1151 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1152 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1153
1154 .hostbus_diversity = 1,
1155 .agc_control = &dib0070_ctrl_agc_filter,
1156 .output_mode = OUTMODE_MPEG2_FIFO,
1157 .drives = 0x2d98,
1158 }
1159 };
1160
1161 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1162 {
1163 return dib8000_set_gpio(fe, 5, 0, !onoff);
1164 }
1165
1166 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1167 {
1168 return dib8000_set_gpio(fe, 0, 0, onoff);
1169 }
1170
1171 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1172 { 240, 7},
1173 { 0xffff, 6},
1174 };
1175
1176 static struct dib0070_config dib807x_dib0070_config[2] = {
1177 {
1178 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1179 .reset = dib80xx_tuner_reset,
1180 .sleep = dib80xx_tuner_sleep,
1181 .clock_khz = 12000,
1182 .clock_pad_drive = 4,
1183 .vga_filter = 1,
1184 .force_crystal_mode = 1,
1185 .enable_third_order_filter = 1,
1186 .charge_pump = 0,
1187 .wbd_gain = dib8070_wbd_gain_cfg,
1188 .osc_buffer_state = 0,
1189 .freq_offset_khz_uhf = -100,
1190 .freq_offset_khz_vhf = -100,
1191 }, {
1192 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1193 .reset = dib80xx_tuner_reset,
1194 .sleep = dib80xx_tuner_sleep,
1195 .clock_khz = 12000,
1196 .clock_pad_drive = 2,
1197 .vga_filter = 1,
1198 .force_crystal_mode = 1,
1199 .enable_third_order_filter = 1,
1200 .charge_pump = 0,
1201 .wbd_gain = dib8070_wbd_gain_cfg,
1202 .osc_buffer_state = 0,
1203 .freq_offset_khz_uhf = -25,
1204 .freq_offset_khz_vhf = -25,
1205 }
1206 };
1207
1208 static int dib807x_set_param_override(struct dvb_frontend *fe,
1209 struct dvb_frontend_parameters *fep)
1210 {
1211 struct dvb_usb_adapter *adap = fe->dvb->priv;
1212 struct dib0700_adapter_state *state = adap->priv;
1213
1214 u16 offset = dib0070_wbd_offset(fe);
1215 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1216 switch (band) {
1217 case BAND_VHF:
1218 offset += 750;
1219 break;
1220 case BAND_UHF: /* fall-thru wanted */
1221 default:
1222 offset += 250; break;
1223 }
1224 deb_info("WBD for DiB8000: %d\n", offset);
1225 dib8000_set_wbd_ref(fe, offset);
1226
1227 return state->set_param_save(fe, fep);
1228 }
1229
1230 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1231 {
1232 struct dib0700_adapter_state *st = adap->priv;
1233 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe,
1234 DIBX000_I2C_INTERFACE_TUNER, 1);
1235
1236 if (adap->id == 0) {
1237 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1238 &dib807x_dib0070_config[0]) == NULL)
1239 return -ENODEV;
1240 } else {
1241 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1242 &dib807x_dib0070_config[1]) == NULL)
1243 return -ENODEV;
1244 }
1245
1246 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1247 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1248 return 0;
1249 }
1250
1251 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1252 u16 pid, int onoff)
1253 {
1254 return dib8000_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1255 }
1256
1257 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1258 int onoff)
1259 {
1260 return dib8000_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1261 }
1262
1263 /* STK807x */
1264 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1265 {
1266 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1267 msleep(10);
1268 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1269 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1270 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1271
1272 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1273
1274 dib0700_ctrl_clock(adap->dev, 72, 1);
1275
1276 msleep(10);
1277 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1278 msleep(10);
1279 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1280
1281 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1282 0x80);
1283
1284 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1285 &dib807x_dib8000_config[0]);
1286
1287 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1288 }
1289
1290 /* STK807xPVR */
1291 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1292 {
1293 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1294 msleep(30);
1295 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1296 msleep(500);
1297 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1298 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1299 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1300
1301 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1302
1303 dib0700_ctrl_clock(adap->dev, 72, 1);
1304
1305 msleep(10);
1306 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1307 msleep(10);
1308 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1309
1310 /* initialize IC 0 */
1311 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
1312
1313 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1314 &dib807x_dib8000_config[0]);
1315
1316 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1317 }
1318
1319 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1320 {
1321 /* initialize IC 1 */
1322 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
1323
1324 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1325 &dib807x_dib8000_config[1]);
1326
1327 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1328 }
1329
1330 /* STK8096GP */
1331 struct dibx000_agc_config dib8090_agc_config[2] = {
1332 {
1333 BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1334 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1335 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1336 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1337 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1338 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1339
1340 787,
1341 10,
1342
1343 0,
1344 118,
1345
1346 0,
1347 3530,
1348 1,
1349 5,
1350
1351 65535,
1352 0,
1353
1354 65535,
1355 0,
1356
1357 0,
1358 32,
1359 114,
1360 143,
1361 144,
1362 114,
1363 227,
1364 116,
1365 117,
1366
1367 28,
1368 26,
1369 31,
1370 51,
1371
1372 0,
1373 },
1374 {
1375 BAND_CBAND,
1376 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1377 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1378 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1379 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1380 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1381
1382 787,
1383 10,
1384
1385 0,
1386 118,
1387
1388 0,
1389 3530,
1390 1,
1391 5,
1392
1393 0,
1394 0,
1395
1396 65535,
1397 0,
1398
1399 0,
1400 32,
1401 114,
1402 143,
1403 144,
1404 114,
1405 227,
1406 116,
1407 117,
1408
1409 28,
1410 26,
1411 31,
1412 51,
1413
1414 0,
1415 }
1416 };
1417
1418 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1419 54000, 13500,
1420 1, 18, 3, 1, 0,
1421 0, 0, 1, 1, 2,
1422 (3 << 14) | (1 << 12) | (599 << 0),
1423 (0 << 25) | 0,
1424 20199727,
1425 12000000,
1426 };
1427
1428 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1429 {
1430 return dib8000_get_adc_power(fe, 1);
1431 }
1432
1433 static struct dib8000_config dib809x_dib8000_config[2] = {
1434 {
1435 .output_mpeg2_in_188_bytes = 1,
1436
1437 .agc_config_count = 2,
1438 .agc = dib8090_agc_config,
1439 .agc_control = dib0090_dcc_freq,
1440 .pll = &dib8090_pll_config_12mhz,
1441 .tuner_is_baseband = 1,
1442
1443 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1444 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1445 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1446
1447 .hostbus_diversity = 1,
1448 .div_cfg = 0x31,
1449 .output_mode = OUTMODE_MPEG2_FIFO,
1450 .drives = 0x2d98,
1451 .diversity_delay = 48,
1452 .refclksel = 3,
1453 }, {
1454 .output_mpeg2_in_188_bytes = 1,
1455
1456 .agc_config_count = 2,
1457 .agc = dib8090_agc_config,
1458 .agc_control = dib0090_dcc_freq,
1459 .pll = &dib8090_pll_config_12mhz,
1460 .tuner_is_baseband = 1,
1461
1462 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1463 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1464 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1465
1466 .hostbus_diversity = 1,
1467 .div_cfg = 0x31,
1468 .output_mode = OUTMODE_DIVERSITY,
1469 .drives = 0x2d08,
1470 .diversity_delay = 1,
1471 .refclksel = 3,
1472 }
1473 };
1474
1475 static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1476 /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1477 { 120, 0, 500, 0, 500, 4 }, /* CBAND */
1478 { 170, 0, 450, 0, 450, 4 }, /* CBAND */
1479 { 380, 48, 373, 28, 259, 6 }, /* VHF */
1480 { 860, 34, 700, 36, 616, 6 }, /* high UHF */
1481 { 0xFFFF, 34, 700, 36, 616, 6 }, /* default */
1482 };
1483
1484 static struct dib0090_config dib809x_dib0090_config = {
1485 .io.pll_bypass = 1,
1486 .io.pll_range = 1,
1487 .io.pll_prediv = 1,
1488 .io.pll_loopdiv = 20,
1489 .io.adc_clock_ratio = 8,
1490 .io.pll_int_loop_filt = 0,
1491 .io.clock_khz = 12000,
1492 .reset = dib80xx_tuner_reset,
1493 .sleep = dib80xx_tuner_sleep,
1494 .clkouttobamse = 1,
1495 .analog_output = 1,
1496 .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1497 .use_pwm_agc = 1,
1498 .clkoutdrive = 1,
1499 .get_adc_power = dib8090_get_adc_power,
1500 .freq_offset_khz_uhf = -63,
1501 .freq_offset_khz_vhf = -143,
1502 .wbd = dib8090_wbd_table,
1503 .fref_clock_ratio = 6,
1504 };
1505
1506 static int dib8096_set_param_override(struct dvb_frontend *fe,
1507 struct dvb_frontend_parameters *fep)
1508 {
1509 struct dvb_usb_adapter *adap = fe->dvb->priv;
1510 struct dib0700_adapter_state *state = adap->priv;
1511 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1512 u16 target;
1513 int ret = 0;
1514 enum frontend_tune_state tune_state = CT_SHUTDOWN;
1515 u16 ltgain, rf_gain_limit;
1516
1517 ret = state->set_param_save(fe, fep);
1518 if (ret < 0)
1519 return ret;
1520
1521 target = (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
1522 dib8000_set_wbd_ref(fe, target);
1523
1524
1525 if (band == BAND_CBAND) {
1526 deb_info("tuning in CBAND - soft-AGC startup\n");
1527 dib0090_set_tune_state(fe, CT_AGC_START);
1528 do {
1529 ret = dib0090_gain_control(fe);
1530 msleep(ret);
1531 tune_state = dib0090_get_tune_state(fe);
1532 if (tune_state == CT_AGC_STEP_0)
1533 dib8000_set_gpio(fe, 6, 0, 1);
1534 else if (tune_state == CT_AGC_STEP_1) {
1535 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1536 if (rf_gain_limit == 0)
1537 dib8000_set_gpio(fe, 6, 0, 0);
1538 }
1539 } while (tune_state < CT_AGC_STOP);
1540 dib0090_pwm_gain_reset(fe);
1541 dib8000_pwm_agc_reset(fe);
1542 dib8000_set_tune_state(fe, CT_DEMOD_START);
1543 } else {
1544 deb_info("not tuning in CBAND - standard AGC startup\n");
1545 dib0090_pwm_gain_reset(fe);
1546 }
1547
1548 return 0;
1549 }
1550
1551 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1552 {
1553 struct dib0700_adapter_state *st = adap->priv;
1554 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1555
1556 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1557 return -ENODEV;
1558
1559 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1560 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1561 return 0;
1562 }
1563
1564 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1565 {
1566 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1567 msleep(10);
1568 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1569 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1570 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1571
1572 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1573
1574 dib0700_ctrl_clock(adap->dev, 72, 1);
1575
1576 msleep(10);
1577 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1578 msleep(10);
1579 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1580
1581 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
1582
1583 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1584
1585 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1586 }
1587
1588 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1589 {
1590 struct dib0700_adapter_state *st = adap->priv;
1591 struct i2c_adapter *tun_i2c;
1592 struct dvb_frontend *fe_slave = dib8000_get_slave_frontend(adap->fe_adap[0].fe, 1);
1593
1594 if (fe_slave) {
1595 tun_i2c = dib8000_get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1596 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1597 return -ENODEV;
1598 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1599 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1600 }
1601 tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1602 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1603 return -ENODEV;
1604
1605 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1606 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1607
1608 return 0;
1609 }
1610
1611 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1612 {
1613 struct dvb_frontend *fe_slave;
1614
1615 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1616 msleep(20);
1617 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1618 msleep(1000);
1619 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1620 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1621 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1622
1623 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1624
1625 dib0700_ctrl_clock(adap->dev, 72, 1);
1626
1627 msleep(20);
1628 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1629 msleep(20);
1630 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1631
1632 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80);
1633
1634 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1635 if (adap->fe_adap[0].fe == NULL)
1636 return -ENODEV;
1637
1638 fe_slave = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1639 dib8000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1640
1641 return fe_slave == NULL ? -ENODEV : 0;
1642 }
1643
1644 /* STK9090M */
1645 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
1646 {
1647 return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1648 }
1649
1650 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
1651 {
1652 return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1653 }
1654
1655 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
1656 {
1657 return dib9000_set_gpio(fe, 5, 0, !onoff);
1658 }
1659
1660 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
1661 {
1662 return dib9000_set_gpio(fe, 0, 0, onoff);
1663 }
1664
1665 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
1666 {
1667 u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
1668 u8 rb[2];
1669 struct i2c_msg msg[2] = {
1670 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
1671 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
1672 };
1673 u8 index_data;
1674
1675 dibx000_i2c_set_speed(i2c, 250);
1676
1677 if (i2c_transfer(i2c, msg, 2) != 2)
1678 return -EIO;
1679
1680 switch (rb[0] << 8 | rb[1]) {
1681 case 0:
1682 deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
1683 return -EIO;
1684 case 1:
1685 deb_info("Found DiB0170 rev2");
1686 break;
1687 case 2:
1688 deb_info("Found DiB0190 rev2");
1689 break;
1690 default:
1691 deb_info("DiB01x0 not found");
1692 return -EIO;
1693 }
1694
1695 for (index_data = 0; index_data < len; index_data += 2) {
1696 wb[2] = (data[index_data + 1] >> 8) & 0xff;
1697 wb[3] = (data[index_data + 1]) & 0xff;
1698
1699 if (data[index_data] == 0) {
1700 wb[0] = (data[index_data] >> 8) & 0xff;
1701 wb[1] = (data[index_data]) & 0xff;
1702 msg[0].len = 2;
1703 if (i2c_transfer(i2c, msg, 2) != 2)
1704 return -EIO;
1705 wb[2] |= rb[0];
1706 wb[3] |= rb[1] & ~(3 << 4);
1707 }
1708
1709 wb[0] = (data[index_data] >> 8)&0xff;
1710 wb[1] = (data[index_data])&0xff;
1711 msg[0].len = 4;
1712 if (i2c_transfer(i2c, &msg[0], 1) != 1)
1713 return -EIO;
1714 }
1715 return 0;
1716 }
1717
1718 static struct dib9000_config stk9090m_config = {
1719 .output_mpeg2_in_188_bytes = 1,
1720 .output_mode = OUTMODE_MPEG2_FIFO,
1721 .vcxo_timer = 279620,
1722 .timing_frequency = 20452225,
1723 .demod_clock_khz = 60000,
1724 .xtal_clock_khz = 30000,
1725 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1726 .subband = {
1727 2,
1728 {
1729 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
1730 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
1731 { 0 },
1732 },
1733 },
1734 .gpio_function = {
1735 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
1736 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
1737 },
1738 };
1739
1740 static struct dib9000_config nim9090md_config[2] = {
1741 {
1742 .output_mpeg2_in_188_bytes = 1,
1743 .output_mode = OUTMODE_MPEG2_FIFO,
1744 .vcxo_timer = 279620,
1745 .timing_frequency = 20452225,
1746 .demod_clock_khz = 60000,
1747 .xtal_clock_khz = 30000,
1748 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1749 }, {
1750 .output_mpeg2_in_188_bytes = 1,
1751 .output_mode = OUTMODE_DIVERSITY,
1752 .vcxo_timer = 279620,
1753 .timing_frequency = 20452225,
1754 .demod_clock_khz = 60000,
1755 .xtal_clock_khz = 30000,
1756 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
1757 .subband = {
1758 2,
1759 {
1760 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
1761 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
1762 { 0 },
1763 },
1764 },
1765 .gpio_function = {
1766 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
1767 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
1768 },
1769 }
1770 };
1771
1772 static struct dib0090_config dib9090_dib0090_config = {
1773 .io.pll_bypass = 0,
1774 .io.pll_range = 1,
1775 .io.pll_prediv = 1,
1776 .io.pll_loopdiv = 8,
1777 .io.adc_clock_ratio = 8,
1778 .io.pll_int_loop_filt = 0,
1779 .io.clock_khz = 30000,
1780 .reset = dib90x0_tuner_reset,
1781 .sleep = dib90x0_tuner_sleep,
1782 .clkouttobamse = 0,
1783 .analog_output = 0,
1784 .use_pwm_agc = 0,
1785 .clkoutdrive = 0,
1786 .freq_offset_khz_uhf = 0,
1787 .freq_offset_khz_vhf = 0,
1788 };
1789
1790 static struct dib0090_config nim9090md_dib0090_config[2] = {
1791 {
1792 .io.pll_bypass = 0,
1793 .io.pll_range = 1,
1794 .io.pll_prediv = 1,
1795 .io.pll_loopdiv = 8,
1796 .io.adc_clock_ratio = 8,
1797 .io.pll_int_loop_filt = 0,
1798 .io.clock_khz = 30000,
1799 .reset = dib90x0_tuner_reset,
1800 .sleep = dib90x0_tuner_sleep,
1801 .clkouttobamse = 1,
1802 .analog_output = 0,
1803 .use_pwm_agc = 0,
1804 .clkoutdrive = 0,
1805 .freq_offset_khz_uhf = 0,
1806 .freq_offset_khz_vhf = 0,
1807 }, {
1808 .io.pll_bypass = 0,
1809 .io.pll_range = 1,
1810 .io.pll_prediv = 1,
1811 .io.pll_loopdiv = 8,
1812 .io.adc_clock_ratio = 8,
1813 .io.pll_int_loop_filt = 0,
1814 .io.clock_khz = 30000,
1815 .reset = dib90x0_tuner_reset,
1816 .sleep = dib90x0_tuner_sleep,
1817 .clkouttobamse = 0,
1818 .analog_output = 0,
1819 .use_pwm_agc = 0,
1820 .clkoutdrive = 0,
1821 .freq_offset_khz_uhf = 0,
1822 .freq_offset_khz_vhf = 0,
1823 }
1824 };
1825
1826
1827 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
1828 {
1829 struct dib0700_adapter_state *state = adap->priv;
1830 struct dib0700_state *st = adap->dev->priv;
1831 u32 fw_version;
1832
1833 /* Make use of the new i2c functions from FW 1.20 */
1834 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
1835 if (fw_version >= 0x10200)
1836 st->fw_use_new_i2c_api = 1;
1837 dib0700_set_i2c_speed(adap->dev, 340);
1838
1839 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1840 msleep(20);
1841 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1842 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1843 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1844 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1845
1846 dib0700_ctrl_clock(adap->dev, 72, 1);
1847
1848 msleep(20);
1849 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1850 msleep(20);
1851 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1852
1853 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
1854
1855 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
1856 deb_info("%s: Upload failed. (file not found?)\n", __func__);
1857 return -ENODEV;
1858 } else {
1859 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
1860 }
1861 stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
1862 stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
1863
1864 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
1865
1866 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1867 }
1868
1869 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
1870 {
1871 struct dib0700_adapter_state *state = adap->priv;
1872 struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
1873 u16 data_dib190[10] = {
1874 1, 0x1374,
1875 2, 0x01a2,
1876 7, 0x0020,
1877 0, 0x00ef,
1878 8, 0x0486,
1879 };
1880
1881 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
1882 return -ENODEV;
1883 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
1884 if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
1885 return -ENODEV;
1886 dib0700_set_i2c_speed(adap->dev, 2000);
1887 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
1888 return -ENODEV;
1889 release_firmware(state->frontend_firmware);
1890 return 0;
1891 }
1892
1893 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
1894 {
1895 struct dib0700_adapter_state *state = adap->priv;
1896 struct dib0700_state *st = adap->dev->priv;
1897 struct i2c_adapter *i2c;
1898 struct dvb_frontend *fe_slave;
1899 u32 fw_version;
1900
1901 /* Make use of the new i2c functions from FW 1.20 */
1902 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
1903 if (fw_version >= 0x10200)
1904 st->fw_use_new_i2c_api = 1;
1905 dib0700_set_i2c_speed(adap->dev, 340);
1906
1907 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1908 msleep(20);
1909 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1910 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1911 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1912 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1913
1914 dib0700_ctrl_clock(adap->dev, 72, 1);
1915
1916 msleep(20);
1917 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1918 msleep(20);
1919 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1920
1921 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
1922 deb_info("%s: Upload failed. (file not found?)\n", __func__);
1923 return -EIO;
1924 } else {
1925 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
1926 }
1927 nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
1928 nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
1929 nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
1930 nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
1931
1932 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
1933 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
1934
1935 if (adap->fe_adap[0].fe == NULL)
1936 return -ENODEV;
1937
1938 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
1939 dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
1940
1941 fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
1942 dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1943
1944 return fe_slave == NULL ? -ENODEV : 0;
1945 }
1946
1947 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
1948 {
1949 struct dib0700_adapter_state *state = adap->priv;
1950 struct i2c_adapter *i2c;
1951 struct dvb_frontend *fe_slave;
1952 u16 data_dib190[10] = {
1953 1, 0x5374,
1954 2, 0x01ae,
1955 7, 0x0020,
1956 0, 0x00ef,
1957 8, 0x0406,
1958 };
1959 i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
1960 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
1961 return -ENODEV;
1962 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
1963 if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
1964 return -ENODEV;
1965 dib0700_set_i2c_speed(adap->dev, 2000);
1966 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
1967 return -ENODEV;
1968
1969 fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
1970 if (fe_slave != NULL) {
1971 i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
1972 dib9000_set_i2c_adapter(fe_slave, i2c);
1973
1974 i2c = dib9000_get_tuner_interface(fe_slave);
1975 if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
1976 return -ENODEV;
1977 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1978 dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 2000);
1979 if (dib9000_firmware_post_pll_init(fe_slave) < 0)
1980 return -ENODEV;
1981 }
1982 release_firmware(state->frontend_firmware);
1983
1984 return 0;
1985 }
1986
1987 /* NIM7090 */
1988 struct dib7090p_best_adc {
1989 u32 timf;
1990 u32 pll_loopdiv;
1991 u32 pll_prediv;
1992 };
1993
1994 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dib7090p_best_adc *adc)
1995 {
1996 u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
1997
1998 u16 xtal = 12000;
1999 u32 fcp_min = 1900; /* PLL Minimum Frequency comparator KHz */
2000 u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
2001 u32 fdem_max = 76000;
2002 u32 fdem_min = 69500;
2003 u32 fcp = 0, fs = 0, fdem = 0;
2004 u32 harmonic_id = 0;
2005
2006 adc->pll_loopdiv = loopdiv;
2007 adc->pll_prediv = prediv;
2008 adc->timf = 0;
2009
2010 deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2011
2012 /* Find Min and Max prediv */
2013 while ((xtal/max_prediv) >= fcp_min)
2014 max_prediv++;
2015
2016 max_prediv--;
2017 min_prediv = max_prediv;
2018 while ((xtal/min_prediv) <= fcp_max) {
2019 min_prediv--;
2020 if (min_prediv == 1)
2021 break;
2022 }
2023 deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2024
2025 min_prediv = 2;
2026
2027 for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2028 fcp = xtal / prediv;
2029 if (fcp > fcp_min && fcp < fcp_max) {
2030 for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2031 fdem = ((xtal/prediv) * loopdiv);
2032 fs = fdem / 4;
2033 /* test min/max system restrictions */
2034
2035 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2036 spur = 0;
2037 /* test fs harmonics positions */
2038 for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ; harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2039 if (((fs*harmonic_id) >= ((fe->dtv_property_cache.frequency/1000) - (fe->dtv_property_cache.bandwidth_hz/2000))) && ((fs*harmonic_id) <= ((fe->dtv_property_cache.frequency/1000) + (fe->dtv_property_cache.bandwidth_hz/2000)))) {
2040 spur = 1;
2041 break;
2042 }
2043 }
2044
2045 if (!spur) {
2046 adc->pll_loopdiv = loopdiv;
2047 adc->pll_prediv = prediv;
2048 adc->timf = 2396745143UL/fdem*(1 << 9);
2049 adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2050 deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2051 break;
2052 }
2053 }
2054 }
2055 }
2056 if (!spur)
2057 break;
2058 }
2059
2060
2061 if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2062 return -EINVAL;
2063 else
2064 return 0;
2065 }
2066
2067 static int dib7090_agc_startup(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
2068 {
2069 struct dvb_usb_adapter *adap = fe->dvb->priv;
2070 struct dib0700_adapter_state *state = adap->priv;
2071 struct dibx000_bandwidth_config pll;
2072 u16 target;
2073 struct dib7090p_best_adc adc;
2074 int ret;
2075
2076 ret = state->set_param_save(fe, fep);
2077 if (ret < 0)
2078 return ret;
2079
2080 memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2081 dib0090_pwm_gain_reset(fe);
2082 target = (dib0090_get_wbd_offset(fe) * 8 + 1) / 2;
2083 dib7000p_set_wbd_ref(fe, target);
2084
2085 if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2086 pll.pll_ratio = adc.pll_loopdiv;
2087 pll.pll_prediv = adc.pll_prediv;
2088
2089 dib7000p_update_pll(fe, &pll);
2090 dib7000p_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2091 }
2092 return 0;
2093 }
2094
2095 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2096 { 380, 81, 850, 64, 540, 4},
2097 { 860, 51, 866, 21, 375, 4},
2098 {1700, 0, 250, 0, 100, 6},
2099 {2600, 0, 250, 0, 100, 6},
2100 { 0xFFFF, 0, 0, 0, 0, 0},
2101 };
2102
2103 struct dibx000_agc_config dib7090_agc_config[2] = {
2104 {
2105 .band_caps = BAND_UHF,
2106 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2107 * 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 */
2108 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2109
2110 .inv_gain = 687,
2111 .time_stabiliz = 10,
2112
2113 .alpha_level = 0,
2114 .thlock = 118,
2115
2116 .wbd_inv = 0,
2117 .wbd_ref = 1200,
2118 .wbd_sel = 3,
2119 .wbd_alpha = 5,
2120
2121 .agc1_max = 65535,
2122 .agc1_min = 0,
2123
2124 .agc2_max = 65535,
2125 .agc2_min = 0,
2126
2127 .agc1_pt1 = 0,
2128 .agc1_pt2 = 32,
2129 .agc1_pt3 = 114,
2130 .agc1_slope1 = 143,
2131 .agc1_slope2 = 144,
2132 .agc2_pt1 = 114,
2133 .agc2_pt2 = 227,
2134 .agc2_slope1 = 116,
2135 .agc2_slope2 = 117,
2136
2137 .alpha_mant = 18,
2138 .alpha_exp = 0,
2139 .beta_mant = 20,
2140 .beta_exp = 59,
2141
2142 .perform_agc_softsplit = 0,
2143 } , {
2144 .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
2145 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
2146 * 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 */
2147 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2148
2149 .inv_gain = 732,
2150 .time_stabiliz = 10,
2151
2152 .alpha_level = 0,
2153 .thlock = 118,
2154
2155 .wbd_inv = 0,
2156 .wbd_ref = 1200,
2157 .wbd_sel = 3,
2158 .wbd_alpha = 5,
2159
2160 .agc1_max = 65535,
2161 .agc1_min = 0,
2162
2163 .agc2_max = 65535,
2164 .agc2_min = 0,
2165
2166 .agc1_pt1 = 0,
2167 .agc1_pt2 = 0,
2168 .agc1_pt3 = 98,
2169 .agc1_slope1 = 0,
2170 .agc1_slope2 = 167,
2171 .agc2_pt1 = 98,
2172 .agc2_pt2 = 255,
2173 .agc2_slope1 = 104,
2174 .agc2_slope2 = 0,
2175
2176 .alpha_mant = 18,
2177 .alpha_exp = 0,
2178 .beta_mant = 20,
2179 .beta_exp = 59,
2180
2181 .perform_agc_softsplit = 0,
2182 }
2183 };
2184
2185 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2186 60000, 15000,
2187 1, 5, 0, 0, 0,
2188 0, 0, 1, 1, 2,
2189 (3 << 14) | (1 << 12) | (524 << 0),
2190 (0 << 25) | 0,
2191 20452225,
2192 15000000,
2193 };
2194
2195 static struct dib7000p_config nim7090_dib7000p_config = {
2196 .output_mpeg2_in_188_bytes = 1,
2197 .hostbus_diversity = 1,
2198 .tuner_is_baseband = 1,
2199 .update_lna = NULL,
2200
2201 .agc_config_count = 2,
2202 .agc = dib7090_agc_config,
2203
2204 .bw = &dib7090_clock_config_12_mhz,
2205
2206 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2207 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2208 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2209
2210 .pwm_freq_div = 0,
2211
2212 .agc_control = dib7090_agc_restart,
2213
2214 .spur_protect = 0,
2215 .disable_sample_and_hold = 0,
2216 .enable_current_mirror = 0,
2217 .diversity_delay = 0,
2218
2219 .output_mode = OUTMODE_MPEG2_FIFO,
2220 .enMpegOutput = 1,
2221 };
2222
2223 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2224 {
2225 .output_mpeg2_in_188_bytes = 1,
2226 .hostbus_diversity = 1,
2227 .tuner_is_baseband = 1,
2228 .update_lna = NULL,
2229
2230 .agc_config_count = 2,
2231 .agc = dib7090_agc_config,
2232
2233 .bw = &dib7090_clock_config_12_mhz,
2234
2235 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2236 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2237 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2238
2239 .pwm_freq_div = 0,
2240
2241 .agc_control = dib7090_agc_restart,
2242
2243 .spur_protect = 0,
2244 .disable_sample_and_hold = 0,
2245 .enable_current_mirror = 0,
2246 .diversity_delay = 0,
2247
2248 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2249 .default_i2c_addr = 0x90,
2250 .enMpegOutput = 1,
2251 }, {
2252 .output_mpeg2_in_188_bytes = 1,
2253 .hostbus_diversity = 1,
2254 .tuner_is_baseband = 1,
2255 .update_lna = NULL,
2256
2257 .agc_config_count = 2,
2258 .agc = dib7090_agc_config,
2259
2260 .bw = &dib7090_clock_config_12_mhz,
2261
2262 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2263 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2264 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2265
2266 .pwm_freq_div = 0,
2267
2268 .agc_control = dib7090_agc_restart,
2269
2270 .spur_protect = 0,
2271 .disable_sample_and_hold = 0,
2272 .enable_current_mirror = 0,
2273 .diversity_delay = 0,
2274
2275 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2276 .default_i2c_addr = 0x92,
2277 .enMpegOutput = 0,
2278 }
2279 };
2280
2281 static const struct dib0090_config nim7090_dib0090_config = {
2282 .io.clock_khz = 12000,
2283 .io.pll_bypass = 0,
2284 .io.pll_range = 0,
2285 .io.pll_prediv = 3,
2286 .io.pll_loopdiv = 6,
2287 .io.adc_clock_ratio = 0,
2288 .io.pll_int_loop_filt = 0,
2289 .reset = dib7090_tuner_sleep,
2290 .sleep = dib7090_tuner_sleep,
2291
2292 .freq_offset_khz_uhf = 0,
2293 .freq_offset_khz_vhf = 0,
2294
2295 .get_adc_power = dib7090_get_adc_power,
2296
2297 .clkouttobamse = 1,
2298 .analog_output = 0,
2299
2300 .wbd_vhf_offset = 0,
2301 .wbd_cband_offset = 0,
2302 .use_pwm_agc = 1,
2303 .clkoutdrive = 0,
2304
2305 .fref_clock_ratio = 0,
2306
2307 .wbd = dib7090_wbd_table,
2308
2309 .ls_cfg_pad_drv = 0,
2310 .data_tx_drv = 0,
2311 .low_if = NULL,
2312 .in_soc = 1,
2313 };
2314
2315 static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2316 {
2317 .io.clock_khz = 12000,
2318 .io.pll_bypass = 0,
2319 .io.pll_range = 0,
2320 .io.pll_prediv = 3,
2321 .io.pll_loopdiv = 6,
2322 .io.adc_clock_ratio = 0,
2323 .io.pll_int_loop_filt = 0,
2324 .reset = dib7090_tuner_sleep,
2325 .sleep = dib7090_tuner_sleep,
2326
2327 .freq_offset_khz_uhf = 50,
2328 .freq_offset_khz_vhf = 70,
2329
2330 .get_adc_power = dib7090_get_adc_power,
2331
2332 .clkouttobamse = 1,
2333 .analog_output = 0,
2334
2335 .wbd_vhf_offset = 0,
2336 .wbd_cband_offset = 0,
2337 .use_pwm_agc = 1,
2338 .clkoutdrive = 0,
2339
2340 .fref_clock_ratio = 0,
2341
2342 .wbd = dib7090_wbd_table,
2343
2344 .ls_cfg_pad_drv = 0,
2345 .data_tx_drv = 0,
2346 .low_if = NULL,
2347 .in_soc = 1,
2348 }, {
2349 .io.clock_khz = 12000,
2350 .io.pll_bypass = 0,
2351 .io.pll_range = 0,
2352 .io.pll_prediv = 3,
2353 .io.pll_loopdiv = 6,
2354 .io.adc_clock_ratio = 0,
2355 .io.pll_int_loop_filt = 0,
2356 .reset = dib7090_tuner_sleep,
2357 .sleep = dib7090_tuner_sleep,
2358
2359 .freq_offset_khz_uhf = -50,
2360 .freq_offset_khz_vhf = -70,
2361
2362 .get_adc_power = dib7090_get_adc_power,
2363
2364 .clkouttobamse = 1,
2365 .analog_output = 0,
2366
2367 .wbd_vhf_offset = 0,
2368 .wbd_cband_offset = 0,
2369 .use_pwm_agc = 1,
2370 .clkoutdrive = 0,
2371
2372 .fref_clock_ratio = 0,
2373
2374 .wbd = dib7090_wbd_table,
2375
2376 .ls_cfg_pad_drv = 0,
2377 .data_tx_drv = 0,
2378 .low_if = NULL,
2379 .in_soc = 1,
2380 }
2381 };
2382
2383 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
2384 {
2385 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2386 msleep(20);
2387 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2388 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2389 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2390 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2391
2392 msleep(20);
2393 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2394 msleep(20);
2395 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2396
2397 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
2398 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2399 return -ENODEV;
2400 }
2401 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
2402
2403 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2404 }
2405
2406 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
2407 {
2408 struct dib0700_adapter_state *st = adap->priv;
2409 struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2410
2411 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
2412 return -ENODEV;
2413
2414 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2415
2416 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2417 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2418 return 0;
2419 }
2420
2421 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
2422 {
2423 struct dib0700_state *st = adap->dev->priv;
2424
2425 /* The TFE7090 requires the dib0700 to not be in master mode */
2426 st->disable_streaming_master_mode = 1;
2427
2428 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2429 msleep(20);
2430 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2431 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2432 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2433 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2434
2435 msleep(20);
2436 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2437 msleep(20);
2438 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2439
2440 /* initialize IC 0 */
2441 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
2442 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2443 return -ENODEV;
2444 }
2445
2446 dib0700_set_i2c_speed(adap->dev, 340);
2447 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
2448 if (adap->fe_adap[0].fe == NULL)
2449 return -ENODEV;
2450
2451 dib7090_slave_reset(adap->fe_adap[0].fe);
2452
2453 return 0;
2454 }
2455
2456 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
2457 {
2458 struct i2c_adapter *i2c;
2459
2460 if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
2461 err("the master dib7090 has to be initialized first");
2462 return -ENODEV; /* the master device has not been initialized */
2463 }
2464
2465 i2c = dib7000p_get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
2466 if (dib7000p_i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
2467 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2468 return -ENODEV;
2469 }
2470
2471 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
2472 dib0700_set_i2c_speed(adap->dev, 200);
2473
2474 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2475 }
2476
2477 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
2478 {
2479 struct dib0700_adapter_state *st = adap->priv;
2480 struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2481
2482 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
2483 return -ENODEV;
2484
2485 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2486
2487 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2488 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2489 return 0;
2490 }
2491
2492 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
2493 {
2494 struct dib0700_adapter_state *st = adap->priv;
2495 struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2496
2497 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
2498 return -ENODEV;
2499
2500 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2501
2502 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2503 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2504 return 0;
2505 }
2506
2507 /* STK7070PD */
2508 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
2509 {
2510 .output_mpeg2_in_188_bytes = 1,
2511
2512 .agc_config_count = 1,
2513 .agc = &dib7070_agc_config,
2514 .bw = &dib7070_bw_config_12_mhz,
2515 .tuner_is_baseband = 1,
2516 .spur_protect = 1,
2517
2518 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2519 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2520 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2521
2522 .hostbus_diversity = 1,
2523 }, {
2524 .output_mpeg2_in_188_bytes = 1,
2525
2526 .agc_config_count = 1,
2527 .agc = &dib7070_agc_config,
2528 .bw = &dib7070_bw_config_12_mhz,
2529 .tuner_is_baseband = 1,
2530 .spur_protect = 1,
2531
2532 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2533 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2534 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2535
2536 .hostbus_diversity = 1,
2537 }
2538 };
2539
2540 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
2541 {
2542 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2543 msleep(10);
2544 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2545 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2546 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2547 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2548
2549 dib0700_ctrl_clock(adap->dev, 72, 1);
2550
2551 msleep(10);
2552 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2553 msleep(10);
2554 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2555
2556 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
2557 stk7070pd_dib7000p_config) != 0) {
2558 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
2559 __func__);
2560 return -ENODEV;
2561 }
2562
2563 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
2564 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2565 }
2566
2567 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
2568 {
2569 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
2570 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2571 }
2572
2573 /* S5H1411 */
2574 static struct s5h1411_config pinnacle_801e_config = {
2575 .output_mode = S5H1411_PARALLEL_OUTPUT,
2576 .gpio = S5H1411_GPIO_OFF,
2577 .mpeg_timing = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
2578 .qam_if = S5H1411_IF_44000,
2579 .vsb_if = S5H1411_IF_44000,
2580 .inversion = S5H1411_INVERSION_OFF,
2581 .status_mode = S5H1411_DEMODLOCKING
2582 };
2583
2584 /* Pinnacle PCTV HD Pro 801e GPIOs map:
2585 GPIO0 - currently unknown
2586 GPIO1 - xc5000 tuner reset
2587 GPIO2 - CX25843 sleep
2588 GPIO3 - currently unknown
2589 GPIO4 - currently unknown
2590 GPIO6 - currently unknown
2591 GPIO7 - currently unknown
2592 GPIO9 - currently unknown
2593 GPIO10 - CX25843 reset
2594 */
2595 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
2596 {
2597 struct dib0700_state *st = adap->dev->priv;
2598
2599 /* Make use of the new i2c functions from FW 1.20 */
2600 st->fw_use_new_i2c_api = 1;
2601
2602 /* The s5h1411 requires the dib0700 to not be in master mode */
2603 st->disable_streaming_master_mode = 1;
2604
2605 /* All msleep values taken from Windows USB trace */
2606 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
2607 dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
2608 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2609 msleep(400);
2610 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2611 msleep(60);
2612 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2613 msleep(30);
2614 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2615 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2616 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2617 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2618 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
2619 msleep(30);
2620
2621 /* Put the CX25843 to sleep for now since we're in digital mode */
2622 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
2623
2624 /* GPIOs are initialized, do the attach */
2625 adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
2626 &adap->dev->i2c_adap);
2627 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2628 }
2629
2630 static int dib0700_xc5000_tuner_callback(void *priv, int component,
2631 int command, int arg)
2632 {
2633 struct dvb_usb_adapter *adap = priv;
2634
2635 if (command == XC5000_TUNER_RESET) {
2636 /* Reset the tuner */
2637 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
2638 msleep(10);
2639 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
2640 msleep(10);
2641 } else {
2642 err("xc5000: unknown tuner callback command: %d\n", command);
2643 return -EINVAL;
2644 }
2645
2646 return 0;
2647 }
2648
2649 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
2650 .i2c_address = 0x64,
2651 .if_khz = 5380,
2652 };
2653
2654 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
2655 {
2656 /* FIXME: generalize & move to common area */
2657 adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
2658
2659 return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
2660 &s5h1411_xc5000_tunerconfig)
2661 == NULL ? -ENODEV : 0;
2662 }
2663
2664 static int dib0700_xc4000_tuner_callback(void *priv, int component,
2665 int command, int arg)
2666 {
2667 struct dvb_usb_adapter *adap = priv;
2668
2669 if (command == XC4000_TUNER_RESET) {
2670 /* Reset the tuner */
2671 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
2672 msleep(10);
2673 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2674 } else {
2675 err("xc4000: unknown tuner callback command: %d\n", command);
2676 return -EINVAL;
2677 }
2678
2679 return 0;
2680 }
2681
2682 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
2683 .band_caps = BAND_UHF | BAND_VHF,
2684 .setup = 0x64,
2685 .inv_gain = 0x02c8,
2686 .time_stabiliz = 0x15,
2687 .alpha_level = 0x00,
2688 .thlock = 0x76,
2689 .wbd_inv = 0x01,
2690 .wbd_ref = 0x0b33,
2691 .wbd_sel = 0x00,
2692 .wbd_alpha = 0x02,
2693 .agc1_max = 0x00,
2694 .agc1_min = 0x00,
2695 .agc2_max = 0x9b26,
2696 .agc2_min = 0x26ca,
2697 .agc1_pt1 = 0x00,
2698 .agc1_pt2 = 0x00,
2699 .agc1_pt3 = 0x00,
2700 .agc1_slope1 = 0x00,
2701 .agc1_slope2 = 0x00,
2702 .agc2_pt1 = 0x00,
2703 .agc2_pt2 = 0x80,
2704 .agc2_slope1 = 0x1d,
2705 .agc2_slope2 = 0x1d,
2706 .alpha_mant = 0x11,
2707 .alpha_exp = 0x1b,
2708 .beta_mant = 0x17,
2709 .beta_exp = 0x33,
2710 .perform_agc_softsplit = 0x00,
2711 };
2712
2713 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
2714 60000, 30000, /* internal, sampling */
2715 1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
2716 0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, */
2717 /* ADClkSrc, modulo */
2718 (3 << 14) | (1 << 12) | 524, /* sad_cfg: refsel, sel, freq_15k */
2719 39370534, /* ifreq */
2720 20452225, /* timf */
2721 30000000 /* xtal */
2722 };
2723
2724 /* FIXME: none of these inputs are validated yet */
2725 static struct dib7000p_config pctv_340e_config = {
2726 .output_mpeg2_in_188_bytes = 1,
2727
2728 .agc_config_count = 1,
2729 .agc = &stk7700p_7000p_xc4000_agc_config,
2730 .bw = &stk7700p_xc4000_pll_config,
2731
2732 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
2733 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
2734 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
2735 };
2736
2737 /* PCTV 340e GPIOs map:
2738 dib0700:
2739 GPIO2 - CX25843 sleep
2740 GPIO3 - CS5340 reset
2741 GPIO5 - IRD
2742 GPIO6 - Power Supply
2743 GPIO8 - LNA (1=off 0=on)
2744 GPIO10 - CX25843 reset
2745 dib7000:
2746 GPIO8 - xc4000 reset
2747 */
2748 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
2749 {
2750 struct dib0700_state *st = adap->dev->priv;
2751
2752 /* Power Supply on */
2753 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
2754 msleep(50);
2755 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2756 msleep(100); /* Allow power supply to settle before probing */
2757
2758 /* cx25843 reset */
2759 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2760 msleep(1); /* cx25843 datasheet say 350us required */
2761 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2762
2763 /* LNA off for now */
2764 dib0700_set_gpio(adap->dev, GPIO8, GPIO_OUT, 1);
2765
2766 /* Put the CX25843 to sleep for now since we're in digital mode */
2767 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
2768
2769 /* FIXME: not verified yet */
2770 dib0700_ctrl_clock(adap->dev, 72, 1);
2771
2772 msleep(500);
2773
2774 if (dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
2775 /* Demodulator not found for some reason? */
2776 return -ENODEV;
2777 }
2778
2779 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x12,
2780 &pctv_340e_config);
2781 st->is_dib7000pc = 1;
2782
2783 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2784 }
2785
2786 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
2787 .i2c_address = 0x61,
2788 .default_pm = 1,
2789 .dvb_amplitude = 0,
2790 .set_smoothedcvbs = 0,
2791 .if_khz = 5400
2792 };
2793
2794 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
2795 {
2796 struct i2c_adapter *tun_i2c;
2797
2798 /* The xc4000 is not on the main i2c bus */
2799 tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
2800 DIBX000_I2C_INTERFACE_TUNER, 1);
2801 if (tun_i2c == NULL) {
2802 printk(KERN_ERR "Could not reach tuner i2c bus\n");
2803 return 0;
2804 }
2805
2806 /* Setup the reset callback */
2807 adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
2808
2809 return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
2810 &dib7000p_xc4000_tunerconfig)
2811 == NULL ? -ENODEV : 0;
2812 }
2813
2814 static struct lgdt3305_config hcw_lgdt3305_config = {
2815 .i2c_addr = 0x0e,
2816 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
2817 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
2818 .tpvalid_polarity = LGDT3305_TP_VALID_LOW,
2819 .deny_i2c_rptr = 0,
2820 .spectral_inversion = 1,
2821 .qam_if_khz = 6000,
2822 .vsb_if_khz = 6000,
2823 .usref_8vsb = 0x0500,
2824 };
2825
2826 static struct mxl5007t_config hcw_mxl5007t_config = {
2827 .xtal_freq_hz = MxL_XTAL_25_MHZ,
2828 .if_freq_hz = MxL_IF_6_MHZ,
2829 .invert_if = 1,
2830 };
2831
2832 /* TIGER-ATSC map:
2833 GPIO0 - LNA_CTR (H: LNA power enabled, L: LNA power disabled)
2834 GPIO1 - ANT_SEL (H: VPA, L: MCX)
2835 GPIO4 - SCL2
2836 GPIO6 - EN_TUNER
2837 GPIO7 - SDA2
2838 GPIO10 - DEM_RST
2839
2840 MXL is behind LG's i2c repeater. LG is on SCL2/SDA2 gpios on the DIB
2841 */
2842 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
2843 {
2844 struct dib0700_state *st = adap->dev->priv;
2845
2846 /* Make use of the new i2c functions from FW 1.20 */
2847 st->fw_use_new_i2c_api = 1;
2848
2849 st->disable_streaming_master_mode = 1;
2850
2851 /* fe power enable */
2852 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
2853 msleep(30);
2854 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2855 msleep(30);
2856
2857 /* demod reset */
2858 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2859 msleep(30);
2860 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2861 msleep(30);
2862 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2863 msleep(30);
2864
2865 adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
2866 &hcw_lgdt3305_config,
2867 &adap->dev->i2c_adap);
2868
2869 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2870 }
2871
2872 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
2873 {
2874 return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
2875 &adap->dev->i2c_adap, 0x60,
2876 &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
2877 }
2878
2879
2880 /* DVB-USB and USB stuff follows */
2881 struct usb_device_id dib0700_usb_id_table[] = {
2882 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) },
2883 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P_PC) },
2884 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
2885 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
2886 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
2887 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
2888 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500) },
2889 { USB_DEVICE(USB_VID_UNIWILL, USB_PID_UNIWILL_STK7700P) },
2890 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
2891 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
2892 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
2893 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV2000E) },
2894 { USB_DEVICE(USB_VID_TERRATEC,
2895 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
2896 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
2897 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700D) },
2898 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070P) },
2899 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
2900 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070PD) },
2901 { USB_DEVICE(USB_VID_PINNACLE,
2902 USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
2903 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500_PC) },
2904 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
2905 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
2906 { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
2907 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000) },
2908 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100) },
2909 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
2910 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
2911 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
2912 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_EXPRESSCARD_320CX) },
2913 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV72E) },
2914 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73E) },
2915 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_EC372S) },
2916 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
2917 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS) },
2918 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
2919 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
2920 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
2921 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U8000) },
2922 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700PH) },
2923 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000H) },
2924 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E) },
2925 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E_SE) },
2926 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
2927 { USB_DEVICE(USB_VID_TERRATEC,
2928 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
2929 { USB_DEVICE(USB_VID_SONY, USB_PID_SONY_PLAYTV) },
2930 /* 45 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_PD378S) },
2931 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
2932 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
2933 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_MC770) },
2934 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT) },
2935 /* 50 */{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_Dlx) },
2936 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_H) },
2937 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T3) },
2938 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T5) },
2939 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D) },
2940 /* 55 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D_2) },
2941 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73A) },
2942 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV73ESE) },
2943 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV282E) },
2944 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7770P) },
2945 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS_2) },
2946 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XPVR) },
2947 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XP) },
2948 { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
2949 { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
2950 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73ESE) },
2951 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV282E) },
2952 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK8096GP) },
2953 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DIVERSITY) },
2954 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090M) },
2955 /* 70 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM8096MD) },
2956 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090MD) },
2957 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM7090) },
2958 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7090PVR) },
2959 { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
2960 /* 75 */{ USB_DEVICE(USB_VID_MEDION, USB_PID_CREATIX_CTX1921) },
2961 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E) },
2962 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E_SE) },
2963 { 0 } /* Terminating entry */
2964 };
2965 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
2966
2967 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
2968 .caps = DVB_USB_IS_AN_I2C_ADAPTER, \
2969 .usb_ctrl = DEVICE_SPECIFIC, \
2970 .firmware = "dvb-usb-dib0700-1.20.fw", \
2971 .download_firmware = dib0700_download_firmware, \
2972 .no_reconnect = 1, \
2973 .size_of_priv = sizeof(struct dib0700_state), \
2974 .i2c_algo = &dib0700_i2c_algo, \
2975 .identify_state = dib0700_identify_state
2976
2977 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
2978 .streaming_ctrl = dib0700_streaming_ctrl, \
2979 .stream = { \
2980 .type = USB_BULK, \
2981 .count = 4, \
2982 .endpoint = ep, \
2983 .u = { \
2984 .bulk = { \
2985 .buffersize = 39480, \
2986 } \
2987 } \
2988 }
2989
2990 struct dvb_usb_device_properties dib0700_devices[] = {
2991 {
2992 DIB0700_DEFAULT_DEVICE_PROPERTIES,
2993
2994 .num_adapters = 1,
2995 .adapter = {
2996 {
2997 .num_frontends = 1,
2998 .fe = {{
2999 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3000 .pid_filter_count = 32,
3001 .pid_filter = stk7700p_pid_filter,
3002 .pid_filter_ctrl = stk7700p_pid_filter_ctrl,
3003 .frontend_attach = stk7700p_frontend_attach,
3004 .tuner_attach = stk7700p_tuner_attach,
3005
3006 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3007 }},
3008 },
3009 },
3010
3011 .num_device_descs = 8,
3012 .devices = {
3013 { "DiBcom STK7700P reference design",
3014 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
3015 { NULL },
3016 },
3017 { "Hauppauge Nova-T Stick",
3018 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
3019 { NULL },
3020 },
3021 { "AVerMedia AVerTV DVB-T Volar",
3022 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
3023 { NULL },
3024 },
3025 { "Compro Videomate U500",
3026 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
3027 { NULL },
3028 },
3029 { "Uniwill STK7700P based (Hama and others)",
3030 { &dib0700_usb_id_table[7], NULL },
3031 { NULL },
3032 },
3033 { "Leadtek Winfast DTV Dongle (STK7700P based)",
3034 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
3035 { NULL },
3036 },
3037 { "AVerMedia AVerTV DVB-T Express",
3038 { &dib0700_usb_id_table[20] },
3039 { NULL },
3040 },
3041 { "Gigabyte U7000",
3042 { &dib0700_usb_id_table[21], NULL },
3043 { NULL },
3044 }
3045 },
3046
3047 .rc.core = {
3048 .rc_interval = DEFAULT_RC_INTERVAL,
3049 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3050 .rc_query = dib0700_rc_query_old_firmware,
3051 .allowed_protos = RC_TYPE_RC5 |
3052 RC_TYPE_RC6 |
3053 RC_TYPE_NEC,
3054 .change_protocol = dib0700_change_protocol,
3055 },
3056 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3057
3058 .num_adapters = 2,
3059 .adapter = {
3060 {
3061 .num_frontends = 1,
3062 .fe = {{
3063 .frontend_attach = bristol_frontend_attach,
3064 .tuner_attach = bristol_tuner_attach,
3065
3066 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3067 }},
3068 }, {
3069 .num_frontends = 1,
3070 .fe = {{
3071 .frontend_attach = bristol_frontend_attach,
3072 .tuner_attach = bristol_tuner_attach,
3073
3074 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3075 }},
3076 }
3077 },
3078
3079 .num_device_descs = 1,
3080 .devices = {
3081 { "Hauppauge Nova-T 500 Dual DVB-T",
3082 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
3083 { NULL },
3084 },
3085 },
3086
3087 .rc.core = {
3088 .rc_interval = DEFAULT_RC_INTERVAL,
3089 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3090 .rc_query = dib0700_rc_query_old_firmware,
3091 .allowed_protos = RC_TYPE_RC5 |
3092 RC_TYPE_RC6 |
3093 RC_TYPE_NEC,
3094 .change_protocol = dib0700_change_protocol,
3095 },
3096 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3097
3098 .num_adapters = 2,
3099 .adapter = {
3100 {
3101 .num_frontends = 1,
3102 .fe = {{
3103 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3104 .pid_filter_count = 32,
3105 .pid_filter = stk70x0p_pid_filter,
3106 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3107 .frontend_attach = stk7700d_frontend_attach,
3108 .tuner_attach = stk7700d_tuner_attach,
3109
3110 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3111 }},
3112 }, {
3113 .num_frontends = 1,
3114 .fe = {{
3115 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3116 .pid_filter_count = 32,
3117 .pid_filter = stk70x0p_pid_filter,
3118 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3119 .frontend_attach = stk7700d_frontend_attach,
3120 .tuner_attach = stk7700d_tuner_attach,
3121
3122 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3123 }},
3124 }
3125 },
3126
3127 .num_device_descs = 5,
3128 .devices = {
3129 { "Pinnacle PCTV 2000e",
3130 { &dib0700_usb_id_table[11], NULL },
3131 { NULL },
3132 },
3133 { "Terratec Cinergy DT XS Diversity",
3134 { &dib0700_usb_id_table[12], NULL },
3135 { NULL },
3136 },
3137 { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
3138 { &dib0700_usb_id_table[13], NULL },
3139 { NULL },
3140 },
3141 { "DiBcom STK7700D reference design",
3142 { &dib0700_usb_id_table[14], NULL },
3143 { NULL },
3144 },
3145 { "YUAN High-Tech DiBcom STK7700D",
3146 { &dib0700_usb_id_table[55], NULL },
3147 { NULL },
3148 },
3149
3150 },
3151
3152 .rc.core = {
3153 .rc_interval = DEFAULT_RC_INTERVAL,
3154 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3155 .rc_query = dib0700_rc_query_old_firmware,
3156 .allowed_protos = RC_TYPE_RC5 |
3157 RC_TYPE_RC6 |
3158 RC_TYPE_NEC,
3159 .change_protocol = dib0700_change_protocol,
3160 },
3161 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3162
3163 .num_adapters = 1,
3164 .adapter = {
3165 {
3166 .num_frontends = 1,
3167 .fe = {{
3168 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3169 .pid_filter_count = 32,
3170 .pid_filter = stk70x0p_pid_filter,
3171 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3172 .frontend_attach = stk7700P2_frontend_attach,
3173 .tuner_attach = stk7700d_tuner_attach,
3174
3175 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3176 }},
3177 },
3178 },
3179
3180 .num_device_descs = 3,
3181 .devices = {
3182 { "ASUS My Cinema U3000 Mini DVBT Tuner",
3183 { &dib0700_usb_id_table[23], NULL },
3184 { NULL },
3185 },
3186 { "Yuan EC372S",
3187 { &dib0700_usb_id_table[31], NULL },
3188 { NULL },
3189 },
3190 { "Terratec Cinergy T Express",
3191 { &dib0700_usb_id_table[42], NULL },
3192 { NULL },
3193 }
3194 },
3195
3196 .rc.core = {
3197 .rc_interval = DEFAULT_RC_INTERVAL,
3198 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3199 .module_name = "dib0700",
3200 .rc_query = dib0700_rc_query_old_firmware,
3201 .allowed_protos = RC_TYPE_RC5 |
3202 RC_TYPE_RC6 |
3203 RC_TYPE_NEC,
3204 .change_protocol = dib0700_change_protocol,
3205 },
3206 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3207
3208 .num_adapters = 1,
3209 .adapter = {
3210 {
3211 .num_frontends = 1,
3212 .fe = {{
3213 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3214 .pid_filter_count = 32,
3215 .pid_filter = stk70x0p_pid_filter,
3216 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3217 .frontend_attach = stk7070p_frontend_attach,
3218 .tuner_attach = dib7070p_tuner_attach,
3219
3220 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3221 }},
3222 .size_of_priv = sizeof(struct dib0700_adapter_state),
3223 },
3224 },
3225
3226 .num_device_descs = 11,
3227 .devices = {
3228 { "DiBcom STK7070P reference design",
3229 { &dib0700_usb_id_table[15], NULL },
3230 { NULL },
3231 },
3232 { "Pinnacle PCTV DVB-T Flash Stick",
3233 { &dib0700_usb_id_table[16], NULL },
3234 { NULL },
3235 },
3236 { "Artec T14BR DVB-T",
3237 { &dib0700_usb_id_table[22], NULL },
3238 { NULL },
3239 },
3240 { "ASUS My Cinema U3100 Mini DVBT Tuner",
3241 { &dib0700_usb_id_table[24], NULL },
3242 { NULL },
3243 },
3244 { "Hauppauge Nova-T Stick",
3245 { &dib0700_usb_id_table[25], NULL },
3246 { NULL },
3247 },
3248 { "Hauppauge Nova-T MyTV.t",
3249 { &dib0700_usb_id_table[26], NULL },
3250 { NULL },
3251 },
3252 { "Pinnacle PCTV 72e",
3253 { &dib0700_usb_id_table[29], NULL },
3254 { NULL },
3255 },
3256 { "Pinnacle PCTV 73e",
3257 { &dib0700_usb_id_table[30], NULL },
3258 { NULL },
3259 },
3260 { "Elgato EyeTV DTT",
3261 { &dib0700_usb_id_table[49], NULL },
3262 { NULL },
3263 },
3264 { "Yuan PD378S",
3265 { &dib0700_usb_id_table[45], NULL },
3266 { NULL },
3267 },
3268 { "Elgato EyeTV Dtt Dlx PD378S",
3269 { &dib0700_usb_id_table[50], NULL },
3270 { NULL },
3271 },
3272 },
3273
3274 .rc.core = {
3275 .rc_interval = DEFAULT_RC_INTERVAL,
3276 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3277 .module_name = "dib0700",
3278 .rc_query = dib0700_rc_query_old_firmware,
3279 .allowed_protos = RC_TYPE_RC5 |
3280 RC_TYPE_RC6 |
3281 RC_TYPE_NEC,
3282 .change_protocol = dib0700_change_protocol,
3283 },
3284 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3285
3286 .num_adapters = 1,
3287 .adapter = {
3288 {
3289 .num_frontends = 1,
3290 .fe = {{
3291 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3292 .pid_filter_count = 32,
3293 .pid_filter = stk70x0p_pid_filter,
3294 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3295 .frontend_attach = stk7070p_frontend_attach,
3296 .tuner_attach = dib7070p_tuner_attach,
3297
3298 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3299 }},
3300 .size_of_priv = sizeof(struct dib0700_adapter_state),
3301 },
3302 },
3303
3304 .num_device_descs = 3,
3305 .devices = {
3306 { "Pinnacle PCTV 73A",
3307 { &dib0700_usb_id_table[56], NULL },
3308 { NULL },
3309 },
3310 { "Pinnacle PCTV 73e SE",
3311 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
3312 { NULL },
3313 },
3314 { "Pinnacle PCTV 282e",
3315 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
3316 { NULL },
3317 },
3318 },
3319
3320 .rc.core = {
3321 .rc_interval = DEFAULT_RC_INTERVAL,
3322 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3323 .module_name = "dib0700",
3324 .rc_query = dib0700_rc_query_old_firmware,
3325 .allowed_protos = RC_TYPE_RC5 |
3326 RC_TYPE_RC6 |
3327 RC_TYPE_NEC,
3328 .change_protocol = dib0700_change_protocol,
3329 },
3330 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3331
3332 .num_adapters = 2,
3333 .adapter = {
3334 {
3335 .num_frontends = 1,
3336 .fe = {{
3337 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3338 .pid_filter_count = 32,
3339 .pid_filter = stk70x0p_pid_filter,
3340 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3341 .frontend_attach = stk7070pd_frontend_attach0,
3342 .tuner_attach = dib7070p_tuner_attach,
3343
3344 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3345 }},
3346 .size_of_priv = sizeof(struct dib0700_adapter_state),
3347 }, {
3348 .num_frontends = 1,
3349 .fe = {{
3350 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3351 .pid_filter_count = 32,
3352 .pid_filter = stk70x0p_pid_filter,
3353 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3354 .frontend_attach = stk7070pd_frontend_attach1,
3355 .tuner_attach = dib7070p_tuner_attach,
3356
3357 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3358 }},
3359 .size_of_priv = sizeof(struct dib0700_adapter_state),
3360 }
3361 },
3362
3363 .num_device_descs = 6,
3364 .devices = {
3365 { "DiBcom STK7070PD reference design",
3366 { &dib0700_usb_id_table[17], NULL },
3367 { NULL },
3368 },
3369 { "Pinnacle PCTV Dual DVB-T Diversity Stick",
3370 { &dib0700_usb_id_table[18], NULL },
3371 { NULL },
3372 },
3373 { "Hauppauge Nova-TD Stick (52009)",
3374 { &dib0700_usb_id_table[35], NULL },
3375 { NULL },
3376 },
3377 { "Hauppauge Nova-TD-500 (84xxx)",
3378 { &dib0700_usb_id_table[36], NULL },
3379 { NULL },
3380 },
3381 { "Terratec Cinergy DT USB XS Diversity/ T5",
3382 { &dib0700_usb_id_table[43],
3383 &dib0700_usb_id_table[53], NULL},
3384 { NULL },
3385 },
3386 { "Sony PlayTV",
3387 { &dib0700_usb_id_table[44], NULL },
3388 { NULL },
3389 },
3390 },
3391
3392 .rc.core = {
3393 .rc_interval = DEFAULT_RC_INTERVAL,
3394 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3395 .module_name = "dib0700",
3396 .rc_query = dib0700_rc_query_old_firmware,
3397 .allowed_protos = RC_TYPE_RC5 |
3398 RC_TYPE_RC6 |
3399 RC_TYPE_NEC,
3400 .change_protocol = dib0700_change_protocol,
3401 },
3402 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3403
3404 .num_adapters = 2,
3405 .adapter = {
3406 {
3407 .num_frontends = 1,
3408 .fe = {{
3409 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3410 .pid_filter_count = 32,
3411 .pid_filter = stk70x0p_pid_filter,
3412 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3413 .frontend_attach = stk7070pd_frontend_attach0,
3414 .tuner_attach = dib7070p_tuner_attach,
3415
3416 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3417 }},
3418 .size_of_priv = sizeof(struct dib0700_adapter_state),
3419 }, {
3420 .num_frontends = 1,
3421 .fe = {{
3422 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3423 .pid_filter_count = 32,
3424 .pid_filter = stk70x0p_pid_filter,
3425 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3426 .frontend_attach = stk7070pd_frontend_attach1,
3427 .tuner_attach = dib7070p_tuner_attach,
3428
3429 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3430 }},
3431 .size_of_priv = sizeof(struct dib0700_adapter_state),
3432 }
3433 },
3434
3435 .num_device_descs = 1,
3436 .devices = {
3437 { "Elgato EyeTV Diversity",
3438 { &dib0700_usb_id_table[68], NULL },
3439 { NULL },
3440 },
3441 },
3442
3443 .rc.core = {
3444 .rc_interval = DEFAULT_RC_INTERVAL,
3445 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
3446 .module_name = "dib0700",
3447 .rc_query = dib0700_rc_query_old_firmware,
3448 .allowed_protos = RC_TYPE_RC5 |
3449 RC_TYPE_RC6 |
3450 RC_TYPE_NEC,
3451 .change_protocol = dib0700_change_protocol,
3452 },
3453 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3454
3455 .num_adapters = 1,
3456 .adapter = {
3457 {
3458 .num_frontends = 1,
3459 .fe = {{
3460 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3461 .pid_filter_count = 32,
3462 .pid_filter = stk70x0p_pid_filter,
3463 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3464 .frontend_attach = stk7700ph_frontend_attach,
3465 .tuner_attach = stk7700ph_tuner_attach,
3466
3467 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3468 }},
3469 .size_of_priv = sizeof(struct
3470 dib0700_adapter_state),
3471 },
3472 },
3473
3474 .num_device_descs = 9,
3475 .devices = {
3476 { "Terratec Cinergy HT USB XE",
3477 { &dib0700_usb_id_table[27], NULL },
3478 { NULL },
3479 },
3480 { "Pinnacle Expresscard 320cx",
3481 { &dib0700_usb_id_table[28], NULL },
3482 { NULL },
3483 },
3484 { "Terratec Cinergy HT Express",
3485 { &dib0700_usb_id_table[32], NULL },
3486 { NULL },
3487 },
3488 { "Gigabyte U8000-RH",
3489 { &dib0700_usb_id_table[37], NULL },
3490 { NULL },
3491 },
3492 { "YUAN High-Tech STK7700PH",
3493 { &dib0700_usb_id_table[38], NULL },
3494 { NULL },
3495 },
3496 { "Asus My Cinema-U3000Hybrid",
3497 { &dib0700_usb_id_table[39], NULL },
3498 { NULL },
3499 },
3500 { "YUAN High-Tech MC770",
3501 { &dib0700_usb_id_table[48], NULL },
3502 { NULL },
3503 },
3504 { "Leadtek WinFast DTV Dongle H",
3505 { &dib0700_usb_id_table[51], NULL },
3506 { NULL },
3507 },
3508 { "YUAN High-Tech STK7700D",
3509 { &dib0700_usb_id_table[54], NULL },
3510 { NULL },
3511 },
3512 },
3513
3514 .rc.core = {
3515 .rc_interval = DEFAULT_RC_INTERVAL,
3516 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3517 .module_name = "dib0700",
3518 .rc_query = dib0700_rc_query_old_firmware,
3519 .allowed_protos = RC_TYPE_RC5 |
3520 RC_TYPE_RC6 |
3521 RC_TYPE_NEC,
3522 .change_protocol = dib0700_change_protocol,
3523 },
3524 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3525 .num_adapters = 1,
3526 .adapter = {
3527 {
3528 .num_frontends = 1,
3529 .fe = {{
3530 .frontend_attach = s5h1411_frontend_attach,
3531 .tuner_attach = xc5000_tuner_attach,
3532
3533 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3534 }},
3535 .size_of_priv = sizeof(struct
3536 dib0700_adapter_state),
3537 },
3538 },
3539
3540 .num_device_descs = 2,
3541 .devices = {
3542 { "Pinnacle PCTV HD Pro USB Stick",
3543 { &dib0700_usb_id_table[40], NULL },
3544 { NULL },
3545 },
3546 { "Pinnacle PCTV HD USB Stick",
3547 { &dib0700_usb_id_table[41], NULL },
3548 { NULL },
3549 },
3550 },
3551
3552 .rc.core = {
3553 .rc_interval = DEFAULT_RC_INTERVAL,
3554 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3555 .module_name = "dib0700",
3556 .rc_query = dib0700_rc_query_old_firmware,
3557 .allowed_protos = RC_TYPE_RC5 |
3558 RC_TYPE_RC6 |
3559 RC_TYPE_NEC,
3560 .change_protocol = dib0700_change_protocol,
3561 },
3562 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3563 .num_adapters = 1,
3564 .adapter = {
3565 {
3566 .num_frontends = 1,
3567 .fe = {{
3568 .frontend_attach = lgdt3305_frontend_attach,
3569 .tuner_attach = mxl5007t_tuner_attach,
3570
3571 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3572 }},
3573 .size_of_priv = sizeof(struct
3574 dib0700_adapter_state),
3575 },
3576 },
3577
3578 .num_device_descs = 2,
3579 .devices = {
3580 { "Hauppauge ATSC MiniCard (B200)",
3581 { &dib0700_usb_id_table[46], NULL },
3582 { NULL },
3583 },
3584 { "Hauppauge ATSC MiniCard (B210)",
3585 { &dib0700_usb_id_table[47], NULL },
3586 { NULL },
3587 },
3588 },
3589 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3590
3591 .num_adapters = 1,
3592 .adapter = {
3593 {
3594 .num_frontends = 1,
3595 .fe = {{
3596 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3597 .pid_filter_count = 32,
3598 .pid_filter = stk70x0p_pid_filter,
3599 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3600 .frontend_attach = stk7770p_frontend_attach,
3601 .tuner_attach = dib7770p_tuner_attach,
3602
3603 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3604 }},
3605 .size_of_priv =
3606 sizeof(struct dib0700_adapter_state),
3607 },
3608 },
3609
3610 .num_device_descs = 4,
3611 .devices = {
3612 { "DiBcom STK7770P reference design",
3613 { &dib0700_usb_id_table[59], NULL },
3614 { NULL },
3615 },
3616 { "Terratec Cinergy T USB XXS (HD)/ T3",
3617 { &dib0700_usb_id_table[33],
3618 &dib0700_usb_id_table[52],
3619 &dib0700_usb_id_table[60], NULL},
3620 { NULL },
3621 },
3622 { "TechniSat AirStar TeleStick 2",
3623 { &dib0700_usb_id_table[74], NULL },
3624 { NULL },
3625 },
3626 { "Medion CTX1921 DVB-T USB",
3627 { &dib0700_usb_id_table[75], NULL },
3628 { NULL },
3629 },
3630 },
3631
3632 .rc.core = {
3633 .rc_interval = DEFAULT_RC_INTERVAL,
3634 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3635 .module_name = "dib0700",
3636 .rc_query = dib0700_rc_query_old_firmware,
3637 .allowed_protos = RC_TYPE_RC5 |
3638 RC_TYPE_RC6 |
3639 RC_TYPE_NEC,
3640 .change_protocol = dib0700_change_protocol,
3641 },
3642 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3643 .num_adapters = 1,
3644 .adapter = {
3645 {
3646 .num_frontends = 1,
3647 .fe = {{
3648 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3649 .pid_filter_count = 32,
3650 .pid_filter = stk80xx_pid_filter,
3651 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3652 .frontend_attach = stk807x_frontend_attach,
3653 .tuner_attach = dib807x_tuner_attach,
3654
3655 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3656 }},
3657 .size_of_priv =
3658 sizeof(struct dib0700_adapter_state),
3659 },
3660 },
3661
3662 .num_device_descs = 3,
3663 .devices = {
3664 { "DiBcom STK807xP reference design",
3665 { &dib0700_usb_id_table[62], NULL },
3666 { NULL },
3667 },
3668 { "Prolink Pixelview SBTVD",
3669 { &dib0700_usb_id_table[63], NULL },
3670 { NULL },
3671 },
3672 { "EvolutePC TVWay+",
3673 { &dib0700_usb_id_table[64], NULL },
3674 { NULL },
3675 },
3676 },
3677
3678 .rc.core = {
3679 .rc_interval = DEFAULT_RC_INTERVAL,
3680 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
3681 .module_name = "dib0700",
3682 .rc_query = dib0700_rc_query_old_firmware,
3683 .allowed_protos = RC_TYPE_RC5 |
3684 RC_TYPE_RC6 |
3685 RC_TYPE_NEC,
3686 .change_protocol = dib0700_change_protocol,
3687 },
3688 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3689 .num_adapters = 2,
3690 .adapter = {
3691 {
3692 .num_frontends = 1,
3693 .fe = {{
3694 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3695 .pid_filter_count = 32,
3696 .pid_filter = stk80xx_pid_filter,
3697 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3698 .frontend_attach = stk807xpvr_frontend_attach0,
3699 .tuner_attach = dib807x_tuner_attach,
3700
3701 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3702 }},
3703 .size_of_priv =
3704 sizeof(struct dib0700_adapter_state),
3705 },
3706 {
3707 .num_frontends = 1,
3708 .fe = {{
3709 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3710 .pid_filter_count = 32,
3711 .pid_filter = stk80xx_pid_filter,
3712 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3713 .frontend_attach = stk807xpvr_frontend_attach1,
3714 .tuner_attach = dib807x_tuner_attach,
3715
3716 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3717 }},
3718 .size_of_priv =
3719 sizeof(struct dib0700_adapter_state),
3720 },
3721 },
3722
3723 .num_device_descs = 1,
3724 .devices = {
3725 { "DiBcom STK807xPVR reference design",
3726 { &dib0700_usb_id_table[61], NULL },
3727 { NULL },
3728 },
3729 },
3730
3731 .rc.core = {
3732 .rc_interval = DEFAULT_RC_INTERVAL,
3733 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3734 .module_name = "dib0700",
3735 .rc_query = dib0700_rc_query_old_firmware,
3736 .allowed_protos = RC_TYPE_RC5 |
3737 RC_TYPE_RC6 |
3738 RC_TYPE_NEC,
3739 .change_protocol = dib0700_change_protocol,
3740 },
3741 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3742 .num_adapters = 1,
3743 .adapter = {
3744 {
3745 .num_frontends = 1,
3746 .fe = {{
3747 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
3748 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3749 .pid_filter_count = 32,
3750 .pid_filter = stk80xx_pid_filter,
3751 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3752 .frontend_attach = stk809x_frontend_attach,
3753 .tuner_attach = dib809x_tuner_attach,
3754
3755 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3756 }},
3757 .size_of_priv =
3758 sizeof(struct dib0700_adapter_state),
3759 },
3760 },
3761
3762 .num_device_descs = 1,
3763 .devices = {
3764 { "DiBcom STK8096GP reference design",
3765 { &dib0700_usb_id_table[67], NULL },
3766 { NULL },
3767 },
3768 },
3769
3770 .rc.core = {
3771 .rc_interval = DEFAULT_RC_INTERVAL,
3772 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3773 .module_name = "dib0700",
3774 .rc_query = dib0700_rc_query_old_firmware,
3775 .allowed_protos = RC_TYPE_RC5 |
3776 RC_TYPE_RC6 |
3777 RC_TYPE_NEC,
3778 .change_protocol = dib0700_change_protocol,
3779 },
3780 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3781 .num_adapters = 1,
3782 .adapter = {
3783 {
3784 .num_frontends = 1,
3785 .fe = {{
3786 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
3787 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3788 .pid_filter_count = 32,
3789 .pid_filter = dib90x0_pid_filter,
3790 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
3791 .frontend_attach = stk9090m_frontend_attach,
3792 .tuner_attach = dib9090_tuner_attach,
3793
3794 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3795 }},
3796 .size_of_priv =
3797 sizeof(struct dib0700_adapter_state),
3798 },
3799 },
3800
3801 .num_device_descs = 1,
3802 .devices = {
3803 { "DiBcom STK9090M reference design",
3804 { &dib0700_usb_id_table[69], NULL },
3805 { NULL },
3806 },
3807 },
3808
3809 .rc.core = {
3810 .rc_interval = DEFAULT_RC_INTERVAL,
3811 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3812 .module_name = "dib0700",
3813 .rc_query = dib0700_rc_query_old_firmware,
3814 .allowed_protos = RC_TYPE_RC5 |
3815 RC_TYPE_RC6 |
3816 RC_TYPE_NEC,
3817 .change_protocol = dib0700_change_protocol,
3818 },
3819 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3820 .num_adapters = 1,
3821 .adapter = {
3822 {
3823 .num_frontends = 1,
3824 .fe = {{
3825 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
3826 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3827 .pid_filter_count = 32,
3828 .pid_filter = stk80xx_pid_filter,
3829 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
3830 .frontend_attach = nim8096md_frontend_attach,
3831 .tuner_attach = nim8096md_tuner_attach,
3832
3833 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3834 }},
3835 .size_of_priv =
3836 sizeof(struct dib0700_adapter_state),
3837 },
3838 },
3839
3840 .num_device_descs = 1,
3841 .devices = {
3842 { "DiBcom NIM8096MD reference design",
3843 { &dib0700_usb_id_table[70], NULL },
3844 { NULL },
3845 },
3846 },
3847
3848 .rc.core = {
3849 .rc_interval = DEFAULT_RC_INTERVAL,
3850 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3851 .module_name = "dib0700",
3852 .rc_query = dib0700_rc_query_old_firmware,
3853 .allowed_protos = RC_TYPE_RC5 |
3854 RC_TYPE_RC6 |
3855 RC_TYPE_NEC,
3856 .change_protocol = dib0700_change_protocol,
3857 },
3858 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3859 .num_adapters = 1,
3860 .adapter = {
3861 {
3862 .num_frontends = 1,
3863 .fe = {{
3864 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
3865 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3866 .pid_filter_count = 32,
3867 .pid_filter = dib90x0_pid_filter,
3868 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
3869 .frontend_attach = nim9090md_frontend_attach,
3870 .tuner_attach = nim9090md_tuner_attach,
3871
3872 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3873 }},
3874 .size_of_priv =
3875 sizeof(struct dib0700_adapter_state),
3876 },
3877 },
3878
3879 .num_device_descs = 1,
3880 .devices = {
3881 { "DiBcom NIM9090MD reference design",
3882 { &dib0700_usb_id_table[71], NULL },
3883 { NULL },
3884 },
3885 },
3886
3887 .rc.core = {
3888 .rc_interval = DEFAULT_RC_INTERVAL,
3889 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3890 .module_name = "dib0700",
3891 .rc_query = dib0700_rc_query_old_firmware,
3892 .allowed_protos = RC_TYPE_RC5 |
3893 RC_TYPE_RC6 |
3894 RC_TYPE_NEC,
3895 .change_protocol = dib0700_change_protocol,
3896 },
3897 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3898 .num_adapters = 1,
3899 .adapter = {
3900 {
3901 .num_frontends = 1,
3902 .fe = {{
3903 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
3904 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3905 .pid_filter_count = 32,
3906 .pid_filter = stk70x0p_pid_filter,
3907 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3908 .frontend_attach = nim7090_frontend_attach,
3909 .tuner_attach = nim7090_tuner_attach,
3910
3911 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3912 }},
3913 .size_of_priv =
3914 sizeof(struct dib0700_adapter_state),
3915 },
3916 },
3917
3918 .num_device_descs = 1,
3919 .devices = {
3920 { "DiBcom NIM7090 reference design",
3921 { &dib0700_usb_id_table[72], NULL },
3922 { NULL },
3923 },
3924 },
3925
3926 .rc.core = {
3927 .rc_interval = DEFAULT_RC_INTERVAL,
3928 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3929 .module_name = "dib0700",
3930 .rc_query = dib0700_rc_query_old_firmware,
3931 .allowed_protos = RC_TYPE_RC5 |
3932 RC_TYPE_RC6 |
3933 RC_TYPE_NEC,
3934 .change_protocol = dib0700_change_protocol,
3935 },
3936 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3937 .num_adapters = 2,
3938 .adapter = {
3939 {
3940 .num_frontends = 1,
3941 .fe = {{
3942 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
3943 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3944 .pid_filter_count = 32,
3945 .pid_filter = stk70x0p_pid_filter,
3946 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3947 .frontend_attach = tfe7090pvr_frontend0_attach,
3948 .tuner_attach = tfe7090pvr_tuner0_attach,
3949
3950 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3951 }},
3952 .size_of_priv =
3953 sizeof(struct dib0700_adapter_state),
3954 },
3955 {
3956 .num_frontends = 1,
3957 .fe = {{
3958 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
3959 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3960 .pid_filter_count = 32,
3961 .pid_filter = stk70x0p_pid_filter,
3962 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3963 .frontend_attach = tfe7090pvr_frontend1_attach,
3964 .tuner_attach = tfe7090pvr_tuner1_attach,
3965
3966 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3967 }},
3968 .size_of_priv =
3969 sizeof(struct dib0700_adapter_state),
3970 },
3971 },
3972
3973 .num_device_descs = 1,
3974 .devices = {
3975 { "DiBcom TFE7090PVR reference design",
3976 { &dib0700_usb_id_table[73], NULL },
3977 { NULL },
3978 },
3979 },
3980
3981 .rc.core = {
3982 .rc_interval = DEFAULT_RC_INTERVAL,
3983 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3984 .module_name = "dib0700",
3985 .rc_query = dib0700_rc_query_old_firmware,
3986 .allowed_protos = RC_TYPE_RC5 |
3987 RC_TYPE_RC6 |
3988 RC_TYPE_NEC,
3989 .change_protocol = dib0700_change_protocol,
3990 },
3991 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3992 .num_adapters = 1,
3993 .adapter = {
3994 {
3995 .num_frontends = 1,
3996 .fe = {{
3997 .frontend_attach = pctv340e_frontend_attach,
3998 .tuner_attach = xc4000_tuner_attach,
3999
4000 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4001 }},
4002 .size_of_priv = sizeof(struct
4003 dib0700_adapter_state),
4004 },
4005 },
4006
4007 .num_device_descs = 2,
4008 .devices = {
4009 { "Pinnacle PCTV 340e HD Pro USB Stick",
4010 { &dib0700_usb_id_table[76], NULL },
4011 { NULL },
4012 },
4013 { "Pinnacle PCTV Hybrid Stick Solo",
4014 { &dib0700_usb_id_table[77], NULL },
4015 { NULL },
4016 },
4017 },
4018 .rc.core = {
4019 .rc_interval = DEFAULT_RC_INTERVAL,
4020 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4021 .module_name = "dib0700",
4022 .rc_query = dib0700_rc_query_old_firmware,
4023 .allowed_protos = RC_TYPE_RC5 |
4024 RC_TYPE_RC6 |
4025 RC_TYPE_NEC,
4026 .change_protocol = dib0700_change_protocol,
4027 },
4028 },
4029 };
4030
4031 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
Linux kernel - Deliverables
This page took 0.131618 seconds and 5 git commands to generate.