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