?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / media / usb / dvb-usb / dib0700_devices.c
blob710c1afe3e85c25e994882cdf6d0513bc4dee5e1
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
3 *
4 * Copyright (C) 2005-9 DiBcom, SA et al
5 */
6 #include "dib0700.h"
7
8 #include "dib3000mc.h"
9 #include "dib7000m.h"
10 #include "dib7000p.h"
11 #include "dib8000.h"
12 #include "dib9000.h"
13 #include "mt2060.h"
14 #include "mt2266.h"
15 #include "tuner-xc2028.h"
16 #include "xc5000.h"
17 #include "xc4000.h"
18 #include "s5h1411.h"
19 #include "dib0070.h"
20 #include "dib0090.h"
21 #include "lgdt3305.h"
22 #include "mxl5007t.h"
23 #include "mn88472.h"
24 #include "tda18250.h"
25
26
27 static int force_lna_activation;
28 module_param(force_lna_activation, int, 0644);
29 MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifier(s) (LNA), if applicable for the device (default: 0=automatic/off).");
30
31 struct dib0700_adapter_state {
32 int (*set_param_save) (struct dvb_frontend *);
33 const struct firmware *frontend_firmware;
34 struct dib7000p_ops dib7000p_ops;
35 struct dib8000_ops dib8000_ops;
36 };
37
38 /* Hauppauge Nova-T 500 (aka Bristol)
39 * has a LNA on GPIO0 which is enabled by setting 1 */
40 static struct mt2060_config bristol_mt2060_config[2] = {
41 {
42 .i2c_address = 0x60,
43 .clock_out = 3,
44 }, {
45 .i2c_address = 0x61,
46 }
47 };
48
49
50 static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
51 .band_caps = BAND_VHF | BAND_UHF,
52 .setup = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
53
54 .agc1_max = 42598,
55 .agc1_min = 17694,
56 .agc2_max = 45875,
57 .agc2_min = 0,
58
59 .agc1_pt1 = 0,
60 .agc1_pt2 = 59,
61
62 .agc1_slope1 = 0,
63 .agc1_slope2 = 69,
64
65 .agc2_pt1 = 0,
66 .agc2_pt2 = 59,
67
68 .agc2_slope1 = 111,
69 .agc2_slope2 = 28,
70 };
71
72 static struct dib3000mc_config bristol_dib3000mc_config[2] = {
73 { .agc = &bristol_dib3000p_mt2060_agc_config,
74 .max_time = 0x196,
75 .ln_adc_level = 0x1cc7,
76 .output_mpeg2_in_188_bytes = 1,
77 },
78 { .agc = &bristol_dib3000p_mt2060_agc_config,
79 .max_time = 0x196,
80 .ln_adc_level = 0x1cc7,
81 .output_mpeg2_in_188_bytes = 1,
82 }
83 };
84
85 static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
86 {
87 struct dib0700_state *st = adap->dev->priv;
88 if (adap->id == 0) {
89 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
90 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
91 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
92 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
93
94 if (force_lna_activation)
95 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
96 else
97 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
98
99 if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
100 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
101 return -ENODEV;
102 }
103 }
104 st->mt2060_if1[adap->id] = 1220;
105 return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
106 (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
107 }
108
109 static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
110 {
111 struct i2c_msg msg[2] = {
112 { .addr = 0x50, .flags = 0, .buf = &adrs, .len = 1 },
113 { .addr = 0x50, .flags = I2C_M_RD, .buf = pval, .len = 1 },
114 };
115 if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
116 return 0;
117 }
118
119 static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
120 {
121 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
122 struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe_adap[0].fe, 1);
123 s8 a;
124 int if1=1220;
125 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
126 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
127 if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
128 }
129 return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
130 &bristol_mt2060_config[adap->id], if1) == NULL ?
131 -ENODEV : 0;
132 }
133
134 /* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
135
136 /* MT226x */
137 static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
138 {
139 BAND_UHF,
140
141 /* 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,
142 * 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 */
143 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
144 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
145
146 1130,
147 21,
148
149 0,
150 118,
151
152 0,
153 3530,
154 1,
155 0,
156
157 65535,
158 33770,
159 65535,
160 23592,
161
162 0,
163 62,
164 255,
165 64,
166 64,
167 132,
168 192,
169 80,
170 80,
171
172 17,
173 27,
174 23,
175 51,
176
177 1,
178 }, {
179 BAND_VHF | BAND_LBAND,
180
181 /* 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,
182 * 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 */
183 (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
184 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
185
186 2372,
187 21,
188
189 0,
190 118,
191
192 0,
193 3530,
194 1,
195 0,
196
197 65535,
198 0,
199 65535,
200 23592,
201
202 0,
203 128,
204 128,
205 128,
206 0,
207 128,
208 253,
209 81,
210 0,
211
212 17,
213 27,
214 23,
215 51,
216
217 1,
218 }
219 };
220
221 static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
222 .internal = 60000,
223 .sampling = 30000,
224 .pll_prediv = 1,
225 .pll_ratio = 8,
226 .pll_range = 3,
227 .pll_reset = 1,
228 .pll_bypass = 0,
229 .enable_refdiv = 0,
230 .bypclk_div = 0,
231 .IO_CLK_en_core = 1,
232 .ADClkSrc = 1,
233 .modulo = 2,
234 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
235 .ifreq = 0,
236 .timf = 20452225,
237 };
238
239 static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
240 { .output_mpeg2_in_188_bytes = 1,
241 .hostbus_diversity = 1,
242 .tuner_is_baseband = 1,
243
244 .agc_config_count = 2,
245 .agc = stk7700d_7000p_mt2266_agc_config,
246 .bw = &stk7700d_mt2266_pll_config,
247
248 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
249 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
250 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
251 },
252 { .output_mpeg2_in_188_bytes = 1,
253 .hostbus_diversity = 1,
254 .tuner_is_baseband = 1,
255
256 .agc_config_count = 2,
257 .agc = stk7700d_7000p_mt2266_agc_config,
258 .bw = &stk7700d_mt2266_pll_config,
259
260 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
261 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
262 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
263 }
264 };
265
266 static struct mt2266_config stk7700d_mt2266_config[2] = {
267 { .i2c_address = 0x60
268 },
269 { .i2c_address = 0x60
270 }
271 };
272
273 static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
274 {
275 struct dib0700_adapter_state *state = adap->priv;
276
277 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
278 return -ENODEV;
279
280 if (adap->id == 0) {
281 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
282 msleep(10);
283 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
284 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
285 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
286 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
287 msleep(10);
288 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
289 msleep(10);
290 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
291 stk7700d_dib7000p_mt2266_config)
292 != 0) {
293 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__);
294 dvb_detach(state->dib7000p_ops.set_wbd_ref);
295 return -ENODEV;
296 }
297 }
298
299 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
300 0x80 + (adap->id << 1),
301 &stk7700d_dib7000p_mt2266_config[adap->id]);
302
303 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
304 }
305
306 static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
307 {
308 struct dib0700_adapter_state *state = adap->priv;
309
310 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
311 return -ENODEV;
312
313 if (adap->id == 0) {
314 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
315 msleep(10);
316 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
317 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
318 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
319 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
320 msleep(10);
321 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
322 msleep(10);
323 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
324 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
325 stk7700d_dib7000p_mt2266_config)
326 != 0) {
327 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__);
328 dvb_detach(state->dib7000p_ops.set_wbd_ref);
329 return -ENODEV;
330 }
331 }
332
333 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
334 0x80 + (adap->id << 1),
335 &stk7700d_dib7000p_mt2266_config[adap->id]);
336
337 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
338 }
339
340 static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
341 {
342 struct i2c_adapter *tun_i2c;
343 struct dib0700_adapter_state *state = adap->priv;
344
345 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
346 DIBX000_I2C_INTERFACE_TUNER, 1);
347 return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
348 &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
349 }
350
351 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
352 static struct dibx000_agc_config xc3028_agc_config = {
353 .band_caps = BAND_VHF | BAND_UHF,
354 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
355 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
356 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
357 .setup = (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
358 .inv_gain = 712,
359 .time_stabiliz = 21,
360 .alpha_level = 0,
361 .thlock = 118,
362 .wbd_inv = 0,
363 .wbd_ref = 2867,
364 .wbd_sel = 0,
365 .wbd_alpha = 2,
366 .agc1_max = 0,
367 .agc1_min = 0,
368 .agc2_max = 39718,
369 .agc2_min = 9930,
370 .agc1_pt1 = 0,
371 .agc1_pt2 = 0,
372 .agc1_pt3 = 0,
373 .agc1_slope1 = 0,
374 .agc1_slope2 = 0,
375 .agc2_pt1 = 0,
376 .agc2_pt2 = 128,
377 .agc2_slope1 = 29,
378 .agc2_slope2 = 29,
379 .alpha_mant = 17,
380 .alpha_exp = 27,
381 .beta_mant = 23,
382 .beta_exp = 51,
383 .perform_agc_softsplit = 1,
384 };
385
386 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
387 static struct dibx000_bandwidth_config xc3028_bw_config = {
388 .internal = 60000,
389 .sampling = 30000,
390 .pll_prediv = 1,
391 .pll_ratio = 8,
392 .pll_range = 3,
393 .pll_reset = 1,
394 .pll_bypass = 0,
395 .enable_refdiv = 0,
396 .bypclk_div = 0,
397 .IO_CLK_en_core = 1,
398 .ADClkSrc = 1,
399 .modulo = 0,
400 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
401 .ifreq = (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
402 .timf = 20452225,
403 .xtal_hz = 30000000,
404 };
405
406 static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
407 .output_mpeg2_in_188_bytes = 1,
408 .tuner_is_baseband = 1,
409
410 .agc_config_count = 1,
411 .agc = &xc3028_agc_config,
412 .bw = &xc3028_bw_config,
413
414 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
415 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
416 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
417 };
418
419 static int stk7700ph_xc3028_callback(void *ptr, int component,
420 int command, int arg)
421 {
422 struct dvb_usb_adapter *adap = ptr;
423 struct dib0700_adapter_state *state = adap->priv;
424
425 switch (command) {
426 case XC2028_TUNER_RESET:
427 /* Send the tuner in then out of reset */
428 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
429 msleep(10);
430 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
431 break;
432 case XC2028_RESET_CLK:
433 case XC2028_I2C_FLUSH:
434 break;
435 default:
436 err("%s: unknown command %d, arg %d\n", __func__,
437 command, arg);
438 return -EINVAL;
439 }
440 return 0;
441 }
442
443 static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
444 .fname = XC2028_DEFAULT_FIRMWARE,
445 .max_len = 64,
446 .demod = XC3028_FE_DIBCOM52,
447 };
448
449 static struct xc2028_config stk7700ph_xc3028_config = {
450 .i2c_addr = 0x61,
451 .ctrl = &stk7700ph_xc3028_ctrl,
452 };
453
454 static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
455 {
456 struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
457 struct dib0700_adapter_state *state = adap->priv;
458
459 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
460 return -ENODEV;
461
462 if (desc->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
463 desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
464 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
465 else
466 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
467 msleep(20);
468 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
469 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
470 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
471 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
472 msleep(10);
473 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
474 msleep(20);
475 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
476 msleep(10);
477
478 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
479 &stk7700ph_dib7700_xc3028_config) != 0) {
480 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
481 __func__);
482 dvb_detach(state->dib7000p_ops.set_wbd_ref);
483 return -ENODEV;
484 }
485
486 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
487 &stk7700ph_dib7700_xc3028_config);
488
489 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
490 }
491
492 static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
493 {
494 struct i2c_adapter *tun_i2c;
495 struct dib0700_adapter_state *state = adap->priv;
496
497 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
498 DIBX000_I2C_INTERFACE_TUNER, 1);
499
500 stk7700ph_xc3028_config.i2c_adap = tun_i2c;
501
502 /* FIXME: generalize & move to common area */
503 adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback;
504
505 return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config)
506 == NULL ? -ENODEV : 0;
507 }
508
509 #define DEFAULT_RC_INTERVAL 50
510
511 /*
512 * This function is used only when firmware is < 1.20 version. Newer
513 * firmwares use bulk mode, with functions implemented at dib0700_core,
514 * at dib0700_rc_urb_completion()
515 */
516 static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
517 {
518 enum rc_proto protocol;
519 u32 scancode;
520 u8 toggle;
521 int i;
522 struct dib0700_state *st = d->priv;
523
524 if (st->fw_version >= 0x10200) {
525 /* For 1.20 firmware , We need to keep the RC polling
526 callback so we can reuse the input device setup in
527 dvb-usb-remote.c. However, the actual work is being done
528 in the bulk URB completion handler. */
529 return 0;
530 }
531
532 st->buf[0] = REQUEST_POLL_RC;
533 st->buf[1] = 0;
534
535 i = dib0700_ctrl_rd(d, st->buf, 2, st->buf, 4);
536 if (i <= 0) {
537 err("RC Query Failed");
538 return -EIO;
539 }
540
541 /* losing half of KEY_0 events from Philipps rc5 remotes.. */
542 if (st->buf[0] == 0 && st->buf[1] == 0
543 && st->buf[2] == 0 && st->buf[3] == 0)
544 return 0;
545
546 /* 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]); */
547
548 dib0700_rc_setup(d, NULL); /* reset ir sensor data to prevent false events */
549
550 switch (d->props.rc.core.protocol) {
551 case RC_PROTO_BIT_NEC:
552 /* NEC protocol sends repeat code as 0 0 0 FF */
553 if ((st->buf[3 - 2] == 0x00) && (st->buf[3 - 3] == 0x00) &&
554 (st->buf[3] == 0xff)) {
555 rc_repeat(d->rc_dev);
556 return 0;
557 }
558
559 protocol = RC_PROTO_NEC;
560 scancode = RC_SCANCODE_NEC(st->buf[3 - 2], st->buf[3 - 3]);
561 toggle = 0;
562 break;
563
564 default:
565 /* RC-5 protocol changes toggle bit on new keypress */
566 protocol = RC_PROTO_RC5;
567 scancode = RC_SCANCODE_RC5(st->buf[3 - 2], st->buf[3 - 3]);
568 toggle = st->buf[3 - 1];
569 break;
570 }
571
572 rc_keydown(d->rc_dev, protocol, scancode, toggle);
573 return 0;
574 }
575
576 /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
577 static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
578 BAND_UHF | BAND_VHF,
579
580 /* 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,
581 * 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 */
582 (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
583 | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
584
585 712,
586 41,
587
588 0,
589 118,
590
591 0,
592 4095,
593 0,
594 0,
595
596 42598,
597 17694,
598 45875,
599 2621,
600 0,
601 76,
602 139,
603 52,
604 59,
605 107,
606 172,
607 57,
608 70,
609
610 21,
611 25,
612 28,
613 48,
614
615 1,
616 { 0,
617 107,
618 51800,
619 24700
620 },
621 };
622
623 static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
624 .band_caps = BAND_UHF | BAND_VHF,
625 /* 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,
626 * 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 */
627 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
628 .inv_gain = 712,
629 .time_stabiliz = 41,
630 .alpha_level = 0,
631 .thlock = 118,
632 .wbd_inv = 0,
633 .wbd_ref = 4095,
634 .wbd_sel = 0,
635 .wbd_alpha = 0,
636 .agc1_max = 42598,
637 .agc1_min = 16384,
638 .agc2_max = 42598,
639 .agc2_min = 0,
640 .agc1_pt1 = 0,
641 .agc1_pt2 = 137,
642 .agc1_pt3 = 255,
643 .agc1_slope1 = 0,
644 .agc1_slope2 = 255,
645 .agc2_pt1 = 0,
646 .agc2_pt2 = 0,
647 .agc2_slope1 = 0,
648 .agc2_slope2 = 41,
649 .alpha_mant = 15,
650 .alpha_exp = 25,
651 .beta_mant = 28,
652 .beta_exp = 48,
653 .perform_agc_softsplit = 0,
654 };
655
656 static struct dibx000_bandwidth_config stk7700p_pll_config = {
657 .internal = 60000,
658 .sampling = 30000,
659 .pll_prediv = 1,
660 .pll_ratio = 8,
661 .pll_range = 3,
662 .pll_reset = 1,
663 .pll_bypass = 0,
664 .enable_refdiv = 0,
665 .bypclk_div = 0,
666 .IO_CLK_en_core = 1,
667 .ADClkSrc = 1,
668 .modulo = 0,
669 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
670 .ifreq = 60258167,
671 .timf = 20452225,
672 .xtal_hz = 30000000,
673 };
674
675 static struct dib7000m_config stk7700p_dib7000m_config = {
676 .dvbt_mode = 1,
677 .output_mpeg2_in_188_bytes = 1,
678 .quartz_direct = 1,
679
680 .agc_config_count = 1,
681 .agc = &stk7700p_7000m_mt2060_agc_config,
682 .bw = &stk7700p_pll_config,
683
684 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
685 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
686 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
687 };
688
689 static struct dib7000p_config stk7700p_dib7000p_config = {
690 .output_mpeg2_in_188_bytes = 1,
691
692 .agc_config_count = 1,
693 .agc = &stk7700p_7000p_mt2060_agc_config,
694 .bw = &stk7700p_pll_config,
695
696 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
697 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
698 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
699 };
700
701 static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
702 {
703 struct dib0700_state *st = adap->dev->priv;
704 struct dib0700_adapter_state *state = adap->priv;
705
706 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
707 return -ENODEV;
708
709 /* unless there is no real power management in DVB - we leave the device on GPIO6 */
710
711 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
712 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(50);
713
714 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10);
715 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
716
717 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
718 dib0700_ctrl_clock(adap->dev, 72, 1);
719 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
720
721 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
722
723 st->mt2060_if1[0] = 1220;
724
725 if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap)) {
726 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
727 st->is_dib7000pc = 1;
728 } else {
729 memset(&state->dib7000p_ops, 0, sizeof(state->dib7000p_ops));
730 adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
731 }
732
733 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
734 }
735
736 static struct mt2060_config stk7700p_mt2060_config = {
737 0x60
738 };
739
740 static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
741 {
742 struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
743 struct dib0700_state *st = adap->dev->priv;
744 struct i2c_adapter *tun_i2c;
745 struct dib0700_adapter_state *state = adap->priv;
746 s8 a;
747 int if1=1220;
748
749 if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
750 adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
751 if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
752 }
753 if (st->is_dib7000pc)
754 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
755 else
756 tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
757
758 return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config,
759 if1) == NULL ? -ENODEV : 0;
760 }
761
762 /* DIB7070 generic */
763 static struct dibx000_agc_config dib7070_agc_config = {
764 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
765 /* 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,
766 * 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 */
767 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
768 .inv_gain = 600,
769 .time_stabiliz = 10,
770 .alpha_level = 0,
771 .thlock = 118,
772 .wbd_inv = 0,
773 .wbd_ref = 3530,
774 .wbd_sel = 1,
775 .wbd_alpha = 5,
776 .agc1_max = 65535,
777 .agc1_min = 0,
778 .agc2_max = 65535,
779 .agc2_min = 0,
780 .agc1_pt1 = 0,
781 .agc1_pt2 = 40,
782 .agc1_pt3 = 183,
783 .agc1_slope1 = 206,
784 .agc1_slope2 = 255,
785 .agc2_pt1 = 72,
786 .agc2_pt2 = 152,
787 .agc2_slope1 = 88,
788 .agc2_slope2 = 90,
789 .alpha_mant = 17,
790 .alpha_exp = 27,
791 .beta_mant = 23,
792 .beta_exp = 51,
793 .perform_agc_softsplit = 0,
794 };
795
796 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
797 {
798 struct dvb_usb_adapter *adap = fe->dvb->priv;
799 struct dib0700_adapter_state *state = adap->priv;
800
801 deb_info("reset: %d", onoff);
802 return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
803 }
804
805 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
806 {
807 struct dvb_usb_adapter *adap = fe->dvb->priv;
808 struct dib0700_adapter_state *state = adap->priv;
809
810 deb_info("sleep: %d", onoff);
811 return state->dib7000p_ops.set_gpio(fe, 9, 0, onoff);
812 }
813
814 static struct dib0070_config dib7070p_dib0070_config[2] = {
815 {
816 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
817 .reset = dib7070_tuner_reset,
818 .sleep = dib7070_tuner_sleep,
819 .clock_khz = 12000,
820 .clock_pad_drive = 4,
821 .charge_pump = 2,
822 }, {
823 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
824 .reset = dib7070_tuner_reset,
825 .sleep = dib7070_tuner_sleep,
826 .clock_khz = 12000,
827 .charge_pump = 2,
828 }
829 };
830
831 static struct dib0070_config dib7770p_dib0070_config = {
832 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
833 .reset = dib7070_tuner_reset,
834 .sleep = dib7070_tuner_sleep,
835 .clock_khz = 12000,
836 .clock_pad_drive = 0,
837 .flip_chip = 1,
838 .charge_pump = 2,
839 };
840
841 static int dib7070_set_param_override(struct dvb_frontend *fe)
842 {
843 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
844 struct dvb_usb_adapter *adap = fe->dvb->priv;
845 struct dib0700_adapter_state *state = adap->priv;
846
847 u16 offset;
848 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
849 switch (band) {
850 case BAND_VHF: offset = 950; break;
851 case BAND_UHF:
852 default: offset = 550; break;
853 }
854 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
855 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
856 return state->set_param_save(fe);
857 }
858
859 static int dib7770_set_param_override(struct dvb_frontend *fe)
860 {
861 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
862 struct dvb_usb_adapter *adap = fe->dvb->priv;
863 struct dib0700_adapter_state *state = adap->priv;
864
865 u16 offset;
866 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
867 switch (band) {
868 case BAND_VHF:
869 state->dib7000p_ops.set_gpio(fe, 0, 0, 1);
870 offset = 850;
871 break;
872 case BAND_UHF:
873 default:
874 state->dib7000p_ops.set_gpio(fe, 0, 0, 0);
875 offset = 250;
876 break;
877 }
878 deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
879 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
880 return state->set_param_save(fe);
881 }
882
883 static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
884 {
885 struct dib0700_adapter_state *st = adap->priv;
886 struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
887 DIBX000_I2C_INTERFACE_TUNER, 1);
888
889 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
890 &dib7770p_dib0070_config) == NULL)
891 return -ENODEV;
892
893 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
894 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
895 return 0;
896 }
897
898 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
899 {
900 struct dib0700_adapter_state *st = adap->priv;
901 struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
902
903 if (adap->id == 0) {
904 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
905 return -ENODEV;
906 } else {
907 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
908 return -ENODEV;
909 }
910
911 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
912 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
913 return 0;
914 }
915
916 static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
917 u16 pid, int onoff)
918 {
919 struct dib0700_adapter_state *state = adapter->priv;
920 struct dib0700_state *st = adapter->dev->priv;
921
922 if (st->is_dib7000pc)
923 return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
924 return dib7000m_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
925 }
926
927 static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
928 {
929 struct dib0700_state *st = adapter->dev->priv;
930 struct dib0700_adapter_state *state = adapter->priv;
931 if (st->is_dib7000pc)
932 return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
933 return dib7000m_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
934 }
935
936 static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
937 {
938 struct dib0700_adapter_state *state = adapter->priv;
939 return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
940 }
941
942 static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
943 {
944 struct dib0700_adapter_state *state = adapter->priv;
945 return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
946 }
947
948 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
949 .internal = 60000,
950 .sampling = 15000,
951 .pll_prediv = 1,
952 .pll_ratio = 20,
953 .pll_range = 3,
954 .pll_reset = 1,
955 .pll_bypass = 0,
956 .enable_refdiv = 0,
957 .bypclk_div = 0,
958 .IO_CLK_en_core = 1,
959 .ADClkSrc = 1,
960 .modulo = 2,
961 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
962 .ifreq = (0 << 25) | 0,
963 .timf = 20452225,
964 .xtal_hz = 12000000,
965 };
966
967 static struct dib7000p_config dib7070p_dib7000p_config = {
968 .output_mpeg2_in_188_bytes = 1,
969
970 .agc_config_count = 1,
971 .agc = &dib7070_agc_config,
972 .bw = &dib7070_bw_config_12_mhz,
973 .tuner_is_baseband = 1,
974 .spur_protect = 1,
975
976 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
977 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
978 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
979
980 .hostbus_diversity = 1,
981 };
982
983 /* STK7070P */
984 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
985 {
986 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
987 struct dib0700_adapter_state *state = adap->priv;
988
989 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
990 return -ENODEV;
991
992 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
993 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
994 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
995 else
996 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
997 msleep(10);
998 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
999 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1000 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1001 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1002
1003 dib0700_ctrl_clock(adap->dev, 72, 1);
1004
1005 msleep(10);
1006 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1007 msleep(10);
1008 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1009
1010 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1011 &dib7070p_dib7000p_config) != 0) {
1012 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
1013 __func__);
1014 dvb_detach(state->dib7000p_ops.set_wbd_ref);
1015 return -ENODEV;
1016 }
1017
1018 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1019 &dib7070p_dib7000p_config);
1020 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1021 }
1022
1023 /* STK7770P */
1024 static struct dib7000p_config dib7770p_dib7000p_config = {
1025 .output_mpeg2_in_188_bytes = 1,
1026
1027 .agc_config_count = 1,
1028 .agc = &dib7070_agc_config,
1029 .bw = &dib7070_bw_config_12_mhz,
1030 .tuner_is_baseband = 1,
1031 .spur_protect = 1,
1032
1033 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1034 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1035 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1036
1037 .hostbus_diversity = 1,
1038 .enable_current_mirror = 1,
1039 .disable_sample_and_hold = 0,
1040 };
1041
1042 static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
1043 {
1044 struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
1045 struct dib0700_adapter_state *state = adap->priv;
1046
1047 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1048 return -ENODEV;
1049
1050 if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
1051 p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
1052 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1053 else
1054 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1055 msleep(10);
1056 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1057 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1058 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1059 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1060
1061 dib0700_ctrl_clock(adap->dev, 72, 1);
1062
1063 msleep(10);
1064 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1065 msleep(10);
1066 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1067
1068 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1069 &dib7770p_dib7000p_config) != 0) {
1070 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
1071 __func__);
1072 dvb_detach(state->dib7000p_ops.set_wbd_ref);
1073 return -ENODEV;
1074 }
1075
1076 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1077 &dib7770p_dib7000p_config);
1078 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1079 }
1080
1081 /* DIB807x generic */
1082 static struct dibx000_agc_config dib807x_agc_config[2] = {
1083 {
1084 BAND_VHF,
1085 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1086 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1087 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1088 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1089 * P_agc_write=0 */
1090 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1091 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1092 (0 << 0), /* setup*/
1093
1094 600, /* inv_gain*/
1095 10, /* time_stabiliz*/
1096
1097 0, /* alpha_level*/
1098 118, /* thlock*/
1099
1100 0, /* wbd_inv*/
1101 3530, /* wbd_ref*/
1102 1, /* wbd_sel*/
1103 5, /* wbd_alpha*/
1104
1105 65535, /* agc1_max*/
1106 0, /* agc1_min*/
1107
1108 65535, /* agc2_max*/
1109 0, /* agc2_min*/
1110
1111 0, /* agc1_pt1*/
1112 40, /* agc1_pt2*/
1113 183, /* agc1_pt3*/
1114 206, /* agc1_slope1*/
1115 255, /* agc1_slope2*/
1116 72, /* agc2_pt1*/
1117 152, /* agc2_pt2*/
1118 88, /* agc2_slope1*/
1119 90, /* agc2_slope2*/
1120
1121 17, /* alpha_mant*/
1122 27, /* alpha_exp*/
1123 23, /* beta_mant*/
1124 51, /* beta_exp*/
1125
1126 0, /* perform_agc_softsplit*/
1127 }, {
1128 BAND_UHF,
1129 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1130 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1131 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1132 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1133 * P_agc_write=0 */
1134 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1135 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1136 (0 << 0), /* setup */
1137
1138 600, /* inv_gain*/
1139 10, /* time_stabiliz*/
1140
1141 0, /* alpha_level*/
1142 118, /* thlock*/
1143
1144 0, /* wbd_inv*/
1145 3530, /* wbd_ref*/
1146 1, /* wbd_sel*/
1147 5, /* wbd_alpha*/
1148
1149 65535, /* agc1_max*/
1150 0, /* agc1_min*/
1151
1152 65535, /* agc2_max*/
1153 0, /* agc2_min*/
1154
1155 0, /* agc1_pt1*/
1156 40, /* agc1_pt2*/
1157 183, /* agc1_pt3*/
1158 206, /* agc1_slope1*/
1159 255, /* agc1_slope2*/
1160 72, /* agc2_pt1*/
1161 152, /* agc2_pt2*/
1162 88, /* agc2_slope1*/
1163 90, /* agc2_slope2*/
1164
1165 17, /* alpha_mant*/
1166 27, /* alpha_exp*/
1167 23, /* beta_mant*/
1168 51, /* beta_exp*/
1169
1170 0, /* perform_agc_softsplit*/
1171 }
1172 };
1173
1174 static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1175 .internal = 60000,
1176 .sampling = 15000,
1177 .pll_prediv = 1,
1178 .pll_ratio = 20,
1179 .pll_range = 3,
1180 .pll_reset = 1,
1181 .pll_bypass = 0,
1182 .enable_refdiv = 0,
1183 .bypclk_div = 0,
1184 .IO_CLK_en_core = 1,
1185 .ADClkSrc = 1,
1186 .modulo = 2,
1187 .sad_cfg = (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1188 .ifreq = (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1189 .timf = 18179755,
1190 .xtal_hz = 12000000,
1191 };
1192
1193 static struct dib8000_config dib807x_dib8000_config[2] = {
1194 {
1195 .output_mpeg2_in_188_bytes = 1,
1196
1197 .agc_config_count = 2,
1198 .agc = dib807x_agc_config,
1199 .pll = &dib807x_bw_config_12_mhz,
1200 .tuner_is_baseband = 1,
1201
1202 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1203 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1204 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1205
1206 .hostbus_diversity = 1,
1207 .div_cfg = 1,
1208 .agc_control = &dib0070_ctrl_agc_filter,
1209 .output_mode = OUTMODE_MPEG2_FIFO,
1210 .drives = 0x2d98,
1211 }, {
1212 .output_mpeg2_in_188_bytes = 1,
1213
1214 .agc_config_count = 2,
1215 .agc = dib807x_agc_config,
1216 .pll = &dib807x_bw_config_12_mhz,
1217 .tuner_is_baseband = 1,
1218
1219 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1220 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1221 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1222
1223 .hostbus_diversity = 1,
1224 .agc_control = &dib0070_ctrl_agc_filter,
1225 .output_mode = OUTMODE_MPEG2_FIFO,
1226 .drives = 0x2d98,
1227 }
1228 };
1229
1230 static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1231 {
1232 struct dvb_usb_adapter *adap = fe->dvb->priv;
1233 struct dib0700_adapter_state *state = adap->priv;
1234
1235 return state->dib8000_ops.set_gpio(fe, 5, 0, !onoff);
1236 }
1237
1238 static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1239 {
1240 struct dvb_usb_adapter *adap = fe->dvb->priv;
1241 struct dib0700_adapter_state *state = adap->priv;
1242
1243 return state->dib8000_ops.set_gpio(fe, 0, 0, onoff);
1244 }
1245
1246 static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1247 { 240, 7},
1248 { 0xffff, 6},
1249 };
1250
1251 static struct dib0070_config dib807x_dib0070_config[2] = {
1252 {
1253 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1254 .reset = dib80xx_tuner_reset,
1255 .sleep = dib80xx_tuner_sleep,
1256 .clock_khz = 12000,
1257 .clock_pad_drive = 4,
1258 .vga_filter = 1,
1259 .force_crystal_mode = 1,
1260 .enable_third_order_filter = 1,
1261 .charge_pump = 0,
1262 .wbd_gain = dib8070_wbd_gain_cfg,
1263 .osc_buffer_state = 0,
1264 .freq_offset_khz_uhf = -100,
1265 .freq_offset_khz_vhf = -100,
1266 }, {
1267 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1268 .reset = dib80xx_tuner_reset,
1269 .sleep = dib80xx_tuner_sleep,
1270 .clock_khz = 12000,
1271 .clock_pad_drive = 2,
1272 .vga_filter = 1,
1273 .force_crystal_mode = 1,
1274 .enable_third_order_filter = 1,
1275 .charge_pump = 0,
1276 .wbd_gain = dib8070_wbd_gain_cfg,
1277 .osc_buffer_state = 0,
1278 .freq_offset_khz_uhf = -25,
1279 .freq_offset_khz_vhf = -25,
1280 }
1281 };
1282
1283 static int dib807x_set_param_override(struct dvb_frontend *fe)
1284 {
1285 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1286 struct dvb_usb_adapter *adap = fe->dvb->priv;
1287 struct dib0700_adapter_state *state = adap->priv;
1288
1289 u16 offset = dib0070_wbd_offset(fe);
1290 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1291 switch (band) {
1292 case BAND_VHF:
1293 offset += 750;
1294 break;
1295 case BAND_UHF: /* fall-thru wanted */
1296 default:
1297 offset += 250; break;
1298 }
1299 deb_info("WBD for DiB8000: %d\n", offset);
1300 state->dib8000_ops.set_wbd_ref(fe, offset);
1301
1302 return state->set_param_save(fe);
1303 }
1304
1305 static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1306 {
1307 struct dib0700_adapter_state *st = adap->priv;
1308 struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe,
1309 DIBX000_I2C_INTERFACE_TUNER, 1);
1310
1311 if (adap->id == 0) {
1312 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1313 &dib807x_dib0070_config[0]) == NULL)
1314 return -ENODEV;
1315 } else {
1316 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1317 &dib807x_dib0070_config[1]) == NULL)
1318 return -ENODEV;
1319 }
1320
1321 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1322 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1323 return 0;
1324 }
1325
1326 static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1327 u16 pid, int onoff)
1328 {
1329 struct dib0700_adapter_state *state = adapter->priv;
1330
1331 return state->dib8000_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1332 }
1333
1334 static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1335 int onoff)
1336 {
1337 struct dib0700_adapter_state *state = adapter->priv;
1338
1339 return state->dib8000_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1340 }
1341
1342 /* STK807x */
1343 static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1344 {
1345 struct dib0700_adapter_state *state = adap->priv;
1346
1347 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1348 return -ENODEV;
1349
1350 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1351 msleep(10);
1352 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1353 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1354 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1355
1356 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1357
1358 dib0700_ctrl_clock(adap->dev, 72, 1);
1359
1360 msleep(10);
1361 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1362 msleep(10);
1363 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1364
1365 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1366 0x80, 0);
1367
1368 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
1369 &dib807x_dib8000_config[0]);
1370
1371 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1372 }
1373
1374 /* STK807xPVR */
1375 static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1376 {
1377 struct dib0700_adapter_state *state = adap->priv;
1378
1379 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1380 return -ENODEV;
1381
1382 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1383 msleep(30);
1384 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1385 msleep(500);
1386 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1387 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1388 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1389
1390 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1391
1392 dib0700_ctrl_clock(adap->dev, 72, 1);
1393
1394 msleep(10);
1395 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1396 msleep(10);
1397 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1398
1399 /* initialize IC 0 */
1400 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0);
1401
1402 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
1403 &dib807x_dib8000_config[0]);
1404
1405 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1406 }
1407
1408 static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1409 {
1410 struct dib0700_adapter_state *state = adap->priv;
1411
1412 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1413 return -ENODEV;
1414
1415 /* initialize IC 1 */
1416 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0);
1417
1418 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82,
1419 &dib807x_dib8000_config[1]);
1420
1421 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1422 }
1423
1424 /* STK8096GP */
1425 static struct dibx000_agc_config dib8090_agc_config[2] = {
1426 {
1427 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1428 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1429 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1430 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1431 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1432 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1433
1434 .inv_gain = 787,
1435 .time_stabiliz = 10,
1436
1437 .alpha_level = 0,
1438 .thlock = 118,
1439
1440 .wbd_inv = 0,
1441 .wbd_ref = 3530,
1442 .wbd_sel = 1,
1443 .wbd_alpha = 5,
1444
1445 .agc1_max = 65535,
1446 .agc1_min = 0,
1447
1448 .agc2_max = 65535,
1449 .agc2_min = 0,
1450
1451 .agc1_pt1 = 0,
1452 .agc1_pt2 = 32,
1453 .agc1_pt3 = 114,
1454 .agc1_slope1 = 143,
1455 .agc1_slope2 = 144,
1456 .agc2_pt1 = 114,
1457 .agc2_pt2 = 227,
1458 .agc2_slope1 = 116,
1459 .agc2_slope2 = 117,
1460
1461 .alpha_mant = 28,
1462 .alpha_exp = 26,
1463 .beta_mant = 31,
1464 .beta_exp = 51,
1465
1466 .perform_agc_softsplit = 0,
1467 },
1468 {
1469 .band_caps = BAND_CBAND,
1470 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1471 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1472 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1473 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1474 | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1475
1476 .inv_gain = 787,
1477 .time_stabiliz = 10,
1478
1479 .alpha_level = 0,
1480 .thlock = 118,
1481
1482 .wbd_inv = 0,
1483 .wbd_ref = 3530,
1484 .wbd_sel = 1,
1485 .wbd_alpha = 5,
1486
1487 .agc1_max = 0,
1488 .agc1_min = 0,
1489
1490 .agc2_max = 65535,
1491 .agc2_min = 0,
1492
1493 .agc1_pt1 = 0,
1494 .agc1_pt2 = 32,
1495 .agc1_pt3 = 114,
1496 .agc1_slope1 = 143,
1497 .agc1_slope2 = 144,
1498 .agc2_pt1 = 114,
1499 .agc2_pt2 = 227,
1500 .agc2_slope1 = 116,
1501 .agc2_slope2 = 117,
1502
1503 .alpha_mant = 28,
1504 .alpha_exp = 26,
1505 .beta_mant = 31,
1506 .beta_exp = 51,
1507
1508 .perform_agc_softsplit = 0,
1509 }
1510 };
1511
1512 static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1513 .internal = 54000,
1514 .sampling = 13500,
1515
1516 .pll_prediv = 1,
1517 .pll_ratio = 18,
1518 .pll_range = 3,
1519 .pll_reset = 1,
1520 .pll_bypass = 0,
1521
1522 .enable_refdiv = 0,
1523 .bypclk_div = 0,
1524 .IO_CLK_en_core = 1,
1525 .ADClkSrc = 1,
1526 .modulo = 2,
1527
1528 .sad_cfg = (3 << 14) | (1 << 12) | (599 << 0),
1529
1530 .ifreq = (0 << 25) | 0,
1531 .timf = 20199727,
1532
1533 .xtal_hz = 12000000,
1534 };
1535
1536 static int dib8090_get_adc_power(struct dvb_frontend *fe)
1537 {
1538 struct dvb_usb_adapter *adap = fe->dvb->priv;
1539 struct dib0700_adapter_state *state = adap->priv;
1540
1541 return state->dib8000_ops.get_adc_power(fe, 1);
1542 }
1543
1544 static void dib8090_agc_control(struct dvb_frontend *fe, u8 restart)
1545 {
1546 deb_info("AGC control callback: %i\n", restart);
1547 dib0090_dcc_freq(fe, restart);
1548
1549 if (restart == 0) /* before AGC startup */
1550 dib0090_set_dc_servo(fe, 1);
1551 }
1552
1553 static struct dib8000_config dib809x_dib8000_config[2] = {
1554 {
1555 .output_mpeg2_in_188_bytes = 1,
1556
1557 .agc_config_count = 2,
1558 .agc = dib8090_agc_config,
1559 .agc_control = dib8090_agc_control,
1560 .pll = &dib8090_pll_config_12mhz,
1561 .tuner_is_baseband = 1,
1562
1563 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1564 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1565 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1566
1567 .hostbus_diversity = 1,
1568 .div_cfg = 0x31,
1569 .output_mode = OUTMODE_MPEG2_FIFO,
1570 .drives = 0x2d98,
1571 .diversity_delay = 48,
1572 .refclksel = 3,
1573 }, {
1574 .output_mpeg2_in_188_bytes = 1,
1575
1576 .agc_config_count = 2,
1577 .agc = dib8090_agc_config,
1578 .agc_control = dib8090_agc_control,
1579 .pll = &dib8090_pll_config_12mhz,
1580 .tuner_is_baseband = 1,
1581
1582 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1583 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1584 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1585
1586 .hostbus_diversity = 1,
1587 .div_cfg = 0x31,
1588 .output_mode = OUTMODE_DIVERSITY,
1589 .drives = 0x2d08,
1590 .diversity_delay = 1,
1591 .refclksel = 3,
1592 }
1593 };
1594
1595 static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1596 /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1597 { 120, 0, 500, 0, 500, 4 }, /* CBAND */
1598 { 170, 0, 450, 0, 450, 4 }, /* CBAND */
1599 { 380, 48, 373, 28, 259, 6 }, /* VHF */
1600 { 860, 34, 700, 36, 616, 6 }, /* high UHF */
1601 { 0xFFFF, 34, 700, 36, 616, 6 }, /* default */
1602 };
1603
1604 static struct dib0090_config dib809x_dib0090_config = {
1605 .io.pll_bypass = 1,
1606 .io.pll_range = 1,
1607 .io.pll_prediv = 1,
1608 .io.pll_loopdiv = 20,
1609 .io.adc_clock_ratio = 8,
1610 .io.pll_int_loop_filt = 0,
1611 .io.clock_khz = 12000,
1612 .reset = dib80xx_tuner_reset,
1613 .sleep = dib80xx_tuner_sleep,
1614 .clkouttobamse = 1,
1615 .analog_output = 1,
1616 .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1617 .use_pwm_agc = 1,
1618 .clkoutdrive = 1,
1619 .get_adc_power = dib8090_get_adc_power,
1620 .freq_offset_khz_uhf = -63,
1621 .freq_offset_khz_vhf = -143,
1622 .wbd = dib8090_wbd_table,
1623 .fref_clock_ratio = 6,
1624 };
1625
1626 static u8 dib8090_compute_pll_parameters(struct dvb_frontend *fe)
1627 {
1628 u8 optimal_pll_ratio = 20;
1629 u32 freq_adc, ratio, rest, max = 0;
1630 u8 pll_ratio;
1631
1632 for (pll_ratio = 17; pll_ratio <= 20; pll_ratio++) {
1633 freq_adc = 12 * pll_ratio * (1 << 8) / 16;
1634 ratio = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) / freq_adc;
1635 rest = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) - ratio * freq_adc;
1636
1637 if (rest > freq_adc / 2)
1638 rest = freq_adc - rest;
1639 deb_info("PLL ratio=%i rest=%i\n", pll_ratio, rest);
1640 if ((rest > max) && (rest > 717)) {
1641 optimal_pll_ratio = pll_ratio;
1642 max = rest;
1643 }
1644 }
1645 deb_info("optimal PLL ratio=%i\n", optimal_pll_ratio);
1646
1647 return optimal_pll_ratio;
1648 }
1649
1650 static int dib8096_set_param_override(struct dvb_frontend *fe)
1651 {
1652 struct dvb_usb_adapter *adap = fe->dvb->priv;
1653 struct dib0700_adapter_state *state = adap->priv;
1654 u8 pll_ratio, band = BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000);
1655 u16 target, ltgain, rf_gain_limit;
1656 u32 timf;
1657 int ret = 0;
1658 enum frontend_tune_state tune_state = CT_SHUTDOWN;
1659
1660 switch (band) {
1661 default:
1662 deb_info("Warning : Rf frequency (%iHz) is not in the supported range, using VHF switch ", fe->dtv_property_cache.frequency);
1663 fallthrough;
1664 case BAND_VHF:
1665 state->dib8000_ops.set_gpio(fe, 3, 0, 1);
1666 break;
1667 case BAND_UHF:
1668 state->dib8000_ops.set_gpio(fe, 3, 0, 0);
1669 break;
1670 }
1671
1672 ret = state->set_param_save(fe);
1673 if (ret < 0)
1674 return ret;
1675
1676 if (fe->dtv_property_cache.bandwidth_hz != 6000000) {
1677 deb_info("only 6MHz bandwidth is supported\n");
1678 return -EINVAL;
1679 }
1680
1681 /* Update PLL if needed ratio */
1682 state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
1683
1684 /* Get optimize PLL ratio to remove spurious */
1685 pll_ratio = dib8090_compute_pll_parameters(fe);
1686 if (pll_ratio == 17)
1687 timf = 21387946;
1688 else if (pll_ratio == 18)
1689 timf = 20199727;
1690 else if (pll_ratio == 19)
1691 timf = 19136583;
1692 else
1693 timf = 18179756;
1694
1695 /* Update ratio */
1696 state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio);
1697
1698 state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, timf);
1699
1700 if (band != BAND_CBAND) {
1701 /* dib0090_get_wbd_target is returning any possible temperature compensated wbd-target */
1702 target = (dib0090_get_wbd_target(fe) * 8 * 18 / 33 + 1) / 2;
1703 state->dib8000_ops.set_wbd_ref(fe, target);
1704 }
1705
1706 if (band == BAND_CBAND) {
1707 deb_info("tuning in CBAND - soft-AGC startup\n");
1708 dib0090_set_tune_state(fe, CT_AGC_START);
1709
1710 do {
1711 ret = dib0090_gain_control(fe);
1712 msleep(ret);
1713 tune_state = dib0090_get_tune_state(fe);
1714 if (tune_state == CT_AGC_STEP_0)
1715 state->dib8000_ops.set_gpio(fe, 6, 0, 1);
1716 else if (tune_state == CT_AGC_STEP_1) {
1717 dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
1718 if (rf_gain_limit < 2000) /* activate the external attenuator in case of very high input power */
1719 state->dib8000_ops.set_gpio(fe, 6, 0, 0);
1720 }
1721 } while (tune_state < CT_AGC_STOP);
1722
1723 deb_info("switching to PWM AGC\n");
1724 dib0090_pwm_gain_reset(fe);
1725 state->dib8000_ops.pwm_agc_reset(fe);
1726 state->dib8000_ops.set_tune_state(fe, CT_DEMOD_START);
1727 } else {
1728 /* for everything else than CBAND we are using standard AGC */
1729 deb_info("not tuning in CBAND - standard AGC startup\n");
1730 dib0090_pwm_gain_reset(fe);
1731 }
1732
1733 return 0;
1734 }
1735
1736 static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1737 {
1738 struct dib0700_adapter_state *st = adap->priv;
1739 struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1740
1741 /* FIXME: if adap->id != 0, check if it is fe_adap[1] */
1742 if (!dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config))
1743 return -ENODEV;
1744
1745 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1746 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1747 return 0;
1748 }
1749
1750 static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1751 {
1752 struct dib0700_adapter_state *state = adap->priv;
1753
1754 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1755 return -ENODEV;
1756
1757 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1758 msleep(10);
1759 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1760 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1761 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1762
1763 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1764
1765 dib0700_ctrl_clock(adap->dev, 72, 1);
1766
1767 msleep(10);
1768 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1769 msleep(10);
1770 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1771
1772 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1773
1774 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1775
1776 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1777 }
1778
1779 static int stk809x_frontend1_attach(struct dvb_usb_adapter *adap)
1780 {
1781 struct dib0700_adapter_state *state = adap->priv;
1782
1783 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1784 return -ENODEV;
1785
1786 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x82, 0);
1787
1788 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1789
1790 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1791 }
1792
1793 static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1794 {
1795 struct dib0700_adapter_state *st = adap->priv;
1796 struct i2c_adapter *tun_i2c;
1797 struct dvb_frontend *fe_slave = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1);
1798
1799 if (fe_slave) {
1800 tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1801 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1802 return -ENODEV;
1803 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1804 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1805 }
1806 tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1807 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1808 return -ENODEV;
1809
1810 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1811 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1812
1813 return 0;
1814 }
1815
1816 static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1817 {
1818 struct dvb_frontend *fe_slave;
1819 struct dib0700_adapter_state *state = adap->priv;
1820
1821 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1822 return -ENODEV;
1823
1824 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1825 msleep(20);
1826 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1827 msleep(1000);
1828 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1829 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1830 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1831
1832 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1833
1834 dib0700_ctrl_clock(adap->dev, 72, 1);
1835
1836 msleep(20);
1837 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1838 msleep(20);
1839 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1840
1841 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
1842
1843 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1844 if (adap->fe_adap[0].fe == NULL)
1845 return -ENODEV;
1846
1847 /* Needed to increment refcount */
1848 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1849 return -ENODEV;
1850
1851 fe_slave = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1852 state->dib8000_ops.set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1853
1854 return fe_slave == NULL ? -ENODEV : 0;
1855 }
1856
1857 /* TFE8096P */
1858 static struct dibx000_agc_config dib8096p_agc_config[2] = {
1859 {
1860 .band_caps = BAND_UHF,
1861 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1862 P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1863 P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1864 P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1865 P_agc_write=0 */
1866 .setup = (0 << 15) | (0 << 14) | (5 << 11)
1867 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1868 | (0 << 4) | (5 << 1) | (0 << 0),
1869
1870 .inv_gain = 684,
1871 .time_stabiliz = 10,
1872
1873 .alpha_level = 0,
1874 .thlock = 118,
1875
1876 .wbd_inv = 0,
1877 .wbd_ref = 1200,
1878 .wbd_sel = 3,
1879 .wbd_alpha = 5,
1880
1881 .agc1_max = 65535,
1882 .agc1_min = 0,
1883
1884 .agc2_max = 32767,
1885 .agc2_min = 0,
1886
1887 .agc1_pt1 = 0,
1888 .agc1_pt2 = 0,
1889 .agc1_pt3 = 105,
1890 .agc1_slope1 = 0,
1891 .agc1_slope2 = 156,
1892 .agc2_pt1 = 105,
1893 .agc2_pt2 = 255,
1894 .agc2_slope1 = 54,
1895 .agc2_slope2 = 0,
1896
1897 .alpha_mant = 28,
1898 .alpha_exp = 26,
1899 .beta_mant = 31,
1900 .beta_exp = 51,
1901
1902 .perform_agc_softsplit = 0,
1903 } , {
1904 .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
1905 /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1906 P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1907 P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1908 P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1909 P_agc_write=0 */
1910 .setup = (0 << 15) | (0 << 14) | (5 << 11)
1911 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1912 | (0 << 4) | (5 << 1) | (0 << 0),
1913
1914 .inv_gain = 732,
1915 .time_stabiliz = 10,
1916
1917 .alpha_level = 0,
1918 .thlock = 118,
1919
1920 .wbd_inv = 0,
1921 .wbd_ref = 1200,
1922 .wbd_sel = 3,
1923 .wbd_alpha = 5,
1924
1925 .agc1_max = 65535,
1926 .agc1_min = 0,
1927
1928 .agc2_max = 32767,
1929 .agc2_min = 0,
1930
1931 .agc1_pt1 = 0,
1932 .agc1_pt2 = 0,
1933 .agc1_pt3 = 98,
1934 .agc1_slope1 = 0,
1935 .agc1_slope2 = 167,
1936 .agc2_pt1 = 98,
1937 .agc2_pt2 = 255,
1938 .agc2_slope1 = 52,
1939 .agc2_slope2 = 0,
1940
1941 .alpha_mant = 28,
1942 .alpha_exp = 26,
1943 .beta_mant = 31,
1944 .beta_exp = 51,
1945
1946 .perform_agc_softsplit = 0,
1947 }
1948 };
1949
1950 static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = {
1951 .internal = 108000,
1952 .sampling = 13500,
1953 .pll_prediv = 1,
1954 .pll_ratio = 9,
1955 .pll_range = 1,
1956 .pll_reset = 0,
1957 .pll_bypass = 0,
1958 .enable_refdiv = 0,
1959 .bypclk_div = 0,
1960 .IO_CLK_en_core = 0,
1961 .ADClkSrc = 0,
1962 .modulo = 2,
1963 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1964 .ifreq = (0 << 25) | 0,
1965 .timf = 20199729,
1966 .xtal_hz = 12000000,
1967 };
1968
1969 static struct dib8000_config tfe8096p_dib8000_config = {
1970 .output_mpeg2_in_188_bytes = 1,
1971 .hostbus_diversity = 1,
1972 .update_lna = NULL,
1973
1974 .agc_config_count = 2,
1975 .agc = dib8096p_agc_config,
1976 .pll = &dib8096p_clock_config_12_mhz,
1977
1978 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1979 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1980 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1981
1982 .agc_control = NULL,
1983 .diversity_delay = 48,
1984 .output_mode = OUTMODE_MPEG2_FIFO,
1985 .enMpegOutput = 1,
1986 };
1987
1988 static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
1989 { 380, 81, 850, 64, 540, 4},
1990 { 860, 51, 866, 21, 375, 4},
1991 {1700, 0, 250, 0, 100, 6},
1992 {2600, 0, 250, 0, 100, 6},
1993 { 0xFFFF, 0, 0, 0, 0, 0},
1994 };
1995
1996 static struct dib0090_config tfe8096p_dib0090_config = {
1997 .io.clock_khz = 12000,
1998 .io.pll_bypass = 0,
1999 .io.pll_range = 0,
2000 .io.pll_prediv = 3,
2001 .io.pll_loopdiv = 6,
2002 .io.adc_clock_ratio = 0,
2003 .io.pll_int_loop_filt = 0,
2004
2005 .freq_offset_khz_uhf = -143,
2006 .freq_offset_khz_vhf = -143,
2007
2008 .get_adc_power = dib8090_get_adc_power,
2009
2010 .clkouttobamse = 1,
2011 .analog_output = 0,
2012
2013 .wbd_vhf_offset = 0,
2014 .wbd_cband_offset = 0,
2015 .use_pwm_agc = 1,
2016 .clkoutdrive = 0,
2017
2018 .fref_clock_ratio = 1,
2019
2020 .ls_cfg_pad_drv = 0,
2021 .data_tx_drv = 0,
2022 .low_if = NULL,
2023 .in_soc = 1,
2024 .force_cband_input = 0,
2025 };
2026
2027 struct dibx090p_adc {
2028 u32 freq; /* RF freq MHz */
2029 u32 timf; /* New Timf */
2030 u32 pll_loopdiv; /* New prediv */
2031 u32 pll_prediv; /* New loopdiv */
2032 };
2033
2034 struct dibx090p_best_adc {
2035 u32 timf;
2036 u32 pll_loopdiv;
2037 u32 pll_prediv;
2038 };
2039
2040 static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc)
2041 {
2042 u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2043 u16 xtal = 12000;
2044 u16 fcp_min = 1900; /* PLL, Minimum Frequency of phase comparator (KHz) */
2045 u16 fcp_max = 20000; /* PLL, Maximum Frequency of phase comparator (KHz) */
2046 u32 fmem_max = 140000; /* 140MHz max SDRAM freq */
2047 u32 fdem_min = 66000;
2048 u32 fcp = 0, fs = 0, fdem = 0, fmem = 0;
2049 u32 harmonic_id = 0;
2050
2051 adc->timf = 0;
2052 adc->pll_loopdiv = loopdiv;
2053 adc->pll_prediv = prediv;
2054
2055 deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz);
2056
2057 /* Find Min and Max prediv */
2058 while ((xtal / max_prediv) >= fcp_min)
2059 max_prediv++;
2060
2061 max_prediv--;
2062 min_prediv = max_prediv;
2063 while ((xtal / min_prediv) <= fcp_max) {
2064 min_prediv--;
2065 if (min_prediv == 1)
2066 break;
2067 }
2068 deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2069
2070 min_prediv = 1;
2071
2072 for (prediv = min_prediv; prediv < max_prediv; prediv++) {
2073 fcp = xtal / prediv;
2074 if (fcp > fcp_min && fcp < fcp_max) {
2075 for (loopdiv = 1; loopdiv < 64; loopdiv++) {
2076 fmem = ((xtal/prediv) * loopdiv);
2077 fdem = fmem / 2;
2078 fs = fdem / 4;
2079
2080 /* test min/max system restrictions */
2081 if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) {
2082 spur = 0;
2083 /* test fs harmonics positions */
2084 for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs)); harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) {
2085 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)))) {
2086 spur = 1;
2087 break;
2088 }
2089 }
2090
2091 if (!spur) {
2092 adc->pll_loopdiv = loopdiv;
2093 adc->pll_prediv = prediv;
2094 adc->timf = (4260880253U / fdem) * (1 << 8);
2095 adc->timf += ((4260880253U % fdem) << 8) / fdem;
2096
2097 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);
2098 break;
2099 }
2100 }
2101 }
2102 }
2103 if (!spur)
2104 break;
2105 }
2106
2107 if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2108 return -EINVAL;
2109 return 0;
2110 }
2111
2112 static int dib8096p_agc_startup(struct dvb_frontend *fe)
2113 {
2114 struct dvb_usb_adapter *adap = fe->dvb->priv;
2115 struct dib0700_adapter_state *state = adap->priv;
2116 struct dibx000_bandwidth_config pll;
2117 struct dibx090p_best_adc adc;
2118 u16 target;
2119 int ret;
2120
2121 ret = state->set_param_save(fe);
2122 if (ret < 0)
2123 return ret;
2124 memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2125
2126 dib0090_pwm_gain_reset(fe);
2127 /* dib0090_get_wbd_target is returning any possible
2128 temperature compensated wbd-target */
2129 target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2130 state->dib8000_ops.set_wbd_ref(fe, target);
2131
2132 if (dib8096p_get_best_sampling(fe, &adc) == 0) {
2133 pll.pll_ratio = adc.pll_loopdiv;
2134 pll.pll_prediv = adc.pll_prediv;
2135
2136 dib0700_set_i2c_speed(adap->dev, 200);
2137 state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
2138 state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2139 dib0700_set_i2c_speed(adap->dev, 1000);
2140 }
2141 return 0;
2142 }
2143
2144 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
2145 {
2146 struct dib0700_state *st = adap->dev->priv;
2147 u32 fw_version;
2148 struct dib0700_adapter_state *state = adap->priv;
2149
2150 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
2151 return -ENODEV;
2152
2153 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2154 if (fw_version >= 0x10200)
2155 st->fw_use_new_i2c_api = 1;
2156
2157 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2158 msleep(20);
2159 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2160 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2161 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2162
2163 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2164
2165 dib0700_ctrl_clock(adap->dev, 72, 1);
2166
2167 msleep(20);
2168 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2169 msleep(20);
2170 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2171
2172 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
2173
2174 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap,
2175 0x80, &tfe8096p_dib8000_config);
2176
2177 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2178 }
2179
2180 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
2181 {
2182 struct dib0700_adapter_state *st = adap->priv;
2183 struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe);
2184
2185 tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep;
2186 tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep;
2187 tfe8096p_dib0090_config.wbd = dib8096p_wbd_table;
2188
2189 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
2190 &tfe8096p_dib0090_config) == NULL)
2191 return -ENODEV;
2192
2193 st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2194
2195 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2196 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
2197 return 0;
2198 }
2199
2200 /* STK9090M */
2201 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2202 {
2203 return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
2204 }
2205
2206 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2207 {
2208 return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
2209 }
2210
2211 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2212 {
2213 return dib9000_set_gpio(fe, 5, 0, !onoff);
2214 }
2215
2216 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2217 {
2218 return dib9000_set_gpio(fe, 0, 0, onoff);
2219 }
2220
2221 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
2222 {
2223 u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
2224 u8 rb[2];
2225 struct i2c_msg msg[2] = {
2226 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
2227 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
2228 };
2229 u8 index_data;
2230
2231 dibx000_i2c_set_speed(i2c, 250);
2232
2233 if (i2c_transfer(i2c, msg, 2) != 2)
2234 return -EIO;
2235
2236 switch (rb[0] << 8 | rb[1]) {
2237 case 0:
2238 deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
2239 return -EIO;
2240 case 1:
2241 deb_info("Found DiB0170 rev2");
2242 break;
2243 case 2:
2244 deb_info("Found DiB0190 rev2");
2245 break;
2246 default:
2247 deb_info("DiB01x0 not found");
2248 return -EIO;
2249 }
2250
2251 for (index_data = 0; index_data < len; index_data += 2) {
2252 wb[2] = (data[index_data + 1] >> 8) & 0xff;
2253 wb[3] = (data[index_data + 1]) & 0xff;
2254
2255 if (data[index_data] == 0) {
2256 wb[0] = (data[index_data] >> 8) & 0xff;
2257 wb[1] = (data[index_data]) & 0xff;
2258 msg[0].len = 2;
2259 if (i2c_transfer(i2c, msg, 2) != 2)
2260 return -EIO;
2261 wb[2] |= rb[0];
2262 wb[3] |= rb[1] & ~(3 << 4);
2263 }
2264
2265 wb[0] = (data[index_data] >> 8)&0xff;
2266 wb[1] = (data[index_data])&0xff;
2267 msg[0].len = 4;
2268 if (i2c_transfer(i2c, &msg[0], 1) != 1)
2269 return -EIO;
2270 }
2271 return 0;
2272 }
2273
2274 static struct dib9000_config stk9090m_config = {
2275 .output_mpeg2_in_188_bytes = 1,
2276 .output_mode = OUTMODE_MPEG2_FIFO,
2277 .vcxo_timer = 279620,
2278 .timing_frequency = 20452225,
2279 .demod_clock_khz = 60000,
2280 .xtal_clock_khz = 30000,
2281 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2282 .subband = {
2283 2,
2284 {
2285 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
2286 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
2287 { 0 },
2288 },
2289 },
2290 .gpio_function = {
2291 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2292 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2293 },
2294 };
2295
2296 static struct dib9000_config nim9090md_config[2] = {
2297 {
2298 .output_mpeg2_in_188_bytes = 1,
2299 .output_mode = OUTMODE_MPEG2_FIFO,
2300 .vcxo_timer = 279620,
2301 .timing_frequency = 20452225,
2302 .demod_clock_khz = 60000,
2303 .xtal_clock_khz = 30000,
2304 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2305 }, {
2306 .output_mpeg2_in_188_bytes = 1,
2307 .output_mode = OUTMODE_DIVERSITY,
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 .subband = {
2314 2,
2315 {
2316 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
2317 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
2318 { 0 },
2319 },
2320 },
2321 .gpio_function = {
2322 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2323 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2324 },
2325 }
2326 };
2327
2328 static struct dib0090_config dib9090_dib0090_config = {
2329 .io.pll_bypass = 0,
2330 .io.pll_range = 1,
2331 .io.pll_prediv = 1,
2332 .io.pll_loopdiv = 8,
2333 .io.adc_clock_ratio = 8,
2334 .io.pll_int_loop_filt = 0,
2335 .io.clock_khz = 30000,
2336 .reset = dib90x0_tuner_reset,
2337 .sleep = dib90x0_tuner_sleep,
2338 .clkouttobamse = 0,
2339 .analog_output = 0,
2340 .use_pwm_agc = 0,
2341 .clkoutdrive = 0,
2342 .freq_offset_khz_uhf = 0,
2343 .freq_offset_khz_vhf = 0,
2344 };
2345
2346 static struct dib0090_config nim9090md_dib0090_config[2] = {
2347 {
2348 .io.pll_bypass = 0,
2349 .io.pll_range = 1,
2350 .io.pll_prediv = 1,
2351 .io.pll_loopdiv = 8,
2352 .io.adc_clock_ratio = 8,
2353 .io.pll_int_loop_filt = 0,
2354 .io.clock_khz = 30000,
2355 .reset = dib90x0_tuner_reset,
2356 .sleep = dib90x0_tuner_sleep,
2357 .clkouttobamse = 1,
2358 .analog_output = 0,
2359 .use_pwm_agc = 0,
2360 .clkoutdrive = 0,
2361 .freq_offset_khz_uhf = 0,
2362 .freq_offset_khz_vhf = 0,
2363 }, {
2364 .io.pll_bypass = 0,
2365 .io.pll_range = 1,
2366 .io.pll_prediv = 1,
2367 .io.pll_loopdiv = 8,
2368 .io.adc_clock_ratio = 8,
2369 .io.pll_int_loop_filt = 0,
2370 .io.clock_khz = 30000,
2371 .reset = dib90x0_tuner_reset,
2372 .sleep = dib90x0_tuner_sleep,
2373 .clkouttobamse = 0,
2374 .analog_output = 0,
2375 .use_pwm_agc = 0,
2376 .clkoutdrive = 0,
2377 .freq_offset_khz_uhf = 0,
2378 .freq_offset_khz_vhf = 0,
2379 }
2380 };
2381
2382
2383 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2384 {
2385 struct dib0700_adapter_state *state = adap->priv;
2386 struct dib0700_state *st = adap->dev->priv;
2387 u32 fw_version;
2388
2389 /* Make use of the new i2c functions from FW 1.20 */
2390 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2391 if (fw_version >= 0x10200)
2392 st->fw_use_new_i2c_api = 1;
2393 dib0700_set_i2c_speed(adap->dev, 340);
2394
2395 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2396 msleep(20);
2397 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2398 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2399 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2400 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2401
2402 dib0700_ctrl_clock(adap->dev, 72, 1);
2403
2404 msleep(20);
2405 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2406 msleep(20);
2407 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2408
2409 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2410
2411 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2412 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2413 return -ENODEV;
2414 } else {
2415 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2416 }
2417 stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2418 stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2419
2420 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2421
2422 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2423 }
2424
2425 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2426 {
2427 struct dib0700_adapter_state *state = adap->priv;
2428 struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2429 u16 data_dib190[10] = {
2430 1, 0x1374,
2431 2, 0x01a2,
2432 7, 0x0020,
2433 0, 0x00ef,
2434 8, 0x0486,
2435 };
2436
2437 if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2438 return -ENODEV;
2439 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2440 return -ENODEV;
2441 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2442 if (!i2c)
2443 return -ENODEV;
2444 if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2445 return -ENODEV;
2446 dib0700_set_i2c_speed(adap->dev, 1500);
2447 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2448 return -ENODEV;
2449 release_firmware(state->frontend_firmware);
2450 return 0;
2451 }
2452
2453 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2454 {
2455 struct dib0700_adapter_state *state = adap->priv;
2456 struct dib0700_state *st = adap->dev->priv;
2457 struct i2c_adapter *i2c;
2458 struct dvb_frontend *fe_slave;
2459 u32 fw_version;
2460
2461 /* Make use of the new i2c functions from FW 1.20 */
2462 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2463 if (fw_version >= 0x10200)
2464 st->fw_use_new_i2c_api = 1;
2465 dib0700_set_i2c_speed(adap->dev, 340);
2466
2467 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2468 msleep(20);
2469 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2470 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2471 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2472 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2473
2474 dib0700_ctrl_clock(adap->dev, 72, 1);
2475
2476 msleep(20);
2477 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2478 msleep(20);
2479 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2480
2481 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2482 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2483 return -EIO;
2484 } else {
2485 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2486 }
2487 nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2488 nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2489 nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2490 nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2491
2492 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2493 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2494
2495 if (adap->fe_adap[0].fe == NULL)
2496 return -ENODEV;
2497
2498 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
2499 dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
2500
2501 fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2502 dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
2503
2504 return fe_slave == NULL ? -ENODEV : 0;
2505 }
2506
2507 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2508 {
2509 struct dib0700_adapter_state *state = adap->priv;
2510 struct i2c_adapter *i2c;
2511 struct dvb_frontend *fe_slave;
2512 u16 data_dib190[10] = {
2513 1, 0x5374,
2514 2, 0x01ae,
2515 7, 0x0020,
2516 0, 0x00ef,
2517 8, 0x0406,
2518 };
2519 if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2520 return -ENODEV;
2521 i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2522 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2523 return -ENODEV;
2524 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2525 if (!i2c)
2526 return -ENODEV;
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 strscpy(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_client_device(&d->i2c_adap, &info);
3771 if (!i2c_client_has_driver(client_demod))
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 strscpy(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_client_device(&adap->dev->i2c_adap, &info);
3799 if (!i2c_client_has_driver(client_tuner))
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