?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / media / usb / dvb-usb / dib0700_devices.c
blob829323e42ca095671372ec15de5cea81a4810fea
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 *);
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_BIT_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)
808 {
809 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
810 struct dvb_usb_adapter *adap = fe->dvb->priv;
811 struct dib0700_adapter_state *state = adap->priv;
812
813 u16 offset;
814 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
815 switch (band) {
816 case BAND_VHF: offset = 950; break;
817 case BAND_UHF:
818 default: offset = 550; break;
819 }
820 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
821 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
822 return state->set_param_save(fe);
823 }
824
825 static int dib7770_set_param_override(struct dvb_frontend *fe)
826 {
827 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
828 struct dvb_usb_adapter *adap = fe->dvb->priv;
829 struct dib0700_adapter_state *state = adap->priv;
830
831 u16 offset;
832 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
833 switch (band) {
834 case BAND_VHF:
835 dib7000p_set_gpio(fe, 0, 0, 1);
836 offset = 850;
837 break;
838 case BAND_UHF:
839 default:
840 dib7000p_set_gpio(fe, 0, 0, 0);
841 offset = 250;
842 break;
843 }
844 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
845 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
846 return state->set_param_save(fe);
847 }
848
849 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
850 {
851 struct dib0700_adapter_state *st = adap->priv;
852 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
853 DIBX000_I2C_INTERFACE_TUNER, 1);
854
855 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
856 &dib7770p_dib0070_config) == NULL)
857 return -ENODEV;
858
859 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
860 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
861 return 0;
862 }
863
864 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
865 {
866 struct dib0700_adapter_state *st = adap->priv;
867 struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
868
869 if (adap->id == 0) {
870 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
871 return -ENODEV;
872 } else {
873 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
874 return -ENODEV;
875 }
876
877 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
878 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
879 return 0;
880 }
881
882 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
883 u16 pid, int onoff)
884 {
885 struct dib0700_state *st = adapter->dev->priv;
886 if (st->is_dib7000pc)
887 return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
888 return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
889 }
890
891 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
892 {
893 struct dib0700_state *st = adapter->dev->priv;
894 if (st->is_dib7000pc)
895 return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
896 return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
897 }
898
899 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
900 {
901 return dib7000p_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
902 }
903
904 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
905 {
906 return dib7000p_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
907 }
908
909 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
910 60000, 15000,
911 1, 20, 3, 1, 0,
912 0, 0, 1, 1, 2,
913 (3 << 14) | (1 << 12) | (524 << 0),
914 (0 << 25) | 0,
915 20452225,
916 12000000,
917 };
918
919 static struct dib7000p_config dib7070p_dib7000p_config = {
920 .output_mpeg2_in_188_bytes = 1,
921
922 .agc_config_count = 1,
923 .agc = &dib7070_agc_config,
924 .bw = &dib7070_bw_config_12_mhz,
925 .tuner_is_baseband = 1,
926 .spur_protect = 1,
927
928 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
929 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
930 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
931
932 .hostbus_diversity = 1,
933 };
934
935 /* STK7070P */
936 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
937 {
938 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
939 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
940 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
941 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
942 else
943 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
944 msleep(10);
945 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
946 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
947 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
948 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
949
950 dib0700_ctrl_clock(adap->dev, 72, 1);
951
952 msleep(10);
953 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
954 msleep(10);
955 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
956
957 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
958 &dib7070p_dib7000p_config) != 0) {
959 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
960 __func__);
961 return -ENODEV;
962 }
963
964 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
965 &dib7070p_dib7000p_config);
966 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
967 }
968
969 /* STK7770P */
970 static struct dib7000p_config dib7770p_dib7000p_config = {
971 .output_mpeg2_in_188_bytes = 1,
972
973 .agc_config_count = 1,
974 .agc = &dib7070_agc_config,
975 .bw = &dib7070_bw_config_12_mhz,
976 .tuner_is_baseband = 1,
977 .spur_protect = 1,
978
979 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
980 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
981 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
982
983 .hostbus_diversity = 1,
984 .enable_current_mirror = 1,
985 .disable_sample_and_hold = 0,
986 };
987
988 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
989 {
990 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
991 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
992 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
993 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
994 else
995 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
996 msleep(10);
997 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
998 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
999 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1000 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1001
1002 dib0700_ctrl_clock(adap->dev, 72, 1);
1003
1004 msleep(10);
1005 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1006 msleep(10);
1007 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1008
1009 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1010 &dib7770p_dib7000p_config) != 0) {
1011 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
1012 __func__);
1013 return -ENODEV;
1014 }
1015
1016 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1017 &dib7770p_dib7000p_config);
1018 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1019 }
1020
1021 /* DIB807x generic */
1022 static struct dibx000_agc_config dib807x_agc_config[2] = {
1023 {
1024 BAND_VHF,
1025 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1026 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1027 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1028 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1029 * P_agc_write=0 */
1030 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1031 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1032 (0 << 0), /* setup*/
1033
1034 600, /* inv_gain*/
1035 10, /* time_stabiliz*/
1036
1037 0, /* alpha_level*/
1038 118, /* thlock*/
1039
1040 0, /* wbd_inv*/
1041 3530, /* wbd_ref*/
1042 1, /* wbd_sel*/
1043 5, /* wbd_alpha*/
1044
1045 65535, /* agc1_max*/
1046 0, /* agc1_min*/
1047
1048 65535, /* agc2_max*/
1049 0, /* agc2_min*/
1050
1051 0, /* agc1_pt1*/
1052 40, /* agc1_pt2*/
1053 183, /* agc1_pt3*/
1054 206, /* agc1_slope1*/
1055 255, /* agc1_slope2*/
1056 72, /* agc2_pt1*/
1057 152, /* agc2_pt2*/
1058 88, /* agc2_slope1*/
1059 90, /* agc2_slope2*/
1060
1061 17, /* alpha_mant*/
1062 27, /* alpha_exp*/
1063 23, /* beta_mant*/
1064 51, /* beta_exp*/
1065
1066 0, /* perform_agc_softsplit*/
1067 }, {
1068 BAND_UHF,
1069 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1070 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1071 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1072 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1073 * P_agc_write=0 */
1074 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1075 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1076 (0 << 0), /* setup */
1077
1078 600, /* inv_gain*/
1079 10, /* time_stabiliz*/
1080
1081 0, /* alpha_level*/
1082 118, /* thlock*/
1083
1084 0, /* wbd_inv*/
1085 3530, /* wbd_ref*/
1086 1, /* wbd_sel*/
1087 5, /* wbd_alpha*/
1088
1089 65535, /* agc1_max*/
1090 0, /* agc1_min*/
1091
1092 65535, /* agc2_max*/
1093 0, /* agc2_min*/
1094
1095 0, /* agc1_pt1*/
1096 40, /* agc1_pt2*/
1097 183, /* agc1_pt3*/
1098 206, /* agc1_slope1*/
1099 255, /* agc1_slope2*/
1100 72, /* agc2_pt1*/
1101 152, /* agc2_pt2*/
1102 88, /* agc2_slope1*/
1103 90, /* agc2_slope2*/
1104
1105 17, /* alpha_mant*/
1106 27, /* alpha_exp*/
1107 23, /* beta_mant*/
1108 51, /* beta_exp*/
1109
1110 0, /* perform_agc_softsplit*/
1111 }
1112 };
1113
1114 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1115 60000, 15000, /* internal, sampling*/
1116 1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
1117 0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
1118 ADClkSrc, modulo */
1119 (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1120 (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1121 18179755, /* timf*/
1122 12000000, /* xtal_hz*/
1123 };
1124
1125 static struct dib8000_config dib807x_dib8000_config[2] = {
1126 {
1127 .output_mpeg2_in_188_bytes = 1,
1128
1129 .agc_config_count = 2,
1130 .agc = dib807x_agc_config,
1131 .pll = &dib807x_bw_config_12_mhz,
1132 .tuner_is_baseband = 1,
1133
1134 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1135 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1136 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1137
1138 .hostbus_diversity = 1,
1139 .div_cfg = 1,
1140 .agc_control = &dib0070_ctrl_agc_filter,
1141 .output_mode = OUTMODE_MPEG2_FIFO,
1142 .drives = 0x2d98,
1143 }, {
1144 .output_mpeg2_in_188_bytes = 1,
1145
1146 .agc_config_count = 2,
1147 .agc = dib807x_agc_config,
1148 .pll = &dib807x_bw_config_12_mhz,
1149 .tuner_is_baseband = 1,
1150
1151 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1152 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1153 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1154
1155 .hostbus_diversity = 1,
1156 .agc_control = &dib0070_ctrl_agc_filter,
1157 .output_mode = OUTMODE_MPEG2_FIFO,
1158 .drives = 0x2d98,
1159 }
1160 };
1161
1162 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1163 {
1164 return dib8000_set_gpio(fe, 5, 0, !onoff);
1165 }
1166
1167 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1168 {
1169 return dib8000_set_gpio(fe, 0, 0, onoff);
1170 }
1171
1172 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1173 { 240, 7},
1174 { 0xffff, 6},
1175 };
1176
1177 static struct dib0070_config dib807x_dib0070_config[2] = {
1178 {
1179 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1180 .reset = dib80xx_tuner_reset,
1181 .sleep = dib80xx_tuner_sleep,
1182 .clock_khz = 12000,
1183 .clock_pad_drive = 4,
1184 .vga_filter = 1,
1185 .force_crystal_mode = 1,
1186 .enable_third_order_filter = 1,
1187 .charge_pump = 0,
1188 .wbd_gain = dib8070_wbd_gain_cfg,
1189 .osc_buffer_state = 0,
1190 .freq_offset_khz_uhf = -100,
1191 .freq_offset_khz_vhf = -100,
1192 }, {
1193 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1194 .reset = dib80xx_tuner_reset,
1195 .sleep = dib80xx_tuner_sleep,
1196 .clock_khz = 12000,
1197 .clock_pad_drive = 2,
1198 .vga_filter = 1,
1199 .force_crystal_mode = 1,
1200 .enable_third_order_filter = 1,
1201 .charge_pump = 0,
1202 .wbd_gain = dib8070_wbd_gain_cfg,
1203 .osc_buffer_state = 0,
1204 .freq_offset_khz_uhf = -25,
1205 .freq_offset_khz_vhf = -25,
1206 }
1207 };
1208
1209 static int dib807x_set_param_override(struct dvb_frontend *fe)
1210 {
1211 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1212 struct dvb_usb_adapter *adap = fe->dvb->priv;
1213 struct dib0700_adapter_state *state = adap->priv;
1214
1215 u16 offset = dib0070_wbd_offset(fe);
1216 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1217 switch (band) {
1218 case BAND_VHF:
1219 offset += 750;
1220 break;
1221 case BAND_UHF: /* fall-thru wanted */
1222 default:
1223 offset += 250; break;
1224 }
1225 deb_info("WBD for DiB8000: %d\n", offset);
1226 dib8000_set_wbd_ref(fe, offset);
1227
1228 return state->set_param_save(fe);
1229 }
1230
1231 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1232 {
1233 struct dib0700_adapter_state *st = adap->priv;
1234 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe,
1235 DIBX000_I2C_INTERFACE_TUNER, 1);
1236
1237 if (adap->id == 0) {
1238 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1239 &dib807x_dib0070_config[0]) == NULL)
1240 return -ENODEV;
1241 } else {
1242 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1243 &dib807x_dib0070_config[1]) == NULL)
1244 return -ENODEV;
1245 }
1246
1247 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1248 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1249 return 0;
1250 }
1251
1252 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1253 u16 pid, int onoff)
1254 {
1255 return dib8000_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1256 }
1257
1258 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1259 int onoff)
1260 {
1261 return dib8000_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1262 }
1263
1264 /* STK807x */
1265 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1266 {
1267 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1268 msleep(10);
1269 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1270 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1271 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1272
1273 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1274
1275 dib0700_ctrl_clock(adap->dev, 72, 1);
1276
1277 msleep(10);
1278 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1279 msleep(10);
1280 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1281
1282 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1283 0x80, 0);
1284
1285 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1286 &dib807x_dib8000_config[0]);
1287
1288 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1289 }
1290
1291 /* STK807xPVR */
1292 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1293 {
1294 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1295 msleep(30);
1296 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1297 msleep(500);
1298 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1299 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1300 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1301
1302 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1303
1304 dib0700_ctrl_clock(adap->dev, 72, 1);
1305
1306 msleep(10);
1307 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1308 msleep(10);
1309 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1310
1311 /* initialize IC 0 */
1312 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0);
1313
1314 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
1315 &dib807x_dib8000_config[0]);
1316
1317 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1318 }
1319
1320 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1321 {
1322 /* initialize IC 1 */
1323 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0);
1324
1325 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
1326 &dib807x_dib8000_config[1]);
1327
1328 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1329 }
1330
1331 /* STK8096GP */
1332 static struct dibx000_agc_config dib8090_agc_config[2] = {
1333 {
1334 BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1335 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1336 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1337 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1338 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1339 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1340
1341 787,
1342 10,
1343
1344 0,
1345 118,
1346
1347 0,
1348 3530,
1349 1,
1350 5,
1351
1352 65535,
1353 0,
1354
1355 65535,
1356 0,
1357
1358 0,
1359 32,
1360 114,
1361 143,
1362 144,
1363 114,
1364 227,
1365 116,
1366 117,
1367
1368 28,
1369 26,
1370 31,
1371 51,
1372
1373 0,
1374 },
1375 {
1376 BAND_CBAND,
1377 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1378 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1379 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1380 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1381 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1382
1383 787,
1384 10,
1385
1386 0,
1387 118,
1388
1389 0,
1390 3530,
1391 1,
1392 5,
1393
1394 0,
1395 0,
1396
1397 65535,
1398 0,
1399
1400 0,
1401 32,
1402 114,
1403 143,
1404 144,
1405 114,
1406 227,
1407 116,
1408 117,
1409
1410 28,
1411 26,
1412 31,
1413 51,
1414
1415 0,
1416 }
1417 };
1418
1419 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1420 54000, 13500,
1421 1, 18, 3, 1, 0,
1422 0, 0, 1, 1, 2,
1423 (3 << 14) | (1 << 12) | (599 << 0),
1424 (0 << 25) | 0,
1425 20199727,
1426 12000000,
1427 };
1428
1429 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1430 {
1431 return dib8000_get_adc_power(fe, 1);
1432 }
1433
1434 static void dib8090_agc_control(struct dvb_frontend *fe, u8 restart)
1435 {
1436 deb_info("AGC control callback: %i\n", restart);
1437 dib0090_dcc_freq(fe, restart);
1438
1439 if (restart == 0) /* before AGC startup */
1440 dib0090_set_dc_servo(fe, 1);
1441 }
1442
1443 static struct dib8000_config dib809x_dib8000_config[2] = {
1444 {
1445 .output_mpeg2_in_188_bytes = 1,
1446
1447 .agc_config_count = 2,
1448 .agc = dib8090_agc_config,
1449 .agc_control = dib8090_agc_control,
1450 .pll = &dib8090_pll_config_12mhz,
1451 .tuner_is_baseband = 1,
1452
1453 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1454 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1455 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1456
1457 .hostbus_diversity = 1,
1458 .div_cfg = 0x31,
1459 .output_mode = OUTMODE_MPEG2_FIFO,
1460 .drives = 0x2d98,
1461 .diversity_delay = 48,
1462 .refclksel = 3,
1463 }, {
1464 .output_mpeg2_in_188_bytes = 1,
1465
1466 .agc_config_count = 2,
1467 .agc = dib8090_agc_config,
1468 .agc_control = dib8090_agc_control,
1469 .pll = &dib8090_pll_config_12mhz,
1470 .tuner_is_baseband = 1,
1471
1472 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1473 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1474 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1475
1476 .hostbus_diversity = 1,
1477 .div_cfg = 0x31,
1478 .output_mode = OUTMODE_DIVERSITY,
1479 .drives = 0x2d08,
1480 .diversity_delay = 1,
1481 .refclksel = 3,
1482 }
1483 };
1484
1485 static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1486 /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1487 { 120, 0, 500, 0, 500, 4 }, /* CBAND */
1488 { 170, 0, 450, 0, 450, 4 }, /* CBAND */
1489 { 380, 48, 373, 28, 259, 6 }, /* VHF */
1490 { 860, 34, 700, 36, 616, 6 }, /* high UHF */
1491 { 0xFFFF, 34, 700, 36, 616, 6 }, /* default */
1492 };
1493
1494 static struct dib0090_config dib809x_dib0090_config = {
1495 .io.pll_bypass = 1,
1496 .io.pll_range = 1,
1497 .io.pll_prediv = 1,
1498 .io.pll_loopdiv = 20,
1499 .io.adc_clock_ratio = 8,
1500 .io.pll_int_loop_filt = 0,
1501 .io.clock_khz = 12000,
1502 .reset = dib80xx_tuner_reset,
1503 .sleep = dib80xx_tuner_sleep,
1504 .clkouttobamse = 1,
1505 .analog_output = 1,
1506 .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1507 .use_pwm_agc = 1,
1508 .clkoutdrive = 1,
1509 .get_adc_power = dib8090_get_adc_power,
1510 .freq_offset_khz_uhf = -63,
1511 .freq_offset_khz_vhf = -143,
1512 .wbd = dib8090_wbd_table,
1513 .fref_clock_ratio = 6,
1514 };
1515
1516 static u8 dib8090_compute_pll_parameters(struct dvb_frontend *fe)
1517 {
1518 u8 optimal_pll_ratio = 20;
1519 u32 freq_adc, ratio, rest, max = 0;
1520 u8 pll_ratio;
1521
1522 for (pll_ratio = 17; pll_ratio <= 20; pll_ratio++) {
1523 freq_adc = 12 * pll_ratio * (1 << 8) / 16;
1524 ratio = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) / freq_adc;
1525 rest = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) - ratio * freq_adc;
1526
1527 if (rest > freq_adc / 2)
1528 rest = freq_adc - rest;
1529 deb_info("PLL ratio=%i rest=%i\n", pll_ratio, rest);
1530 if ((rest > max) && (rest > 717)) {
1531 optimal_pll_ratio = pll_ratio;
1532 max = rest;
1533 }
1534 }
1535 deb_info("optimal PLL ratio=%i\n", optimal_pll_ratio);
1536
1537 return optimal_pll_ratio;
1538 }
1539
1540 static int dib8096_set_param_override(struct dvb_frontend *fe)
1541 {
1542 struct dvb_usb_adapter *adap = fe->dvb->priv;
1543 struct dib0700_adapter_state *state = adap->priv;
1544 u8 pll_ratio, band = BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000);
1545 u16 target, ltgain, rf_gain_limit;
1546 u32 timf;
1547 int ret = 0;
1548 enum frontend_tune_state tune_state = CT_SHUTDOWN;
1549
1550 switch (band) {
1551 default:
1552 deb_info("Warning : Rf frequency (%iHz) is not in the supported range, using VHF switch ", fe->dtv_property_cache.frequency);
1553 case BAND_VHF:
1554 dib8000_set_gpio(fe, 3, 0, 1);
1555 break;
1556 case BAND_UHF:
1557 dib8000_set_gpio(fe, 3, 0, 0);
1558 break;
1559 }
1560
1561 ret = state->set_param_save(fe);
1562 if (ret < 0)
1563 return ret;
1564
1565 if (fe->dtv_property_cache.bandwidth_hz != 6000000) {
1566 deb_info("only 6MHz bandwidth is supported\n");
1567 return -EINVAL;
1568 }
1569
1570 /** Update PLL if needed ratio **/
1571 dib8000_update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
1572
1573 /** Get optimize PLL ratio to remove spurious **/
1574 pll_ratio = dib8090_compute_pll_parameters(fe);
1575 if (pll_ratio == 17)
1576 timf = 21387946;
1577 else if (pll_ratio == 18)
1578 timf = 20199727;
1579 else if (pll_ratio == 19)
1580 timf = 19136583;
1581 else
1582 timf = 18179756;
1583
1584 /** Update ratio **/
1585 dib8000_update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio);
1586
1587 dib8000_ctrl_timf(fe, DEMOD_TIMF_SET, timf);
1588
1589 if (band != BAND_CBAND) {
1590 /* dib0090_get_wbd_target is returning any possible temperature compensated wbd-target */
1591 target = (dib0090_get_wbd_target(fe) * 8 * 18 / 33 + 1) / 2;
1592 dib8000_set_wbd_ref(fe, target);
1593 }
1594
1595 if (band == BAND_CBAND) {
1596 deb_info("tuning in CBAND - soft-AGC startup\n");
1597 dib0090_set_tune_state(fe, CT_AGC_START);
1598
1599 do {
1600 ret = dib0090_gain_control(fe);
1601 msleep(ret);
1602 tune_state = dib0090_get_tune_state(fe);
1603 if (tune_state == CT_AGC_STEP_0)
1604 dib8000_set_gpio(fe, 6, 0, 1);
1605 else if (tune_state == CT_AGC_STEP_1) {
1606 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1607 if (rf_gain_limit < 2000) /* activate the external attenuator in case of very high input power */
1608 dib8000_set_gpio(fe, 6, 0, 0);
1609 }
1610 } while (tune_state < CT_AGC_STOP);
1611
1612 deb_info("switching to PWM AGC\n");
1613 dib0090_pwm_gain_reset(fe);
1614 dib8000_pwm_agc_reset(fe);
1615 dib8000_set_tune_state(fe, CT_DEMOD_START);
1616 } else {
1617 /* for everything else than CBAND we are using standard AGC */
1618 deb_info("not tuning in CBAND - standard AGC startup\n");
1619 dib0090_pwm_gain_reset(fe);
1620 }
1621
1622 return 0;
1623 }
1624
1625 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1626 {
1627 struct dib0700_adapter_state *st = adap->priv;
1628 struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1629
1630 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1631 return -ENODEV;
1632
1633 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1634 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1635 return 0;
1636 }
1637
1638 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1639 {
1640 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1641 msleep(10);
1642 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1643 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1644 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1645
1646 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1647
1648 dib0700_ctrl_clock(adap->dev, 72, 1);
1649
1650 msleep(10);
1651 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1652 msleep(10);
1653 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1654
1655 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1656
1657 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1658
1659 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1660 }
1661
1662 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1663 {
1664 struct dib0700_adapter_state *st = adap->priv;
1665 struct i2c_adapter *tun_i2c;
1666 struct dvb_frontend *fe_slave = dib8000_get_slave_frontend(adap->fe_adap[0].fe, 1);
1667
1668 if (fe_slave) {
1669 tun_i2c = dib8000_get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1670 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1671 return -ENODEV;
1672 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1673 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1674 }
1675 tun_i2c = dib8000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1676 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1677 return -ENODEV;
1678
1679 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1680 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1681
1682 return 0;
1683 }
1684
1685 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1686 {
1687 struct dvb_frontend *fe_slave;
1688
1689 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1690 msleep(20);
1691 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1692 msleep(1000);
1693 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1694 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1695 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1696
1697 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1698
1699 dib0700_ctrl_clock(adap->dev, 72, 1);
1700
1701 msleep(20);
1702 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1703 msleep(20);
1704 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1705
1706 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
1707
1708 adap->fe_adap[0].fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1709 if (adap->fe_adap[0].fe == NULL)
1710 return -ENODEV;
1711
1712 fe_slave = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1713 dib8000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1714
1715 return fe_slave == NULL ? -ENODEV : 0;
1716 }
1717
1718 /* TFE8096P */
1719 static struct dibx000_agc_config dib8096p_agc_config[2] = {
1720 {
1721 .band_caps = BAND_UHF,
1722 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1723 P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1724 P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1725 P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1726 P_agc_write=0 */
1727 .setup = (0 << 15) | (0 << 14) | (5 << 11)
1728 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1729 | (0 << 4) | (5 << 1) | (0 << 0),
1730
1731 .inv_gain = 684,
1732 .time_stabiliz = 10,
1733
1734 .alpha_level = 0,
1735 .thlock = 118,
1736
1737 .wbd_inv = 0,
1738 .wbd_ref = 1200,
1739 .wbd_sel = 3,
1740 .wbd_alpha = 5,
1741
1742 .agc1_max = 65535,
1743 .agc1_min = 0,
1744
1745 .agc2_max = 32767,
1746 .agc2_min = 0,
1747
1748 .agc1_pt1 = 0,
1749 .agc1_pt2 = 0,
1750 .agc1_pt3 = 105,
1751 .agc1_slope1 = 0,
1752 .agc1_slope2 = 156,
1753 .agc2_pt1 = 105,
1754 .agc2_pt2 = 255,
1755 .agc2_slope1 = 54,
1756 .agc2_slope2 = 0,
1757
1758 .alpha_mant = 28,
1759 .alpha_exp = 26,
1760 .beta_mant = 31,
1761 .beta_exp = 51,
1762
1763 .perform_agc_softsplit = 0,
1764 } , {
1765 .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
1766 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1767 P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1768 P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1769 P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1770 P_agc_write=0 */
1771 .setup = (0 << 15) | (0 << 14) | (5 << 11)
1772 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1773 | (0 << 4) | (5 << 1) | (0 << 0),
1774
1775 .inv_gain = 732,
1776 .time_stabiliz = 10,
1777
1778 .alpha_level = 0,
1779 .thlock = 118,
1780
1781 .wbd_inv = 0,
1782 .wbd_ref = 1200,
1783 .wbd_sel = 3,
1784 .wbd_alpha = 5,
1785
1786 .agc1_max = 65535,
1787 .agc1_min = 0,
1788
1789 .agc2_max = 32767,
1790 .agc2_min = 0,
1791
1792 .agc1_pt1 = 0,
1793 .agc1_pt2 = 0,
1794 .agc1_pt3 = 98,
1795 .agc1_slope1 = 0,
1796 .agc1_slope2 = 167,
1797 .agc2_pt1 = 98,
1798 .agc2_pt2 = 255,
1799 .agc2_slope1 = 52,
1800 .agc2_slope2 = 0,
1801
1802 .alpha_mant = 28,
1803 .alpha_exp = 26,
1804 .beta_mant = 31,
1805 .beta_exp = 51,
1806
1807 .perform_agc_softsplit = 0,
1808 }
1809 };
1810
1811 static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = {
1812 108000, 13500,
1813 1, 9, 1, 0, 0,
1814 0, 0, 0, 0, 2,
1815 (3 << 14) | (1 << 12) | (524 << 0),
1816 (0 << 25) | 0,
1817 20199729,
1818 12000000,
1819 };
1820
1821 static struct dib8000_config tfe8096p_dib8000_config = {
1822 .output_mpeg2_in_188_bytes = 1,
1823 .hostbus_diversity = 1,
1824 .update_lna = NULL,
1825
1826 .agc_config_count = 2,
1827 .agc = dib8096p_agc_config,
1828 .pll = &dib8096p_clock_config_12_mhz,
1829
1830 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1831 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1832 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1833
1834 .agc_control = NULL,
1835 .diversity_delay = 48,
1836 .output_mode = OUTMODE_MPEG2_FIFO,
1837 .enMpegOutput = 1,
1838 };
1839
1840 static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
1841 { 380, 81, 850, 64, 540, 4},
1842 { 860, 51, 866, 21, 375, 4},
1843 {1700, 0, 250, 0, 100, 6},
1844 {2600, 0, 250, 0, 100, 6},
1845 { 0xFFFF, 0, 0, 0, 0, 0},
1846 };
1847
1848 static const struct dib0090_config tfe8096p_dib0090_config = {
1849 .io.clock_khz = 12000,
1850 .io.pll_bypass = 0,
1851 .io.pll_range = 0,
1852 .io.pll_prediv = 3,
1853 .io.pll_loopdiv = 6,
1854 .io.adc_clock_ratio = 0,
1855 .io.pll_int_loop_filt = 0,
1856 .reset = dib8096p_tuner_sleep,
1857 .sleep = dib8096p_tuner_sleep,
1858
1859 .freq_offset_khz_uhf = -143,
1860 .freq_offset_khz_vhf = -143,
1861
1862 .get_adc_power = dib8090_get_adc_power,
1863
1864 .clkouttobamse = 1,
1865 .analog_output = 0,
1866
1867 .wbd_vhf_offset = 0,
1868 .wbd_cband_offset = 0,
1869 .use_pwm_agc = 1,
1870 .clkoutdrive = 0,
1871
1872 .fref_clock_ratio = 1,
1873
1874 .wbd = dib8096p_wbd_table,
1875
1876 .ls_cfg_pad_drv = 0,
1877 .data_tx_drv = 0,
1878 .low_if = NULL,
1879 .in_soc = 1,
1880 .force_cband_input = 0,
1881 };
1882
1883 struct dibx090p_adc {
1884 u32 freq; /* RF freq MHz */
1885 u32 timf; /* New Timf */
1886 u32 pll_loopdiv; /* New prediv */
1887 u32 pll_prediv; /* New loopdiv */
1888 };
1889
1890 struct dibx090p_best_adc {
1891 u32 timf;
1892 u32 pll_loopdiv;
1893 u32 pll_prediv;
1894 };
1895
1896 static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc)
1897 {
1898 u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
1899 u16 xtal = 12000;
1900 u16 fcp_min = 1900; /* PLL, Minimum Frequency of phase comparator (KHz) */
1901 u16 fcp_max = 20000; /* PLL, Maximum Frequency of phase comparator (KHz) */
1902 u32 fmem_max = 140000; /* 140MHz max SDRAM freq */
1903 u32 fdem_min = 66000;
1904 u32 fcp = 0, fs = 0, fdem = 0, fmem = 0;
1905 u32 harmonic_id = 0;
1906
1907 adc->timf = 0;
1908 adc->pll_loopdiv = loopdiv;
1909 adc->pll_prediv = prediv;
1910
1911 deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz);
1912
1913 /* Find Min and Max prediv */
1914 while ((xtal / max_prediv) >= fcp_min)
1915 max_prediv++;
1916
1917 max_prediv--;
1918 min_prediv = max_prediv;
1919 while ((xtal / min_prediv) <= fcp_max) {
1920 min_prediv--;
1921 if (min_prediv == 1)
1922 break;
1923 }
1924 deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
1925
1926 min_prediv = 1;
1927
1928 for (prediv = min_prediv; prediv < max_prediv; prediv++) {
1929 fcp = xtal / prediv;
1930 if (fcp > fcp_min && fcp < fcp_max) {
1931 for (loopdiv = 1; loopdiv < 64; loopdiv++) {
1932 fmem = ((xtal/prediv) * loopdiv);
1933 fdem = fmem / 2;
1934 fs = fdem / 4;
1935
1936 /* test min/max system restrictions */
1937 if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) {
1938 spur = 0;
1939 /* test fs harmonics positions */
1940 for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs)); harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) {
1941 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)))) {
1942 spur = 1;
1943 break;
1944 }
1945 }
1946
1947 if (!spur) {
1948 adc->pll_loopdiv = loopdiv;
1949 adc->pll_prediv = prediv;
1950 adc->timf = (4260880253U / fdem) * (1 << 8);
1951 adc->timf += ((4260880253U % fdem) << 8) / fdem;
1952
1953 deb_info("RF %6d; BW %6d; Xtal %6d; Fmem %6d; Fdem %6d; Fs %6d; Prediv %2d; Loopdiv %2d; Timf %8d;", fe->dtv_property_cache.frequency, fe->dtv_property_cache.bandwidth_hz, xtal, fmem, fdem, fs, prediv, loopdiv, adc->timf);
1954 break;
1955 }
1956 }
1957 }
1958 }
1959 if (!spur)
1960 break;
1961 }
1962
1963 if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
1964 return -EINVAL;
1965 return 0;
1966 }
1967
1968 static int dib8096p_agc_startup(struct dvb_frontend *fe)
1969 {
1970 struct dvb_usb_adapter *adap = fe->dvb->priv;
1971 struct dib0700_adapter_state *state = adap->priv;
1972 struct dibx000_bandwidth_config pll;
1973 struct dibx090p_best_adc adc;
1974 u16 target;
1975 int ret;
1976
1977 ret = state->set_param_save(fe);
1978 if (ret < 0)
1979 return ret;
1980 memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
1981
1982 dib0090_pwm_gain_reset(fe);
1983 /* dib0090_get_wbd_target is returning any possible
1984 temperature compensated wbd-target */
1985 target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
1986 dib8000_set_wbd_ref(fe, target);
1987
1988 if (dib8096p_get_best_sampling(fe, &adc) == 0) {
1989 pll.pll_ratio = adc.pll_loopdiv;
1990 pll.pll_prediv = adc.pll_prediv;
1991
1992 dib0700_set_i2c_speed(adap->dev, 200);
1993 dib8000_update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
1994 dib8000_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
1995 dib0700_set_i2c_speed(adap->dev, 1000);
1996 }
1997 return 0;
1998 }
1999
2000 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
2001 {
2002 struct dib0700_state *st = adap->dev->priv;
2003 u32 fw_version;
2004
2005 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2006 if (fw_version >= 0x10200)
2007 st->fw_use_new_i2c_api = 1;
2008
2009 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2010 msleep(20);
2011 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2012 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2013 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2014
2015 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2016
2017 dib0700_ctrl_clock(adap->dev, 72, 1);
2018
2019 msleep(20);
2020 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2021 msleep(20);
2022 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2023
2024 dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
2025
2026 adap->fe_adap[0].fe = dvb_attach(dib8000_attach,
2027 &adap->dev->i2c_adap, 0x80, &tfe8096p_dib8000_config);
2028
2029 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2030 }
2031
2032 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
2033 {
2034 struct dib0700_adapter_state *st = adap->priv;
2035 struct i2c_adapter *tun_i2c = dib8096p_get_i2c_tuner(adap->fe_adap[0].fe);
2036
2037 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
2038 &tfe8096p_dib0090_config) == NULL)
2039 return -ENODEV;
2040
2041 dib8000_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2042
2043 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2044 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
2045 return 0;
2046 }
2047
2048 /* STK9090M */
2049 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2050 {
2051 return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
2052 }
2053
2054 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2055 {
2056 return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
2057 }
2058
2059 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2060 {
2061 return dib9000_set_gpio(fe, 5, 0, !onoff);
2062 }
2063
2064 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2065 {
2066 return dib9000_set_gpio(fe, 0, 0, onoff);
2067 }
2068
2069 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
2070 {
2071 u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
2072 u8 rb[2];
2073 struct i2c_msg msg[2] = {
2074 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
2075 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
2076 };
2077 u8 index_data;
2078
2079 dibx000_i2c_set_speed(i2c, 250);
2080
2081 if (i2c_transfer(i2c, msg, 2) != 2)
2082 return -EIO;
2083
2084 switch (rb[0] << 8 | rb[1]) {
2085 case 0:
2086 deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
2087 return -EIO;
2088 case 1:
2089 deb_info("Found DiB0170 rev2");
2090 break;
2091 case 2:
2092 deb_info("Found DiB0190 rev2");
2093 break;
2094 default:
2095 deb_info("DiB01x0 not found");
2096 return -EIO;
2097 }
2098
2099 for (index_data = 0; index_data < len; index_data += 2) {
2100 wb[2] = (data[index_data + 1] >> 8) & 0xff;
2101 wb[3] = (data[index_data + 1]) & 0xff;
2102
2103 if (data[index_data] == 0) {
2104 wb[0] = (data[index_data] >> 8) & 0xff;
2105 wb[1] = (data[index_data]) & 0xff;
2106 msg[0].len = 2;
2107 if (i2c_transfer(i2c, msg, 2) != 2)
2108 return -EIO;
2109 wb[2] |= rb[0];
2110 wb[3] |= rb[1] & ~(3 << 4);
2111 }
2112
2113 wb[0] = (data[index_data] >> 8)&0xff;
2114 wb[1] = (data[index_data])&0xff;
2115 msg[0].len = 4;
2116 if (i2c_transfer(i2c, &msg[0], 1) != 1)
2117 return -EIO;
2118 }
2119 return 0;
2120 }
2121
2122 static struct dib9000_config stk9090m_config = {
2123 .output_mpeg2_in_188_bytes = 1,
2124 .output_mode = OUTMODE_MPEG2_FIFO,
2125 .vcxo_timer = 279620,
2126 .timing_frequency = 20452225,
2127 .demod_clock_khz = 60000,
2128 .xtal_clock_khz = 30000,
2129 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2130 .subband = {
2131 2,
2132 {
2133 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
2134 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
2135 { 0 },
2136 },
2137 },
2138 .gpio_function = {
2139 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2140 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2141 },
2142 };
2143
2144 static struct dib9000_config nim9090md_config[2] = {
2145 {
2146 .output_mpeg2_in_188_bytes = 1,
2147 .output_mode = OUTMODE_MPEG2_FIFO,
2148 .vcxo_timer = 279620,
2149 .timing_frequency = 20452225,
2150 .demod_clock_khz = 60000,
2151 .xtal_clock_khz = 30000,
2152 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2153 }, {
2154 .output_mpeg2_in_188_bytes = 1,
2155 .output_mode = OUTMODE_DIVERSITY,
2156 .vcxo_timer = 279620,
2157 .timing_frequency = 20452225,
2158 .demod_clock_khz = 60000,
2159 .xtal_clock_khz = 30000,
2160 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2161 .subband = {
2162 2,
2163 {
2164 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
2165 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
2166 { 0 },
2167 },
2168 },
2169 .gpio_function = {
2170 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2171 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2172 },
2173 }
2174 };
2175
2176 static struct dib0090_config dib9090_dib0090_config = {
2177 .io.pll_bypass = 0,
2178 .io.pll_range = 1,
2179 .io.pll_prediv = 1,
2180 .io.pll_loopdiv = 8,
2181 .io.adc_clock_ratio = 8,
2182 .io.pll_int_loop_filt = 0,
2183 .io.clock_khz = 30000,
2184 .reset = dib90x0_tuner_reset,
2185 .sleep = dib90x0_tuner_sleep,
2186 .clkouttobamse = 0,
2187 .analog_output = 0,
2188 .use_pwm_agc = 0,
2189 .clkoutdrive = 0,
2190 .freq_offset_khz_uhf = 0,
2191 .freq_offset_khz_vhf = 0,
2192 };
2193
2194 static struct dib0090_config nim9090md_dib0090_config[2] = {
2195 {
2196 .io.pll_bypass = 0,
2197 .io.pll_range = 1,
2198 .io.pll_prediv = 1,
2199 .io.pll_loopdiv = 8,
2200 .io.adc_clock_ratio = 8,
2201 .io.pll_int_loop_filt = 0,
2202 .io.clock_khz = 30000,
2203 .reset = dib90x0_tuner_reset,
2204 .sleep = dib90x0_tuner_sleep,
2205 .clkouttobamse = 1,
2206 .analog_output = 0,
2207 .use_pwm_agc = 0,
2208 .clkoutdrive = 0,
2209 .freq_offset_khz_uhf = 0,
2210 .freq_offset_khz_vhf = 0,
2211 }, {
2212 .io.pll_bypass = 0,
2213 .io.pll_range = 1,
2214 .io.pll_prediv = 1,
2215 .io.pll_loopdiv = 8,
2216 .io.adc_clock_ratio = 8,
2217 .io.pll_int_loop_filt = 0,
2218 .io.clock_khz = 30000,
2219 .reset = dib90x0_tuner_reset,
2220 .sleep = dib90x0_tuner_sleep,
2221 .clkouttobamse = 0,
2222 .analog_output = 0,
2223 .use_pwm_agc = 0,
2224 .clkoutdrive = 0,
2225 .freq_offset_khz_uhf = 0,
2226 .freq_offset_khz_vhf = 0,
2227 }
2228 };
2229
2230
2231 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2232 {
2233 struct dib0700_adapter_state *state = adap->priv;
2234 struct dib0700_state *st = adap->dev->priv;
2235 u32 fw_version;
2236
2237 /* Make use of the new i2c functions from FW 1.20 */
2238 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2239 if (fw_version >= 0x10200)
2240 st->fw_use_new_i2c_api = 1;
2241 dib0700_set_i2c_speed(adap->dev, 340);
2242
2243 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2244 msleep(20);
2245 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2246 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2247 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2248 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2249
2250 dib0700_ctrl_clock(adap->dev, 72, 1);
2251
2252 msleep(20);
2253 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2254 msleep(20);
2255 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2256
2257 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2258
2259 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2260 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2261 return -ENODEV;
2262 } else {
2263 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
2264 }
2265 stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2266 stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2267
2268 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2269
2270 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2271 }
2272
2273 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2274 {
2275 struct dib0700_adapter_state *state = adap->priv;
2276 struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2277 u16 data_dib190[10] = {
2278 1, 0x1374,
2279 2, 0x01a2,
2280 7, 0x0020,
2281 0, 0x00ef,
2282 8, 0x0486,
2283 };
2284
2285 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2286 return -ENODEV;
2287 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2288 if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2289 return -ENODEV;
2290 dib0700_set_i2c_speed(adap->dev, 1500);
2291 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2292 return -ENODEV;
2293 release_firmware(state->frontend_firmware);
2294 return 0;
2295 }
2296
2297 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2298 {
2299 struct dib0700_adapter_state *state = adap->priv;
2300 struct dib0700_state *st = adap->dev->priv;
2301 struct i2c_adapter *i2c;
2302 struct dvb_frontend *fe_slave;
2303 u32 fw_version;
2304
2305 /* Make use of the new i2c functions from FW 1.20 */
2306 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2307 if (fw_version >= 0x10200)
2308 st->fw_use_new_i2c_api = 1;
2309 dib0700_set_i2c_speed(adap->dev, 340);
2310
2311 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2312 msleep(20);
2313 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2314 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2315 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2316 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2317
2318 dib0700_ctrl_clock(adap->dev, 72, 1);
2319
2320 msleep(20);
2321 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2322 msleep(20);
2323 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2324
2325 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2326 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2327 return -EIO;
2328 } else {
2329 deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
2330 }
2331 nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2332 nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2333 nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2334 nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2335
2336 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2337 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2338
2339 if (adap->fe_adap[0].fe == NULL)
2340 return -ENODEV;
2341
2342 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
2343 dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
2344
2345 fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2346 dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
2347
2348 return fe_slave == NULL ? -ENODEV : 0;
2349 }
2350
2351 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2352 {
2353 struct dib0700_adapter_state *state = adap->priv;
2354 struct i2c_adapter *i2c;
2355 struct dvb_frontend *fe_slave;
2356 u16 data_dib190[10] = {
2357 1, 0x5374,
2358 2, 0x01ae,
2359 7, 0x0020,
2360 0, 0x00ef,
2361 8, 0x0406,
2362 };
2363 i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2364 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2365 return -ENODEV;
2366 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2367 if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
2368 return -ENODEV;
2369
2370 dib0700_set_i2c_speed(adap->dev, 1500);
2371 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2372 return -ENODEV;
2373
2374 fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
2375 if (fe_slave != NULL) {
2376 i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
2377 dib9000_set_i2c_adapter(fe_slave, i2c);
2378
2379 i2c = dib9000_get_tuner_interface(fe_slave);
2380 if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
2381 return -ENODEV;
2382 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
2383 dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 1500);
2384 if (dib9000_firmware_post_pll_init(fe_slave) < 0)
2385 return -ENODEV;
2386 }
2387 release_firmware(state->frontend_firmware);
2388
2389 return 0;
2390 }
2391
2392 /* NIM7090 */
2393 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dibx090p_best_adc *adc)
2394 {
2395 u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2396
2397 u16 xtal = 12000;
2398 u32 fcp_min = 1900; /* PLL Minimum Frequency comparator KHz */
2399 u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
2400 u32 fdem_max = 76000;
2401 u32 fdem_min = 69500;
2402 u32 fcp = 0, fs = 0, fdem = 0;
2403 u32 harmonic_id = 0;
2404
2405 adc->pll_loopdiv = loopdiv;
2406 adc->pll_prediv = prediv;
2407 adc->timf = 0;
2408
2409 deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2410
2411 /* Find Min and Max prediv */
2412 while ((xtal/max_prediv) >= fcp_min)
2413 max_prediv++;
2414
2415 max_prediv--;
2416 min_prediv = max_prediv;
2417 while ((xtal/min_prediv) <= fcp_max) {
2418 min_prediv--;
2419 if (min_prediv == 1)
2420 break;
2421 }
2422 deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2423
2424 min_prediv = 2;
2425
2426 for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2427 fcp = xtal / prediv;
2428 if (fcp > fcp_min && fcp < fcp_max) {
2429 for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2430 fdem = ((xtal/prediv) * loopdiv);
2431 fs = fdem / 4;
2432 /* test min/max system restrictions */
2433
2434 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2435 spur = 0;
2436 /* test fs harmonics positions */
2437 for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ; harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2438 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)))) {
2439 spur = 1;
2440 break;
2441 }
2442 }
2443
2444 if (!spur) {
2445 adc->pll_loopdiv = loopdiv;
2446 adc->pll_prediv = prediv;
2447 adc->timf = 2396745143UL/fdem*(1 << 9);
2448 adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2449 deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2450 break;
2451 }
2452 }
2453 }
2454 }
2455 if (!spur)
2456 break;
2457 }
2458
2459
2460 if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2461 return -EINVAL;
2462 else
2463 return 0;
2464 }
2465
2466 static int dib7090_agc_startup(struct dvb_frontend *fe)
2467 {
2468 struct dvb_usb_adapter *adap = fe->dvb->priv;
2469 struct dib0700_adapter_state *state = adap->priv;
2470 struct dibx000_bandwidth_config pll;
2471 u16 target;
2472 struct dibx090p_best_adc adc;
2473 int ret;
2474
2475 ret = state->set_param_save(fe);
2476 if (ret < 0)
2477 return ret;
2478
2479 memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2480 dib0090_pwm_gain_reset(fe);
2481 target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2482 dib7000p_set_wbd_ref(fe, target);
2483
2484 if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2485 pll.pll_ratio = adc.pll_loopdiv;
2486 pll.pll_prediv = adc.pll_prediv;
2487
2488 dib7000p_update_pll(fe, &pll);
2489 dib7000p_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2490 }
2491 return 0;
2492 }
2493
2494 static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
2495 {
2496 deb_info("AGC restart callback: %d", restart);
2497 if (restart == 0) /* before AGC startup */
2498 dib0090_set_dc_servo(fe, 1);
2499 return 0;
2500 }
2501
2502 static int tfe7790p_update_lna(struct dvb_frontend *fe, u16 agc_global)
2503 {
2504 deb_info("update LNA: agc global=%i", agc_global);
2505
2506 if (agc_global < 25000) {
2507 dib7000p_set_gpio(fe, 8, 0, 0);
2508 dib7000p_set_agc1_min(fe, 0);
2509 } else {
2510 dib7000p_set_gpio(fe, 8, 0, 1);
2511 dib7000p_set_agc1_min(fe, 32768);
2512 }
2513
2514 return 0;
2515 }
2516
2517 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2518 { 380, 81, 850, 64, 540, 4},
2519 { 860, 51, 866, 21, 375, 4},
2520 {1700, 0, 250, 0, 100, 6},
2521 {2600, 0, 250, 0, 100, 6},
2522 { 0xFFFF, 0, 0, 0, 0, 0},
2523 };
2524
2525 static struct dibx000_agc_config dib7090_agc_config[2] = {
2526 {
2527 .band_caps = BAND_UHF,
2528 /* 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,
2529 * 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 */
2530 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2531
2532 .inv_gain = 687,
2533 .time_stabiliz = 10,
2534
2535 .alpha_level = 0,
2536 .thlock = 118,
2537
2538 .wbd_inv = 0,
2539 .wbd_ref = 1200,
2540 .wbd_sel = 3,
2541 .wbd_alpha = 5,
2542
2543 .agc1_max = 65535,
2544 .agc1_min = 32768,
2545
2546 .agc2_max = 65535,
2547 .agc2_min = 0,
2548
2549 .agc1_pt1 = 0,
2550 .agc1_pt2 = 32,
2551 .agc1_pt3 = 114,
2552 .agc1_slope1 = 143,
2553 .agc1_slope2 = 144,
2554 .agc2_pt1 = 114,
2555 .agc2_pt2 = 227,
2556 .agc2_slope1 = 116,
2557 .agc2_slope2 = 117,
2558
2559 .alpha_mant = 18,
2560 .alpha_exp = 0,
2561 .beta_mant = 20,
2562 .beta_exp = 59,
2563
2564 .perform_agc_softsplit = 0,
2565 } , {
2566 .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
2567 /* 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,
2568 * 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 */
2569 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2570
2571 .inv_gain = 732,
2572 .time_stabiliz = 10,
2573
2574 .alpha_level = 0,
2575 .thlock = 118,
2576
2577 .wbd_inv = 0,
2578 .wbd_ref = 1200,
2579 .wbd_sel = 3,
2580 .wbd_alpha = 5,
2581
2582 .agc1_max = 65535,
2583 .agc1_min = 0,
2584
2585 .agc2_max = 65535,
2586 .agc2_min = 0,
2587
2588 .agc1_pt1 = 0,
2589 .agc1_pt2 = 0,
2590 .agc1_pt3 = 98,
2591 .agc1_slope1 = 0,
2592 .agc1_slope2 = 167,
2593 .agc2_pt1 = 98,
2594 .agc2_pt2 = 255,
2595 .agc2_slope1 = 104,
2596 .agc2_slope2 = 0,
2597
2598 .alpha_mant = 18,
2599 .alpha_exp = 0,
2600 .beta_mant = 20,
2601 .beta_exp = 59,
2602
2603 .perform_agc_softsplit = 0,
2604 }
2605 };
2606
2607 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2608 60000, 15000,
2609 1, 5, 0, 0, 0,
2610 0, 0, 1, 1, 2,
2611 (3 << 14) | (1 << 12) | (524 << 0),
2612 (0 << 25) | 0,
2613 20452225,
2614 15000000,
2615 };
2616
2617 static struct dib7000p_config nim7090_dib7000p_config = {
2618 .output_mpeg2_in_188_bytes = 1,
2619 .hostbus_diversity = 1,
2620 .tuner_is_baseband = 1,
2621 .update_lna = tfe7790p_update_lna, /* GPIO used is the same as TFE7790 */
2622
2623 .agc_config_count = 2,
2624 .agc = dib7090_agc_config,
2625
2626 .bw = &dib7090_clock_config_12_mhz,
2627
2628 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2629 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2630 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2631
2632 .pwm_freq_div = 0,
2633
2634 .agc_control = dib7090_agc_restart,
2635
2636 .spur_protect = 0,
2637 .disable_sample_and_hold = 0,
2638 .enable_current_mirror = 0,
2639 .diversity_delay = 0,
2640
2641 .output_mode = OUTMODE_MPEG2_FIFO,
2642 .enMpegOutput = 1,
2643 };
2644
2645 static int tfe7090p_pvr_update_lna(struct dvb_frontend *fe, u16 agc_global)
2646 {
2647 deb_info("TFE7090P-PVR update LNA: agc global=%i", agc_global);
2648 if (agc_global < 25000) {
2649 dib7000p_set_gpio(fe, 5, 0, 0);
2650 dib7000p_set_agc1_min(fe, 0);
2651 } else {
2652 dib7000p_set_gpio(fe, 5, 0, 1);
2653 dib7000p_set_agc1_min(fe, 32768);
2654 }
2655
2656 return 0;
2657 }
2658
2659 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2660 {
2661 .output_mpeg2_in_188_bytes = 1,
2662 .hostbus_diversity = 1,
2663 .tuner_is_baseband = 1,
2664 .update_lna = tfe7090p_pvr_update_lna,
2665
2666 .agc_config_count = 2,
2667 .agc = dib7090_agc_config,
2668
2669 .bw = &dib7090_clock_config_12_mhz,
2670
2671 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2672 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2673 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2674
2675 .pwm_freq_div = 0,
2676
2677 .agc_control = dib7090_agc_restart,
2678
2679 .spur_protect = 0,
2680 .disable_sample_and_hold = 0,
2681 .enable_current_mirror = 0,
2682 .diversity_delay = 0,
2683
2684 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2685 .default_i2c_addr = 0x90,
2686 .enMpegOutput = 1,
2687 }, {
2688 .output_mpeg2_in_188_bytes = 1,
2689 .hostbus_diversity = 1,
2690 .tuner_is_baseband = 1,
2691 .update_lna = tfe7090p_pvr_update_lna,
2692
2693 .agc_config_count = 2,
2694 .agc = dib7090_agc_config,
2695
2696 .bw = &dib7090_clock_config_12_mhz,
2697
2698 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2699 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2700 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2701
2702 .pwm_freq_div = 0,
2703
2704 .agc_control = dib7090_agc_restart,
2705
2706 .spur_protect = 0,
2707 .disable_sample_and_hold = 0,
2708 .enable_current_mirror = 0,
2709 .diversity_delay = 0,
2710
2711 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2712 .default_i2c_addr = 0x92,
2713 .enMpegOutput = 0,
2714 }
2715 };
2716
2717 static const struct dib0090_config nim7090_dib0090_config = {
2718 .io.clock_khz = 12000,
2719 .io.pll_bypass = 0,
2720 .io.pll_range = 0,
2721 .io.pll_prediv = 3,
2722 .io.pll_loopdiv = 6,
2723 .io.adc_clock_ratio = 0,
2724 .io.pll_int_loop_filt = 0,
2725 .reset = dib7090_tuner_sleep,
2726 .sleep = dib7090_tuner_sleep,
2727
2728 .freq_offset_khz_uhf = 0,
2729 .freq_offset_khz_vhf = 0,
2730
2731 .get_adc_power = dib7090_get_adc_power,
2732
2733 .clkouttobamse = 1,
2734 .analog_output = 0,
2735
2736 .wbd_vhf_offset = 0,
2737 .wbd_cband_offset = 0,
2738 .use_pwm_agc = 1,
2739 .clkoutdrive = 0,
2740
2741 .fref_clock_ratio = 0,
2742
2743 .wbd = dib7090_wbd_table,
2744
2745 .ls_cfg_pad_drv = 0,
2746 .data_tx_drv = 0,
2747 .low_if = NULL,
2748 .in_soc = 1,
2749 };
2750
2751 static struct dib7000p_config tfe7790p_dib7000p_config = {
2752 .output_mpeg2_in_188_bytes = 1,
2753 .hostbus_diversity = 1,
2754 .tuner_is_baseband = 1,
2755 .update_lna = tfe7790p_update_lna,
2756
2757 .agc_config_count = 2,
2758 .agc = dib7090_agc_config,
2759
2760 .bw = &dib7090_clock_config_12_mhz,
2761
2762 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2763 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2764 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2765
2766 .pwm_freq_div = 0,
2767
2768 .agc_control = dib7090_agc_restart,
2769
2770 .spur_protect = 0,
2771 .disable_sample_and_hold = 0,
2772 .enable_current_mirror = 0,
2773 .diversity_delay = 0,
2774
2775 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2776 .enMpegOutput = 1,
2777 };
2778
2779 static const struct dib0090_config tfe7790p_dib0090_config = {
2780 .io.clock_khz = 12000,
2781 .io.pll_bypass = 0,
2782 .io.pll_range = 0,
2783 .io.pll_prediv = 3,
2784 .io.pll_loopdiv = 6,
2785 .io.adc_clock_ratio = 0,
2786 .io.pll_int_loop_filt = 0,
2787 .reset = dib7090_tuner_sleep,
2788 .sleep = dib7090_tuner_sleep,
2789
2790 .freq_offset_khz_uhf = 0,
2791 .freq_offset_khz_vhf = 0,
2792
2793 .get_adc_power = dib7090_get_adc_power,
2794
2795 .clkouttobamse = 1,
2796 .analog_output = 0,
2797
2798 .wbd_vhf_offset = 0,
2799 .wbd_cband_offset = 0,
2800 .use_pwm_agc = 1,
2801 .clkoutdrive = 0,
2802
2803 .fref_clock_ratio = 0,
2804
2805 .wbd = dib7090_wbd_table,
2806
2807 .ls_cfg_pad_drv = 0,
2808 .data_tx_drv = 0,
2809 .low_if = NULL,
2810 .in_soc = 1,
2811 .force_cband_input = 0,
2812 .is_dib7090e = 0,
2813 .force_crystal_mode = 1,
2814 };
2815
2816 static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2817 {
2818 .io.clock_khz = 12000,
2819 .io.pll_bypass = 0,
2820 .io.pll_range = 0,
2821 .io.pll_prediv = 3,
2822 .io.pll_loopdiv = 6,
2823 .io.adc_clock_ratio = 0,
2824 .io.pll_int_loop_filt = 0,
2825 .reset = dib7090_tuner_sleep,
2826 .sleep = dib7090_tuner_sleep,
2827
2828 .freq_offset_khz_uhf = 50,
2829 .freq_offset_khz_vhf = 70,
2830
2831 .get_adc_power = dib7090_get_adc_power,
2832
2833 .clkouttobamse = 1,
2834 .analog_output = 0,
2835
2836 .wbd_vhf_offset = 0,
2837 .wbd_cband_offset = 0,
2838 .use_pwm_agc = 1,
2839 .clkoutdrive = 0,
2840
2841 .fref_clock_ratio = 0,
2842
2843 .wbd = dib7090_wbd_table,
2844
2845 .ls_cfg_pad_drv = 0,
2846 .data_tx_drv = 0,
2847 .low_if = NULL,
2848 .in_soc = 1,
2849 }, {
2850 .io.clock_khz = 12000,
2851 .io.pll_bypass = 0,
2852 .io.pll_range = 0,
2853 .io.pll_prediv = 3,
2854 .io.pll_loopdiv = 6,
2855 .io.adc_clock_ratio = 0,
2856 .io.pll_int_loop_filt = 0,
2857 .reset = dib7090_tuner_sleep,
2858 .sleep = dib7090_tuner_sleep,
2859
2860 .freq_offset_khz_uhf = -50,
2861 .freq_offset_khz_vhf = -70,
2862
2863 .get_adc_power = dib7090_get_adc_power,
2864
2865 .clkouttobamse = 1,
2866 .analog_output = 0,
2867
2868 .wbd_vhf_offset = 0,
2869 .wbd_cband_offset = 0,
2870 .use_pwm_agc = 1,
2871 .clkoutdrive = 0,
2872
2873 .fref_clock_ratio = 0,
2874
2875 .wbd = dib7090_wbd_table,
2876
2877 .ls_cfg_pad_drv = 0,
2878 .data_tx_drv = 0,
2879 .low_if = NULL,
2880 .in_soc = 1,
2881 }
2882 };
2883
2884 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
2885 {
2886 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2887 msleep(20);
2888 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2889 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2890 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2891 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2892
2893 msleep(20);
2894 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2895 msleep(20);
2896 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2897
2898 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
2899 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2900 return -ENODEV;
2901 }
2902 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
2903
2904 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2905 }
2906
2907 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
2908 {
2909 struct dib0700_adapter_state *st = adap->priv;
2910 struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2911
2912 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
2913 return -ENODEV;
2914
2915 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2916
2917 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2918 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2919 return 0;
2920 }
2921
2922 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
2923 {
2924 struct dib0700_state *st = adap->dev->priv;
2925
2926 /* The TFE7090 requires the dib0700 to not be in master mode */
2927 st->disable_streaming_master_mode = 1;
2928
2929 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2930 msleep(20);
2931 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2932 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2933 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2934 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2935
2936 msleep(20);
2937 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2938 msleep(20);
2939 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2940
2941 /* initialize IC 0 */
2942 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
2943 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2944 return -ENODEV;
2945 }
2946
2947 dib0700_set_i2c_speed(adap->dev, 340);
2948 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
2949 if (adap->fe_adap[0].fe == NULL)
2950 return -ENODEV;
2951
2952 dib7090_slave_reset(adap->fe_adap[0].fe);
2953
2954 return 0;
2955 }
2956
2957 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
2958 {
2959 struct i2c_adapter *i2c;
2960
2961 if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
2962 err("the master dib7090 has to be initialized first");
2963 return -ENODEV; /* the master device has not been initialized */
2964 }
2965
2966 i2c = dib7000p_get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
2967 if (dib7000p_i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
2968 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n", __func__);
2969 return -ENODEV;
2970 }
2971
2972 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
2973 dib0700_set_i2c_speed(adap->dev, 200);
2974
2975 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2976 }
2977
2978 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
2979 {
2980 struct dib0700_adapter_state *st = adap->priv;
2981 struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2982
2983 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
2984 return -ENODEV;
2985
2986 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2987
2988 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2989 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
2990 return 0;
2991 }
2992
2993 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
2994 {
2995 struct dib0700_adapter_state *st = adap->priv;
2996 struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
2997
2998 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
2999 return -ENODEV;
3000
3001 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3002
3003 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3004 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3005 return 0;
3006 }
3007
3008 static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
3009 {
3010 struct dib0700_state *st = adap->dev->priv;
3011
3012 /* The TFE7790P requires the dib0700 to not be in master mode */
3013 st->disable_streaming_master_mode = 1;
3014
3015 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3016 msleep(20);
3017 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3018 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3019 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3020 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3021 msleep(20);
3022 dib0700_ctrl_clock(adap->dev, 72, 1);
3023 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3024 msleep(20);
3025 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3026
3027 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap,
3028 1, 0x10, &tfe7790p_dib7000p_config) != 0) {
3029 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
3030 __func__);
3031 return -ENODEV;
3032 }
3033 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,
3034 0x80, &tfe7790p_dib7000p_config);
3035
3036 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3037 }
3038
3039 static int tfe7790p_tuner_attach(struct dvb_usb_adapter *adap)
3040 {
3041 struct dib0700_adapter_state *st = adap->priv;
3042 struct i2c_adapter *tun_i2c =
3043 dib7090_get_i2c_tuner(adap->fe_adap[0].fe);
3044
3045 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3046 &tfe7790p_dib0090_config) == NULL)
3047 return -ENODEV;
3048
3049 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3050
3051 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3052 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3053 return 0;
3054 }
3055
3056 /* STK7070PD */
3057 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
3058 {
3059 .output_mpeg2_in_188_bytes = 1,
3060
3061 .agc_config_count = 1,
3062 .agc = &dib7070_agc_config,
3063 .bw = &dib7070_bw_config_12_mhz,
3064 .tuner_is_baseband = 1,
3065 .spur_protect = 1,
3066
3067 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3068 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3069 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3070
3071 .hostbus_diversity = 1,
3072 }, {
3073 .output_mpeg2_in_188_bytes = 1,
3074
3075 .agc_config_count = 1,
3076 .agc = &dib7070_agc_config,
3077 .bw = &dib7070_bw_config_12_mhz,
3078 .tuner_is_baseband = 1,
3079 .spur_protect = 1,
3080
3081 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3082 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3083 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3084
3085 .hostbus_diversity = 1,
3086 }
3087 };
3088
3089 static void stk7070pd_init(struct dvb_usb_device *dev)
3090 {
3091 dib0700_set_gpio(dev, GPIO6, GPIO_OUT, 1);
3092 msleep(10);
3093 dib0700_set_gpio(dev, GPIO9, GPIO_OUT, 1);
3094 dib0700_set_gpio(dev, GPIO4, GPIO_OUT, 1);
3095 dib0700_set_gpio(dev, GPIO7, GPIO_OUT, 1);
3096 dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 0);
3097
3098 dib0700_ctrl_clock(dev, 72, 1);
3099
3100 msleep(10);
3101 dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 1);
3102 }
3103
3104 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
3105 {
3106 stk7070pd_init(adap->dev);
3107
3108 msleep(10);
3109 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3110
3111 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
3112 stk7070pd_dib7000p_config) != 0) {
3113 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
3114 __func__);
3115 return -ENODEV;
3116 }
3117
3118 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
3119 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3120 }
3121
3122 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
3123 {
3124 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
3125 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3126 }
3127
3128 static int novatd_read_status_override(struct dvb_frontend *fe,
3129 fe_status_t *stat)
3130 {
3131 struct dvb_usb_adapter *adap = fe->dvb->priv;
3132 struct dvb_usb_device *dev = adap->dev;
3133 struct dib0700_state *state = dev->priv;
3134 int ret;
3135
3136 ret = state->read_status(fe, stat);
3137
3138 if (!ret)
3139 dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3140 !!(*stat & FE_HAS_LOCK));
3141
3142 return ret;
3143 }
3144
3145 static int novatd_sleep_override(struct dvb_frontend* fe)
3146 {
3147 struct dvb_usb_adapter *adap = fe->dvb->priv;
3148 struct dvb_usb_device *dev = adap->dev;
3149 struct dib0700_state *state = dev->priv;
3150
3151 /* turn off LED */
3152 dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, 0);
3153
3154 return state->sleep(fe);
3155 }
3156
3157 /**
3158 * novatd_frontend_attach - Nova-TD specific attach
3159 *
3160 * Nova-TD has GPIO0, 1 and 2 for LEDs. So do not fiddle with them except for
3161 * information purposes.
3162 */
3163 static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
3164 {
3165 struct dvb_usb_device *dev = adap->dev;
3166 struct dib0700_state *st = dev->priv;
3167
3168 if (adap->id == 0) {
3169 stk7070pd_init(dev);
3170
3171 /* turn the power LED on, the other two off (just in case) */
3172 dib0700_set_gpio(dev, GPIO0, GPIO_OUT, 0);
3173 dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
3174 dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
3175
3176 if (dib7000p_i2c_enumeration(&dev->i2c_adap, 2, 18,
3177 stk7070pd_dib7000p_config) != 0) {
3178 err("%s: dib7000p_i2c_enumeration failed. Cannot continue\n",
3179 __func__);
3180 return -ENODEV;
3181 }
3182 }
3183
3184 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &dev->i2c_adap,
3185 adap->id == 0 ? 0x80 : 0x82,
3186 &stk7070pd_dib7000p_config[adap->id]);
3187
3188 if (adap->fe_adap[0].fe == NULL)
3189 return -ENODEV;
3190
3191 st->read_status = adap->fe_adap[0].fe->ops.read_status;
3192 adap->fe_adap[0].fe->ops.read_status = novatd_read_status_override;
3193 st->sleep = adap->fe_adap[0].fe->ops.sleep;
3194 adap->fe_adap[0].fe->ops.sleep = novatd_sleep_override;
3195
3196 return 0;
3197 }
3198
3199 /* S5H1411 */
3200 static struct s5h1411_config pinnacle_801e_config = {
3201 .output_mode = S5H1411_PARALLEL_OUTPUT,
3202 .gpio = S5H1411_GPIO_OFF,
3203 .mpeg_timing = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
3204 .qam_if = S5H1411_IF_44000,
3205 .vsb_if = S5H1411_IF_44000,
3206 .inversion = S5H1411_INVERSION_OFF,
3207 .status_mode = S5H1411_DEMODLOCKING
3208 };
3209
3210 /* Pinnacle PCTV HD Pro 801e GPIOs map:
3211 GPIO0 - currently unknown
3212 GPIO1 - xc5000 tuner reset
3213 GPIO2 - CX25843 sleep
3214 GPIO3 - currently unknown
3215 GPIO4 - currently unknown
3216 GPIO6 - currently unknown
3217 GPIO7 - currently unknown
3218 GPIO9 - currently unknown
3219 GPIO10 - CX25843 reset
3220 */
3221 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
3222 {
3223 struct dib0700_state *st = adap->dev->priv;
3224
3225 /* Make use of the new i2c functions from FW 1.20 */
3226 st->fw_use_new_i2c_api = 1;
3227
3228 /* The s5h1411 requires the dib0700 to not be in master mode */
3229 st->disable_streaming_master_mode = 1;
3230
3231 /* All msleep values taken from Windows USB trace */
3232 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
3233 dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
3234 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3235 msleep(400);
3236 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3237 msleep(60);
3238 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3239 msleep(30);
3240 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3241 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3242 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3243 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3244 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
3245 msleep(30);
3246
3247 /* Put the CX25843 to sleep for now since we're in digital mode */
3248 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3249
3250 /* GPIOs are initialized, do the attach */
3251 adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
3252 &adap->dev->i2c_adap);
3253 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3254 }
3255
3256 static int dib0700_xc5000_tuner_callback(void *priv, int component,
3257 int command, int arg)
3258 {
3259 struct dvb_usb_adapter *adap = priv;
3260
3261 if (command == XC5000_TUNER_RESET) {
3262 /* Reset the tuner */
3263 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
3264 msleep(10);
3265 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
3266 msleep(10);
3267 } else {
3268 err("xc5000: unknown tuner callback command: %d\n", command);
3269 return -EINVAL;
3270 }
3271
3272 return 0;
3273 }
3274
3275 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3276 .i2c_address = 0x64,
3277 .if_khz = 5380,
3278 };
3279
3280 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
3281 {
3282 /* FIXME: generalize & move to common area */
3283 adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
3284
3285 return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
3286 &s5h1411_xc5000_tunerconfig)
3287 == NULL ? -ENODEV : 0;
3288 }
3289
3290 static int dib0700_xc4000_tuner_callback(void *priv, int component,
3291 int command, int arg)
3292 {
3293 struct dvb_usb_adapter *adap = priv;
3294
3295 if (command == XC4000_TUNER_RESET) {
3296 /* Reset the tuner */
3297 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
3298 msleep(10);
3299 dib7000p_set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3300 } else {
3301 err("xc4000: unknown tuner callback command: %d\n", command);
3302 return -EINVAL;
3303 }
3304
3305 return 0;
3306 }
3307
3308 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
3309 .band_caps = BAND_UHF | BAND_VHF,
3310 .setup = 0x64,
3311 .inv_gain = 0x02c8,
3312 .time_stabiliz = 0x15,
3313 .alpha_level = 0x00,
3314 .thlock = 0x76,
3315 .wbd_inv = 0x01,
3316 .wbd_ref = 0x0b33,
3317 .wbd_sel = 0x00,
3318 .wbd_alpha = 0x02,
3319 .agc1_max = 0x00,
3320 .agc1_min = 0x00,
3321 .agc2_max = 0x9b26,
3322 .agc2_min = 0x26ca,
3323 .agc1_pt1 = 0x00,
3324 .agc1_pt2 = 0x00,
3325 .agc1_pt3 = 0x00,
3326 .agc1_slope1 = 0x00,
3327 .agc1_slope2 = 0x00,
3328 .agc2_pt1 = 0x00,
3329 .agc2_pt2 = 0x80,
3330 .agc2_slope1 = 0x1d,
3331 .agc2_slope2 = 0x1d,
3332 .alpha_mant = 0x11,
3333 .alpha_exp = 0x1b,
3334 .beta_mant = 0x17,
3335 .beta_exp = 0x33,
3336 .perform_agc_softsplit = 0x00,
3337 };
3338
3339 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
3340 60000, 30000, /* internal, sampling */
3341 1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
3342 0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, */
3343 /* ADClkSrc, modulo */
3344 (3 << 14) | (1 << 12) | 524, /* sad_cfg: refsel, sel, freq_15k */
3345 39370534, /* ifreq */
3346 20452225, /* timf */
3347 30000000 /* xtal */
3348 };
3349
3350 /* FIXME: none of these inputs are validated yet */
3351 static struct dib7000p_config pctv_340e_config = {
3352 .output_mpeg2_in_188_bytes = 1,
3353
3354 .agc_config_count = 1,
3355 .agc = &stk7700p_7000p_xc4000_agc_config,
3356 .bw = &stk7700p_xc4000_pll_config,
3357
3358 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
3359 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
3360 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
3361 };
3362
3363 /* PCTV 340e GPIOs map:
3364 dib0700:
3365 GPIO2 - CX25843 sleep
3366 GPIO3 - CS5340 reset
3367 GPIO5 - IRD
3368 GPIO6 - Power Supply
3369 GPIO8 - LNA (1=off 0=on)
3370 GPIO10 - CX25843 reset
3371 dib7000:
3372 GPIO8 - xc4000 reset
3373 */
3374 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
3375 {
3376 struct dib0700_state *st = adap->dev->priv;
3377
3378 /* Power Supply on */
3379 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3380 msleep(50);
3381 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3382 msleep(100); /* Allow power supply to settle before probing */
3383
3384 /* cx25843 reset */
3385 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3386 msleep(1); /* cx25843 datasheet say 350us required */
3387 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3388
3389 /* LNA off for now */
3390 dib0700_set_gpio(adap->dev, GPIO8, GPIO_OUT, 1);
3391
3392 /* Put the CX25843 to sleep for now since we're in digital mode */
3393 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3394
3395 /* FIXME: not verified yet */
3396 dib0700_ctrl_clock(adap->dev, 72, 1);
3397
3398 msleep(500);
3399
3400 if (dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
3401 /* Demodulator not found for some reason? */
3402 return -ENODEV;
3403 }
3404
3405 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x12,
3406 &pctv_340e_config);
3407 st->is_dib7000pc = 1;
3408
3409 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3410 }
3411
3412 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
3413 .i2c_address = 0x61,
3414 .default_pm = 1,
3415 .dvb_amplitude = 0,
3416 .set_smoothedcvbs = 0,
3417 .if_khz = 5400
3418 };
3419
3420 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
3421 {
3422 struct i2c_adapter *tun_i2c;
3423
3424 /* The xc4000 is not on the main i2c bus */
3425 tun_i2c = dib7000p_get_i2c_master(adap->fe_adap[0].fe,
3426 DIBX000_I2C_INTERFACE_TUNER, 1);
3427 if (tun_i2c == NULL) {
3428 printk(KERN_ERR "Could not reach tuner i2c bus\n");
3429 return 0;
3430 }
3431
3432 /* Setup the reset callback */
3433 adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
3434
3435 return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
3436 &dib7000p_xc4000_tunerconfig)
3437 == NULL ? -ENODEV : 0;
3438 }
3439
3440 static struct lgdt3305_config hcw_lgdt3305_config = {
3441 .i2c_addr = 0x0e,
3442 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
3443 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
3444 .tpvalid_polarity = LGDT3305_TP_VALID_LOW,
3445 .deny_i2c_rptr = 0,
3446 .spectral_inversion = 1,
3447 .qam_if_khz = 6000,
3448 .vsb_if_khz = 6000,
3449 .usref_8vsb = 0x0500,
3450 };
3451
3452 static struct mxl5007t_config hcw_mxl5007t_config = {
3453 .xtal_freq_hz = MxL_XTAL_25_MHZ,
3454 .if_freq_hz = MxL_IF_6_MHZ,
3455 .invert_if = 1,
3456 };
3457
3458 /* TIGER-ATSC map:
3459 GPIO0 - LNA_CTR (H: LNA power enabled, L: LNA power disabled)
3460 GPIO1 - ANT_SEL (H: VPA, L: MCX)
3461 GPIO4 - SCL2
3462 GPIO6 - EN_TUNER
3463 GPIO7 - SDA2
3464 GPIO10 - DEM_RST
3465
3466 MXL is behind LG's i2c repeater. LG is on SCL2/SDA2 gpios on the DIB
3467 */
3468 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
3469 {
3470 struct dib0700_state *st = adap->dev->priv;
3471
3472 /* Make use of the new i2c functions from FW 1.20 */
3473 st->fw_use_new_i2c_api = 1;
3474
3475 st->disable_streaming_master_mode = 1;
3476
3477 /* fe power enable */
3478 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3479 msleep(30);
3480 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3481 msleep(30);
3482
3483 /* demod reset */
3484 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3485 msleep(30);
3486 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3487 msleep(30);
3488 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3489 msleep(30);
3490
3491 adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
3492 &hcw_lgdt3305_config,
3493 &adap->dev->i2c_adap);
3494
3495 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3496 }
3497
3498 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
3499 {
3500 return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
3501 &adap->dev->i2c_adap, 0x60,
3502 &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
3503 }
3504
3505
3506 /* DVB-USB and USB stuff follows */
3507 struct usb_device_id dib0700_usb_id_table[] = {
3508 /* 0 */ { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) },
3509 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P_PC) },
3510 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
3511 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
3512 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
3513 /* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
3514 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500) },
3515 { USB_DEVICE(USB_VID_UNIWILL, USB_PID_UNIWILL_STK7700P) },
3516 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
3517 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
3518 /* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
3519 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV2000E) },
3520 { USB_DEVICE(USB_VID_TERRATEC,
3521 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
3522 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
3523 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700D) },
3524 /* 15 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070P) },
3525 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
3526 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070PD) },
3527 { USB_DEVICE(USB_VID_PINNACLE,
3528 USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
3529 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500_PC) },
3530 /* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
3531 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
3532 { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
3533 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000) },
3534 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100) },
3535 /* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
3536 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
3537 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
3538 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_EXPRESSCARD_320CX) },
3539 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV72E) },
3540 /* 30 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73E) },
3541 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_EC372S) },
3542 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
3543 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS) },
3544 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
3545 /* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
3546 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
3547 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U8000) },
3548 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700PH) },
3549 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000H) },
3550 /* 40 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E) },
3551 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E_SE) },
3552 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
3553 { USB_DEVICE(USB_VID_TERRATEC,
3554 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
3555 { USB_DEVICE(USB_VID_SONY, USB_PID_SONY_PLAYTV) },
3556 /* 45 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_PD378S) },
3557 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
3558 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
3559 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_MC770) },
3560 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT) },
3561 /* 50 */{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_Dlx) },
3562 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_H) },
3563 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T3) },
3564 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T5) },
3565 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D) },
3566 /* 55 */{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D_2) },
3567 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73A) },
3568 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV73ESE) },
3569 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV282E) },
3570 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7770P) },
3571 /* 60 */{ USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS_2) },
3572 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XPVR) },
3573 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XP) },
3574 { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
3575 { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
3576 /* 65 */{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73ESE) },
3577 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV282E) },
3578 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK8096GP) },
3579 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DIVERSITY) },
3580 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090M) },
3581 /* 70 */{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM8096MD) },
3582 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090MD) },
3583 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM7090) },
3584 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7090PVR) },
3585 { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
3586 /* 75 */{ USB_DEVICE(USB_VID_MEDION, USB_PID_CREATIX_CTX1921) },
3587 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E) },
3588 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E_SE) },
3589 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7790P) },
3590 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE8096P) },
3591 /* 80 */{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_2) },
3592 { USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_2002E) },
3593 { USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_2002E_SE) },
3594 { 0 } /* Terminating entry */
3595 };
3596 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
3597
3598 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
3599 .caps = DVB_USB_IS_AN_I2C_ADAPTER, \
3600 .usb_ctrl = DEVICE_SPECIFIC, \
3601 .firmware = "dvb-usb-dib0700-1.20.fw", \
3602 .download_firmware = dib0700_download_firmware, \
3603 .no_reconnect = 1, \
3604 .size_of_priv = sizeof(struct dib0700_state), \
3605 .i2c_algo = &dib0700_i2c_algo, \
3606 .identify_state = dib0700_identify_state
3607
3608 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
3609 .streaming_ctrl = dib0700_streaming_ctrl, \
3610 .stream = { \
3611 .type = USB_BULK, \
3612 .count = 4, \
3613 .endpoint = ep, \
3614 .u = { \
3615 .bulk = { \
3616 .buffersize = 39480, \
3617 } \
3618 } \
3619 }
3620
3621 struct dvb_usb_device_properties dib0700_devices[] = {
3622 {
3623 DIB0700_DEFAULT_DEVICE_PROPERTIES,
3624
3625 .num_adapters = 1,
3626 .adapter = {
3627 {
3628 .num_frontends = 1,
3629 .fe = {{
3630 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3631 .pid_filter_count = 32,
3632 .pid_filter = stk7700p_pid_filter,
3633 .pid_filter_ctrl = stk7700p_pid_filter_ctrl,
3634 .frontend_attach = stk7700p_frontend_attach,
3635 .tuner_attach = stk7700p_tuner_attach,
3636
3637 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3638 }},
3639 },
3640 },
3641
3642 .num_device_descs = 8,
3643 .devices = {
3644 { "DiBcom STK7700P reference design",
3645 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
3646 { NULL },
3647 },
3648 { "Hauppauge Nova-T Stick",
3649 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
3650 { NULL },
3651 },
3652 { "AVerMedia AVerTV DVB-T Volar",
3653 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
3654 { NULL },
3655 },
3656 { "Compro Videomate U500",
3657 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
3658 { NULL },
3659 },
3660 { "Uniwill STK7700P based (Hama and others)",
3661 { &dib0700_usb_id_table[7], NULL },
3662 { NULL },
3663 },
3664 { "Leadtek Winfast DTV Dongle (STK7700P based)",
3665 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
3666 { NULL },
3667 },
3668 { "AVerMedia AVerTV DVB-T Express",
3669 { &dib0700_usb_id_table[20] },
3670 { NULL },
3671 },
3672 { "Gigabyte U7000",
3673 { &dib0700_usb_id_table[21], NULL },
3674 { NULL },
3675 }
3676 },
3677
3678 .rc.core = {
3679 .rc_interval = DEFAULT_RC_INTERVAL,
3680 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3681 .rc_query = dib0700_rc_query_old_firmware,
3682 .allowed_protos = RC_BIT_RC5 |
3683 RC_BIT_RC6_MCE |
3684 RC_BIT_NEC,
3685 .change_protocol = dib0700_change_protocol,
3686 },
3687 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3688
3689 .num_adapters = 2,
3690 .adapter = {
3691 {
3692 .num_frontends = 1,
3693 .fe = {{
3694 .frontend_attach = bristol_frontend_attach,
3695 .tuner_attach = bristol_tuner_attach,
3696
3697 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3698 }},
3699 }, {
3700 .num_frontends = 1,
3701 .fe = {{
3702 .frontend_attach = bristol_frontend_attach,
3703 .tuner_attach = bristol_tuner_attach,
3704
3705 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3706 }},
3707 }
3708 },
3709
3710 .num_device_descs = 1,
3711 .devices = {
3712 { "Hauppauge Nova-T 500 Dual DVB-T",
3713 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
3714 { NULL },
3715 },
3716 },
3717
3718 .rc.core = {
3719 .rc_interval = DEFAULT_RC_INTERVAL,
3720 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3721 .rc_query = dib0700_rc_query_old_firmware,
3722 .allowed_protos = RC_BIT_RC5 |
3723 RC_BIT_RC6_MCE |
3724 RC_BIT_NEC,
3725 .change_protocol = dib0700_change_protocol,
3726 },
3727 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3728
3729 .num_adapters = 2,
3730 .adapter = {
3731 {
3732 .num_frontends = 1,
3733 .fe = {{
3734 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3735 .pid_filter_count = 32,
3736 .pid_filter = stk70x0p_pid_filter,
3737 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3738 .frontend_attach = stk7700d_frontend_attach,
3739 .tuner_attach = stk7700d_tuner_attach,
3740
3741 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3742 }},
3743 }, {
3744 .num_frontends = 1,
3745 .fe = {{
3746 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3747 .pid_filter_count = 32,
3748 .pid_filter = stk70x0p_pid_filter,
3749 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3750 .frontend_attach = stk7700d_frontend_attach,
3751 .tuner_attach = stk7700d_tuner_attach,
3752
3753 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3754 }},
3755 }
3756 },
3757
3758 .num_device_descs = 5,
3759 .devices = {
3760 { "Pinnacle PCTV 2000e",
3761 { &dib0700_usb_id_table[11], NULL },
3762 { NULL },
3763 },
3764 { "Terratec Cinergy DT XS Diversity",
3765 { &dib0700_usb_id_table[12], NULL },
3766 { NULL },
3767 },
3768 { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
3769 { &dib0700_usb_id_table[13], NULL },
3770 { NULL },
3771 },
3772 { "DiBcom STK7700D reference design",
3773 { &dib0700_usb_id_table[14], NULL },
3774 { NULL },
3775 },
3776 { "YUAN High-Tech DiBcom STK7700D",
3777 { &dib0700_usb_id_table[55], NULL },
3778 { NULL },
3779 },
3780
3781 },
3782
3783 .rc.core = {
3784 .rc_interval = DEFAULT_RC_INTERVAL,
3785 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3786 .rc_query = dib0700_rc_query_old_firmware,
3787 .allowed_protos = RC_BIT_RC5 |
3788 RC_BIT_RC6_MCE |
3789 RC_BIT_NEC,
3790 .change_protocol = dib0700_change_protocol,
3791 },
3792 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3793
3794 .num_adapters = 1,
3795 .adapter = {
3796 {
3797 .num_frontends = 1,
3798 .fe = {{
3799 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3800 .pid_filter_count = 32,
3801 .pid_filter = stk70x0p_pid_filter,
3802 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3803 .frontend_attach = stk7700P2_frontend_attach,
3804 .tuner_attach = stk7700d_tuner_attach,
3805
3806 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3807 }},
3808 },
3809 },
3810
3811 .num_device_descs = 3,
3812 .devices = {
3813 { "ASUS My Cinema U3000 Mini DVBT Tuner",
3814 { &dib0700_usb_id_table[23], NULL },
3815 { NULL },
3816 },
3817 { "Yuan EC372S",
3818 { &dib0700_usb_id_table[31], NULL },
3819 { NULL },
3820 },
3821 { "Terratec Cinergy T Express",
3822 { &dib0700_usb_id_table[42], NULL },
3823 { NULL },
3824 }
3825 },
3826
3827 .rc.core = {
3828 .rc_interval = DEFAULT_RC_INTERVAL,
3829 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3830 .module_name = "dib0700",
3831 .rc_query = dib0700_rc_query_old_firmware,
3832 .allowed_protos = RC_BIT_RC5 |
3833 RC_BIT_RC6_MCE |
3834 RC_BIT_NEC,
3835 .change_protocol = dib0700_change_protocol,
3836 },
3837 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3838
3839 .num_adapters = 1,
3840 .adapter = {
3841 {
3842 .num_frontends = 1,
3843 .fe = {{
3844 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3845 .pid_filter_count = 32,
3846 .pid_filter = stk70x0p_pid_filter,
3847 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3848 .frontend_attach = stk7070p_frontend_attach,
3849 .tuner_attach = dib7070p_tuner_attach,
3850
3851 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3852 }},
3853 .size_of_priv = sizeof(struct dib0700_adapter_state),
3854 },
3855 },
3856
3857 .num_device_descs = 12,
3858 .devices = {
3859 { "DiBcom STK7070P reference design",
3860 { &dib0700_usb_id_table[15], NULL },
3861 { NULL },
3862 },
3863 { "Pinnacle PCTV DVB-T Flash Stick",
3864 { &dib0700_usb_id_table[16], NULL },
3865 { NULL },
3866 },
3867 { "Artec T14BR DVB-T",
3868 { &dib0700_usb_id_table[22], NULL },
3869 { NULL },
3870 },
3871 { "ASUS My Cinema U3100 Mini DVBT Tuner",
3872 { &dib0700_usb_id_table[24], NULL },
3873 { NULL },
3874 },
3875 { "Hauppauge Nova-T Stick",
3876 { &dib0700_usb_id_table[25], NULL },
3877 { NULL },
3878 },
3879 { "Hauppauge Nova-T MyTV.t",
3880 { &dib0700_usb_id_table[26], NULL },
3881 { NULL },
3882 },
3883 { "Pinnacle PCTV 72e",
3884 { &dib0700_usb_id_table[29], NULL },
3885 { NULL },
3886 },
3887 { "Pinnacle PCTV 73e",
3888 { &dib0700_usb_id_table[30], NULL },
3889 { NULL },
3890 },
3891 { "Elgato EyeTV DTT",
3892 { &dib0700_usb_id_table[49], NULL },
3893 { NULL },
3894 },
3895 { "Yuan PD378S",
3896 { &dib0700_usb_id_table[45], NULL },
3897 { NULL },
3898 },
3899 { "Elgato EyeTV Dtt Dlx PD378S",
3900 { &dib0700_usb_id_table[50], NULL },
3901 { NULL },
3902 },
3903 { "Elgato EyeTV DTT rev. 2",
3904 { &dib0700_usb_id_table[80], NULL },
3905 { NULL },
3906 },
3907 },
3908
3909 .rc.core = {
3910 .rc_interval = DEFAULT_RC_INTERVAL,
3911 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3912 .module_name = "dib0700",
3913 .rc_query = dib0700_rc_query_old_firmware,
3914 .allowed_protos = RC_BIT_RC5 |
3915 RC_BIT_RC6_MCE |
3916 RC_BIT_NEC,
3917 .change_protocol = dib0700_change_protocol,
3918 },
3919 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3920
3921 .num_adapters = 1,
3922 .adapter = {
3923 {
3924 .num_frontends = 1,
3925 .fe = {{
3926 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3927 .pid_filter_count = 32,
3928 .pid_filter = stk70x0p_pid_filter,
3929 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3930 .frontend_attach = stk7070p_frontend_attach,
3931 .tuner_attach = dib7070p_tuner_attach,
3932
3933 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3934 }},
3935 .size_of_priv = sizeof(struct dib0700_adapter_state),
3936 },
3937 },
3938
3939 .num_device_descs = 3,
3940 .devices = {
3941 { "Pinnacle PCTV 73A",
3942 { &dib0700_usb_id_table[56], NULL },
3943 { NULL },
3944 },
3945 { "Pinnacle PCTV 73e SE",
3946 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
3947 { NULL },
3948 },
3949 { "Pinnacle PCTV 282e",
3950 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
3951 { NULL },
3952 },
3953 },
3954
3955 .rc.core = {
3956 .rc_interval = DEFAULT_RC_INTERVAL,
3957 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3958 .module_name = "dib0700",
3959 .rc_query = dib0700_rc_query_old_firmware,
3960 .allowed_protos = RC_BIT_RC5 |
3961 RC_BIT_RC6_MCE |
3962 RC_BIT_NEC,
3963 .change_protocol = dib0700_change_protocol,
3964 },
3965 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
3966
3967 .num_adapters = 2,
3968 .adapter = {
3969 {
3970 .num_frontends = 1,
3971 .fe = {{
3972 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3973 .pid_filter_count = 32,
3974 .pid_filter = stk70x0p_pid_filter,
3975 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3976 .frontend_attach = novatd_frontend_attach,
3977 .tuner_attach = dib7070p_tuner_attach,
3978
3979 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3980 }},
3981 .size_of_priv = sizeof(struct dib0700_adapter_state),
3982 }, {
3983 .num_frontends = 1,
3984 .fe = {{
3985 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3986 .pid_filter_count = 32,
3987 .pid_filter = stk70x0p_pid_filter,
3988 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
3989 .frontend_attach = novatd_frontend_attach,
3990 .tuner_attach = dib7070p_tuner_attach,
3991
3992 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
3993 }},
3994 .size_of_priv = sizeof(struct dib0700_adapter_state),
3995 }
3996 },
3997
3998 .num_device_descs = 3,
3999 .devices = {
4000 { "Hauppauge Nova-TD Stick (52009)",
4001 { &dib0700_usb_id_table[35], NULL },
4002 { NULL },
4003 },
4004 { "PCTV 2002e",
4005 { &dib0700_usb_id_table[81], NULL },
4006 { NULL },
4007 },
4008 { "PCTV 2002e SE",
4009 { &dib0700_usb_id_table[82], NULL },
4010 { NULL },
4011 },
4012 },
4013
4014 .rc.core = {
4015 .rc_interval = DEFAULT_RC_INTERVAL,
4016 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4017 .module_name = "dib0700",
4018 .rc_query = dib0700_rc_query_old_firmware,
4019 .allowed_protos = RC_BIT_RC5 |
4020 RC_BIT_RC6_MCE |
4021 RC_BIT_NEC,
4022 .change_protocol = dib0700_change_protocol,
4023 },
4024 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4025
4026 .num_adapters = 2,
4027 .adapter = {
4028 {
4029 .num_frontends = 1,
4030 .fe = {{
4031 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4032 .pid_filter_count = 32,
4033 .pid_filter = stk70x0p_pid_filter,
4034 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4035 .frontend_attach = stk7070pd_frontend_attach0,
4036 .tuner_attach = dib7070p_tuner_attach,
4037
4038 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4039 }},
4040 .size_of_priv = sizeof(struct dib0700_adapter_state),
4041 }, {
4042 .num_frontends = 1,
4043 .fe = {{
4044 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4045 .pid_filter_count = 32,
4046 .pid_filter = stk70x0p_pid_filter,
4047 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4048 .frontend_attach = stk7070pd_frontend_attach1,
4049 .tuner_attach = dib7070p_tuner_attach,
4050
4051 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4052 }},
4053 .size_of_priv = sizeof(struct dib0700_adapter_state),
4054 }
4055 },
4056
4057 .num_device_descs = 5,
4058 .devices = {
4059 { "DiBcom STK7070PD reference design",
4060 { &dib0700_usb_id_table[17], NULL },
4061 { NULL },
4062 },
4063 { "Pinnacle PCTV Dual DVB-T Diversity Stick",
4064 { &dib0700_usb_id_table[18], NULL },
4065 { NULL },
4066 },
4067 { "Hauppauge Nova-TD-500 (84xxx)",
4068 { &dib0700_usb_id_table[36], NULL },
4069 { NULL },
4070 },
4071 { "Terratec Cinergy DT USB XS Diversity/ T5",
4072 { &dib0700_usb_id_table[43],
4073 &dib0700_usb_id_table[53], NULL},
4074 { NULL },
4075 },
4076 { "Sony PlayTV",
4077 { &dib0700_usb_id_table[44], NULL },
4078 { NULL },
4079 },
4080 },
4081
4082 .rc.core = {
4083 .rc_interval = DEFAULT_RC_INTERVAL,
4084 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4085 .module_name = "dib0700",
4086 .rc_query = dib0700_rc_query_old_firmware,
4087 .allowed_protos = RC_BIT_RC5 |
4088 RC_BIT_RC6_MCE |
4089 RC_BIT_NEC,
4090 .change_protocol = dib0700_change_protocol,
4091 },
4092 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4093
4094 .num_adapters = 2,
4095 .adapter = {
4096 {
4097 .num_frontends = 1,
4098 .fe = {{
4099 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4100 .pid_filter_count = 32,
4101 .pid_filter = stk70x0p_pid_filter,
4102 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4103 .frontend_attach = stk7070pd_frontend_attach0,
4104 .tuner_attach = dib7070p_tuner_attach,
4105
4106 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4107 }},
4108 .size_of_priv = sizeof(struct dib0700_adapter_state),
4109 }, {
4110 .num_frontends = 1,
4111 .fe = {{
4112 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4113 .pid_filter_count = 32,
4114 .pid_filter = stk70x0p_pid_filter,
4115 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4116 .frontend_attach = stk7070pd_frontend_attach1,
4117 .tuner_attach = dib7070p_tuner_attach,
4118
4119 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4120 }},
4121 .size_of_priv = sizeof(struct dib0700_adapter_state),
4122 }
4123 },
4124
4125 .num_device_descs = 1,
4126 .devices = {
4127 { "Elgato EyeTV Diversity",
4128 { &dib0700_usb_id_table[68], NULL },
4129 { NULL },
4130 },
4131 },
4132
4133 .rc.core = {
4134 .rc_interval = DEFAULT_RC_INTERVAL,
4135 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
4136 .module_name = "dib0700",
4137 .rc_query = dib0700_rc_query_old_firmware,
4138 .allowed_protos = RC_BIT_RC5 |
4139 RC_BIT_RC6_MCE |
4140 RC_BIT_NEC,
4141 .change_protocol = dib0700_change_protocol,
4142 },
4143 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4144
4145 .num_adapters = 1,
4146 .adapter = {
4147 {
4148 .num_frontends = 1,
4149 .fe = {{
4150 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4151 .pid_filter_count = 32,
4152 .pid_filter = stk70x0p_pid_filter,
4153 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4154 .frontend_attach = stk7700ph_frontend_attach,
4155 .tuner_attach = stk7700ph_tuner_attach,
4156
4157 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4158 }},
4159 .size_of_priv = sizeof(struct
4160 dib0700_adapter_state),
4161 },
4162 },
4163
4164 .num_device_descs = 9,
4165 .devices = {
4166 { "Terratec Cinergy HT USB XE",
4167 { &dib0700_usb_id_table[27], NULL },
4168 { NULL },
4169 },
4170 { "Pinnacle Expresscard 320cx",
4171 { &dib0700_usb_id_table[28], NULL },
4172 { NULL },
4173 },
4174 { "Terratec Cinergy HT Express",
4175 { &dib0700_usb_id_table[32], NULL },
4176 { NULL },
4177 },
4178 { "Gigabyte U8000-RH",
4179 { &dib0700_usb_id_table[37], NULL },
4180 { NULL },
4181 },
4182 { "YUAN High-Tech STK7700PH",
4183 { &dib0700_usb_id_table[38], NULL },
4184 { NULL },
4185 },
4186 { "Asus My Cinema-U3000Hybrid",
4187 { &dib0700_usb_id_table[39], NULL },
4188 { NULL },
4189 },
4190 { "YUAN High-Tech MC770",
4191 { &dib0700_usb_id_table[48], NULL },
4192 { NULL },
4193 },
4194 { "Leadtek WinFast DTV Dongle H",
4195 { &dib0700_usb_id_table[51], NULL },
4196 { NULL },
4197 },
4198 { "YUAN High-Tech STK7700D",
4199 { &dib0700_usb_id_table[54], NULL },
4200 { NULL },
4201 },
4202 },
4203
4204 .rc.core = {
4205 .rc_interval = DEFAULT_RC_INTERVAL,
4206 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4207 .module_name = "dib0700",
4208 .rc_query = dib0700_rc_query_old_firmware,
4209 .allowed_protos = RC_BIT_RC5 |
4210 RC_BIT_RC6_MCE |
4211 RC_BIT_NEC,
4212 .change_protocol = dib0700_change_protocol,
4213 },
4214 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4215 .num_adapters = 1,
4216 .adapter = {
4217 {
4218 .num_frontends = 1,
4219 .fe = {{
4220 .frontend_attach = s5h1411_frontend_attach,
4221 .tuner_attach = xc5000_tuner_attach,
4222
4223 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4224 }},
4225 .size_of_priv = sizeof(struct
4226 dib0700_adapter_state),
4227 },
4228 },
4229
4230 .num_device_descs = 2,
4231 .devices = {
4232 { "Pinnacle PCTV HD Pro USB Stick",
4233 { &dib0700_usb_id_table[40], NULL },
4234 { NULL },
4235 },
4236 { "Pinnacle PCTV HD USB Stick",
4237 { &dib0700_usb_id_table[41], NULL },
4238 { NULL },
4239 },
4240 },
4241
4242 .rc.core = {
4243 .rc_interval = DEFAULT_RC_INTERVAL,
4244 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4245 .module_name = "dib0700",
4246 .rc_query = dib0700_rc_query_old_firmware,
4247 .allowed_protos = RC_BIT_RC5 |
4248 RC_BIT_RC6_MCE |
4249 RC_BIT_NEC,
4250 .change_protocol = dib0700_change_protocol,
4251 },
4252 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4253 .num_adapters = 1,
4254 .adapter = {
4255 {
4256 .num_frontends = 1,
4257 .fe = {{
4258 .frontend_attach = lgdt3305_frontend_attach,
4259 .tuner_attach = mxl5007t_tuner_attach,
4260
4261 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4262 }},
4263 .size_of_priv = sizeof(struct
4264 dib0700_adapter_state),
4265 },
4266 },
4267
4268 .num_device_descs = 2,
4269 .devices = {
4270 { "Hauppauge ATSC MiniCard (B200)",
4271 { &dib0700_usb_id_table[46], NULL },
4272 { NULL },
4273 },
4274 { "Hauppauge ATSC MiniCard (B210)",
4275 { &dib0700_usb_id_table[47], NULL },
4276 { NULL },
4277 },
4278 },
4279 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4280
4281 .num_adapters = 1,
4282 .adapter = {
4283 {
4284 .num_frontends = 1,
4285 .fe = {{
4286 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4287 .pid_filter_count = 32,
4288 .pid_filter = stk70x0p_pid_filter,
4289 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4290 .frontend_attach = stk7770p_frontend_attach,
4291 .tuner_attach = dib7770p_tuner_attach,
4292
4293 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4294 }},
4295 .size_of_priv =
4296 sizeof(struct dib0700_adapter_state),
4297 },
4298 },
4299
4300 .num_device_descs = 4,
4301 .devices = {
4302 { "DiBcom STK7770P reference design",
4303 { &dib0700_usb_id_table[59], NULL },
4304 { NULL },
4305 },
4306 { "Terratec Cinergy T USB XXS (HD)/ T3",
4307 { &dib0700_usb_id_table[33],
4308 &dib0700_usb_id_table[52],
4309 &dib0700_usb_id_table[60], NULL},
4310 { NULL },
4311 },
4312 { "TechniSat AirStar TeleStick 2",
4313 { &dib0700_usb_id_table[74], NULL },
4314 { NULL },
4315 },
4316 { "Medion CTX1921 DVB-T USB",
4317 { &dib0700_usb_id_table[75], NULL },
4318 { NULL },
4319 },
4320 },
4321
4322 .rc.core = {
4323 .rc_interval = DEFAULT_RC_INTERVAL,
4324 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4325 .module_name = "dib0700",
4326 .rc_query = dib0700_rc_query_old_firmware,
4327 .allowed_protos = RC_BIT_RC5 |
4328 RC_BIT_RC6_MCE |
4329 RC_BIT_NEC,
4330 .change_protocol = dib0700_change_protocol,
4331 },
4332 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4333 .num_adapters = 1,
4334 .adapter = {
4335 {
4336 .num_frontends = 1,
4337 .fe = {{
4338 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4339 .pid_filter_count = 32,
4340 .pid_filter = stk80xx_pid_filter,
4341 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4342 .frontend_attach = stk807x_frontend_attach,
4343 .tuner_attach = dib807x_tuner_attach,
4344
4345 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4346 }},
4347 .size_of_priv =
4348 sizeof(struct dib0700_adapter_state),
4349 },
4350 },
4351
4352 .num_device_descs = 3,
4353 .devices = {
4354 { "DiBcom STK807xP reference design",
4355 { &dib0700_usb_id_table[62], NULL },
4356 { NULL },
4357 },
4358 { "Prolink Pixelview SBTVD",
4359 { &dib0700_usb_id_table[63], NULL },
4360 { NULL },
4361 },
4362 { "EvolutePC TVWay+",
4363 { &dib0700_usb_id_table[64], NULL },
4364 { NULL },
4365 },
4366 },
4367
4368 .rc.core = {
4369 .rc_interval = DEFAULT_RC_INTERVAL,
4370 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
4371 .module_name = "dib0700",
4372 .rc_query = dib0700_rc_query_old_firmware,
4373 .allowed_protos = RC_BIT_RC5 |
4374 RC_BIT_RC6_MCE |
4375 RC_BIT_NEC,
4376 .change_protocol = dib0700_change_protocol,
4377 },
4378 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4379 .num_adapters = 2,
4380 .adapter = {
4381 {
4382 .num_frontends = 1,
4383 .fe = {{
4384 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4385 .pid_filter_count = 32,
4386 .pid_filter = stk80xx_pid_filter,
4387 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4388 .frontend_attach = stk807xpvr_frontend_attach0,
4389 .tuner_attach = dib807x_tuner_attach,
4390
4391 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4392 }},
4393 .size_of_priv =
4394 sizeof(struct dib0700_adapter_state),
4395 },
4396 {
4397 .num_frontends = 1,
4398 .fe = {{
4399 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4400 .pid_filter_count = 32,
4401 .pid_filter = stk80xx_pid_filter,
4402 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4403 .frontend_attach = stk807xpvr_frontend_attach1,
4404 .tuner_attach = dib807x_tuner_attach,
4405
4406 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4407 }},
4408 .size_of_priv =
4409 sizeof(struct dib0700_adapter_state),
4410 },
4411 },
4412
4413 .num_device_descs = 1,
4414 .devices = {
4415 { "DiBcom STK807xPVR reference design",
4416 { &dib0700_usb_id_table[61], NULL },
4417 { NULL },
4418 },
4419 },
4420
4421 .rc.core = {
4422 .rc_interval = DEFAULT_RC_INTERVAL,
4423 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4424 .module_name = "dib0700",
4425 .rc_query = dib0700_rc_query_old_firmware,
4426 .allowed_protos = RC_BIT_RC5 |
4427 RC_BIT_RC6_MCE |
4428 RC_BIT_NEC,
4429 .change_protocol = dib0700_change_protocol,
4430 },
4431 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4432 .num_adapters = 1,
4433 .adapter = {
4434 {
4435 .num_frontends = 1,
4436 .fe = {{
4437 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4438 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4439 .pid_filter_count = 32,
4440 .pid_filter = stk80xx_pid_filter,
4441 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4442 .frontend_attach = stk809x_frontend_attach,
4443 .tuner_attach = dib809x_tuner_attach,
4444
4445 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4446 }},
4447 .size_of_priv =
4448 sizeof(struct dib0700_adapter_state),
4449 },
4450 },
4451
4452 .num_device_descs = 1,
4453 .devices = {
4454 { "DiBcom STK8096GP reference design",
4455 { &dib0700_usb_id_table[67], NULL },
4456 { NULL },
4457 },
4458 },
4459
4460 .rc.core = {
4461 .rc_interval = DEFAULT_RC_INTERVAL,
4462 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4463 .module_name = "dib0700",
4464 .rc_query = dib0700_rc_query_old_firmware,
4465 .allowed_protos = RC_BIT_RC5 |
4466 RC_BIT_RC6_MCE |
4467 RC_BIT_NEC,
4468 .change_protocol = dib0700_change_protocol,
4469 },
4470 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4471 .num_adapters = 1,
4472 .adapter = {
4473 {
4474 .num_frontends = 1,
4475 .fe = {{
4476 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4477 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4478 .pid_filter_count = 32,
4479 .pid_filter = dib90x0_pid_filter,
4480 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4481 .frontend_attach = stk9090m_frontend_attach,
4482 .tuner_attach = dib9090_tuner_attach,
4483
4484 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4485 }},
4486 .size_of_priv =
4487 sizeof(struct dib0700_adapter_state),
4488 },
4489 },
4490
4491 .num_device_descs = 1,
4492 .devices = {
4493 { "DiBcom STK9090M reference design",
4494 { &dib0700_usb_id_table[69], NULL },
4495 { NULL },
4496 },
4497 },
4498
4499 .rc.core = {
4500 .rc_interval = DEFAULT_RC_INTERVAL,
4501 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4502 .module_name = "dib0700",
4503 .rc_query = dib0700_rc_query_old_firmware,
4504 .allowed_protos = RC_BIT_RC5 |
4505 RC_BIT_RC6_MCE |
4506 RC_BIT_NEC,
4507 .change_protocol = dib0700_change_protocol,
4508 },
4509 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4510 .num_adapters = 1,
4511 .adapter = {
4512 {
4513 .num_frontends = 1,
4514 .fe = {{
4515 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4516 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4517 .pid_filter_count = 32,
4518 .pid_filter = stk80xx_pid_filter,
4519 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4520 .frontend_attach = nim8096md_frontend_attach,
4521 .tuner_attach = nim8096md_tuner_attach,
4522
4523 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4524 }},
4525 .size_of_priv =
4526 sizeof(struct dib0700_adapter_state),
4527 },
4528 },
4529
4530 .num_device_descs = 1,
4531 .devices = {
4532 { "DiBcom NIM8096MD reference design",
4533 { &dib0700_usb_id_table[70], NULL },
4534 { NULL },
4535 },
4536 },
4537
4538 .rc.core = {
4539 .rc_interval = DEFAULT_RC_INTERVAL,
4540 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4541 .module_name = "dib0700",
4542 .rc_query = dib0700_rc_query_old_firmware,
4543 .allowed_protos = RC_BIT_RC5 |
4544 RC_BIT_RC6_MCE |
4545 RC_BIT_NEC,
4546 .change_protocol = dib0700_change_protocol,
4547 },
4548 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4549 .num_adapters = 1,
4550 .adapter = {
4551 {
4552 .num_frontends = 1,
4553 .fe = {{
4554 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4555 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4556 .pid_filter_count = 32,
4557 .pid_filter = dib90x0_pid_filter,
4558 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4559 .frontend_attach = nim9090md_frontend_attach,
4560 .tuner_attach = nim9090md_tuner_attach,
4561
4562 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4563 }},
4564 .size_of_priv =
4565 sizeof(struct dib0700_adapter_state),
4566 },
4567 },
4568
4569 .num_device_descs = 1,
4570 .devices = {
4571 { "DiBcom NIM9090MD reference design",
4572 { &dib0700_usb_id_table[71], NULL },
4573 { NULL },
4574 },
4575 },
4576
4577 .rc.core = {
4578 .rc_interval = DEFAULT_RC_INTERVAL,
4579 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4580 .module_name = "dib0700",
4581 .rc_query = dib0700_rc_query_old_firmware,
4582 .allowed_protos = RC_BIT_RC5 |
4583 RC_BIT_RC6_MCE |
4584 RC_BIT_NEC,
4585 .change_protocol = dib0700_change_protocol,
4586 },
4587 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4588 .num_adapters = 1,
4589 .adapter = {
4590 {
4591 .num_frontends = 1,
4592 .fe = {{
4593 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4594 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4595 .pid_filter_count = 32,
4596 .pid_filter = stk70x0p_pid_filter,
4597 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4598 .frontend_attach = nim7090_frontend_attach,
4599 .tuner_attach = nim7090_tuner_attach,
4600
4601 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4602 }},
4603 .size_of_priv =
4604 sizeof(struct dib0700_adapter_state),
4605 },
4606 },
4607
4608 .num_device_descs = 1,
4609 .devices = {
4610 { "DiBcom NIM7090 reference design",
4611 { &dib0700_usb_id_table[72], NULL },
4612 { NULL },
4613 },
4614 },
4615
4616 .rc.core = {
4617 .rc_interval = DEFAULT_RC_INTERVAL,
4618 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4619 .module_name = "dib0700",
4620 .rc_query = dib0700_rc_query_old_firmware,
4621 .allowed_protos = RC_BIT_RC5 |
4622 RC_BIT_RC6_MCE |
4623 RC_BIT_NEC,
4624 .change_protocol = dib0700_change_protocol,
4625 },
4626 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4627 .num_adapters = 2,
4628 .adapter = {
4629 {
4630 .num_frontends = 1,
4631 .fe = {{
4632 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4633 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4634 .pid_filter_count = 32,
4635 .pid_filter = stk70x0p_pid_filter,
4636 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4637 .frontend_attach = tfe7090pvr_frontend0_attach,
4638 .tuner_attach = tfe7090pvr_tuner0_attach,
4639
4640 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4641 }},
4642 .size_of_priv =
4643 sizeof(struct dib0700_adapter_state),
4644 },
4645 {
4646 .num_frontends = 1,
4647 .fe = {{
4648 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4649 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4650 .pid_filter_count = 32,
4651 .pid_filter = stk70x0p_pid_filter,
4652 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4653 .frontend_attach = tfe7090pvr_frontend1_attach,
4654 .tuner_attach = tfe7090pvr_tuner1_attach,
4655
4656 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4657 }},
4658 .size_of_priv =
4659 sizeof(struct dib0700_adapter_state),
4660 },
4661 },
4662
4663 .num_device_descs = 1,
4664 .devices = {
4665 { "DiBcom TFE7090PVR reference design",
4666 { &dib0700_usb_id_table[73], NULL },
4667 { NULL },
4668 },
4669 },
4670
4671 .rc.core = {
4672 .rc_interval = DEFAULT_RC_INTERVAL,
4673 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4674 .module_name = "dib0700",
4675 .rc_query = dib0700_rc_query_old_firmware,
4676 .allowed_protos = RC_BIT_RC5 |
4677 RC_BIT_RC6_MCE |
4678 RC_BIT_NEC,
4679 .change_protocol = dib0700_change_protocol,
4680 },
4681 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4682 .num_adapters = 1,
4683 .adapter = {
4684 {
4685 .num_frontends = 1,
4686 .fe = {{
4687 .frontend_attach = pctv340e_frontend_attach,
4688 .tuner_attach = xc4000_tuner_attach,
4689
4690 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4691 }},
4692 .size_of_priv = sizeof(struct
4693 dib0700_adapter_state),
4694 },
4695 },
4696
4697 .num_device_descs = 2,
4698 .devices = {
4699 { "Pinnacle PCTV 340e HD Pro USB Stick",
4700 { &dib0700_usb_id_table[76], NULL },
4701 { NULL },
4702 },
4703 { "Pinnacle PCTV Hybrid Stick Solo",
4704 { &dib0700_usb_id_table[77], NULL },
4705 { NULL },
4706 },
4707 },
4708 .rc.core = {
4709 .rc_interval = DEFAULT_RC_INTERVAL,
4710 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4711 .module_name = "dib0700",
4712 .rc_query = dib0700_rc_query_old_firmware,
4713 .allowed_protos = RC_BIT_RC5 |
4714 RC_BIT_RC6_MCE |
4715 RC_BIT_NEC,
4716 .change_protocol = dib0700_change_protocol,
4717 },
4718 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4719 .num_adapters = 1,
4720 .adapter = {
4721 {
4722 .num_frontends = 1,
4723 .fe = {{
4724 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4725 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4726 .pid_filter_count = 32,
4727 .pid_filter = stk70x0p_pid_filter,
4728 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4729 .frontend_attach = tfe7790p_frontend_attach,
4730 .tuner_attach = tfe7790p_tuner_attach,
4731
4732 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4733 } },
4734
4735 .size_of_priv =
4736 sizeof(struct dib0700_adapter_state),
4737 },
4738 },
4739
4740 .num_device_descs = 1,
4741 .devices = {
4742 { "DiBcom TFE7790P reference design",
4743 { &dib0700_usb_id_table[78], NULL },
4744 { NULL },
4745 },
4746 },
4747
4748 .rc.core = {
4749 .rc_interval = DEFAULT_RC_INTERVAL,
4750 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4751 .module_name = "dib0700",
4752 .rc_query = dib0700_rc_query_old_firmware,
4753 .allowed_protos = RC_BIT_RC5 |
4754 RC_BIT_RC6_MCE |
4755 RC_BIT_NEC,
4756 .change_protocol = dib0700_change_protocol,
4757 },
4758 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4759 .num_adapters = 1,
4760 .adapter = {
4761 {
4762 .num_frontends = 1,
4763 .fe = {{
4764 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4765 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4766 .pid_filter_count = 32,
4767 .pid_filter = stk80xx_pid_filter,
4768 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4769 .frontend_attach = tfe8096p_frontend_attach,
4770 .tuner_attach = tfe8096p_tuner_attach,
4771
4772 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4773
4774 } },
4775
4776 .size_of_priv =
4777 sizeof(struct dib0700_adapter_state),
4778 },
4779 },
4780
4781 .num_device_descs = 1,
4782 .devices = {
4783 { "DiBcom TFE8096P reference design",
4784 { &dib0700_usb_id_table[79], NULL },
4785 { NULL },
4786 },
4787 },
4788
4789 .rc.core = {
4790 .rc_interval = DEFAULT_RC_INTERVAL,
4791 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4792 .module_name = "dib0700",
4793 .rc_query = dib0700_rc_query_old_firmware,
4794 .allowed_protos = RC_BIT_RC5 |
4795 RC_BIT_RC6_MCE |
4796 RC_BIT_NEC,
4797 .change_protocol = dib0700_change_protocol,
4798 },
4799 },
4800 };
4801
4802 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
Linux with added FPC-III support