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