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