1
2
3
4
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
27static int force_lna_activation;
28module_param(force_lna_activation, int, 0644);
29MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifier(s) (LNA), if applicable for the device (default: 0=automatic/off).");
30
31struct 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
39
40static 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
50static 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
72static 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
85static 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
109static 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
119static 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
135
136
137static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
138 {
139 BAND_UHF,
140
141
142
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
182
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
221static 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
239static 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
266static struct mt2266_config stk7700d_mt2266_config[2] = {
267 { .i2c_address = 0x60
268 },
269 { .i2c_address = 0x60
270 }
271};
272
273static 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
306static 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
340static 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
352static struct dibx000_agc_config xc3028_agc_config = {
353 .band_caps = BAND_VHF | BAND_UHF,
354
355
356
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
387static 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),
401 .ifreq = (1 << 25) | 5816102,
402 .timf = 20452225,
403 .xtal_hz = 30000000,
404};
405
406static 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
419static 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
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
443static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
444 .fname = XC2028_DEFAULT_FIRMWARE,
445 .max_len = 64,
446 .demod = XC3028_FE_DIBCOM52,
447};
448
449static struct xc2028_config stk7700ph_xc3028_config = {
450 .i2c_addr = 0x61,
451 .ctrl = &stk7700ph_xc3028_ctrl,
452};
453
454static 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
492static 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
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
513
514
515
516static 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
526
527
528
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
542 if (st->buf[0] == 0 && st->buf[1] == 0
543 && st->buf[2] == 0 && st->buf[3] == 0)
544 return 0;
545
546
547
548 dib0700_rc_setup(d, NULL);
549
550 switch (d->props.rc.core.protocol) {
551 case RC_PROTO_BIT_NEC:
552
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
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
577static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
578 BAND_UHF | BAND_VHF,
579
580
581
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
623static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
624 .band_caps = BAND_UHF | BAND_VHF,
625
626
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
656static 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
675static 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
689static 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
701static 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
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
736static struct mt2060_config stk7700p_mt2060_config = {
737 0x60
738};
739
740static 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
763static struct dibx000_agc_config dib7070_agc_config = {
764 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
765
766
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
796static 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
805static 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
814static 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
831static 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
841static 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
859static 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
883static 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
898static 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
916static 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
927static 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
936static 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
942static 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
948static 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
967static 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
984static 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
1024static 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
1042static 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
1082static struct dibx000_agc_config dib807x_agc_config[2] = {
1083 {
1084 BAND_VHF,
1085
1086
1087
1088
1089
1090 (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1091 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1092 (0 << 0),
1093
1094 600,
1095 10,
1096
1097 0,
1098 118,
1099
1100 0,
1101 3530,
1102 1,
1103 5,
1104
1105 65535,
1106 0,
1107
1108 65535,
1109 0,
1110
1111 0,
1112 40,
1113 183,
1114 206,
1115 255,
1116 72,
1117 152,
1118 88,
1119 90,
1120
1121 17,
1122 27,
1123 23,
1124 51,
1125
1126 0,
1127 }, {
1128 BAND_UHF,
1129
1130
1131
1132
1133
1134 (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1135 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1136 (0 << 0),
1137
1138 600,
1139 10,
1140
1141 0,
1142 118,
1143
1144 0,
1145 3530,
1146 1,
1147 5,
1148
1149 65535,
1150 0,
1151
1152 65535,
1153 0,
1154
1155 0,
1156 40,
1157 183,
1158 206,
1159 255,
1160 72,
1161 152,
1162 88,
1163 90,
1164
1165 17,
1166 27,
1167 23,
1168 51,
1169
1170 0,
1171 }
1172};
1173
1174static 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),
1188 .ifreq = (0 << 25) | 0,
1189 .timf = 18179755,
1190 .xtal_hz = 12000000,
1191};
1192
1193static 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
1230static 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
1238static 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
1246static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1247 { 240, 7},
1248 { 0xffff, 6},
1249};
1250
1251static 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
1283static 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:
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
1305static 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
1326static 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
1334static 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
1343static 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
1375static 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
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
1408static 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
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
1425static struct dibx000_agc_config dib8090_agc_config[2] = {
1426 {
1427 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1428
1429
1430
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
1471
1472
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
1512static 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
1536static 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
1544static 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)
1550 dib0090_set_dc_servo(fe, 1);
1551}
1552
1553static 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
1595static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1596
1597 { 120, 0, 500, 0, 500, 4 },
1598 { 170, 0, 450, 0, 450, 4 },
1599 { 380, 48, 373, 28, 259, 6 },
1600 { 860, 34, 700, 36, 616, 6 },
1601 { 0xFFFF, 34, 700, 36, 616, 6 },
1602};
1603
1604static 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
1626static 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
1650static 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
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
1682 state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
1683
1684
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
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
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, <gain);
1718 if (rf_gain_limit < 2000)
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
1729 deb_info("not tuning in CBAND - standard AGC startup\n");
1730 dib0090_pwm_gain_reset(fe);
1731 }
1732
1733 return 0;
1734}
1735
1736static 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 if (adap->id == 0) {
1742 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1743 return -ENODEV;
1744 } else {
1745
1746 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1747 return -ENODEV;
1748 }
1749
1750 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1751 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1752 return 0;
1753}
1754
1755static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1756{
1757 struct dib0700_adapter_state *state = adap->priv;
1758
1759 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1760 return -ENODEV;
1761
1762 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1763 msleep(10);
1764 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1765 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1766 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1767
1768 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1769
1770 dib0700_ctrl_clock(adap->dev, 72, 1);
1771
1772 msleep(10);
1773 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1774 msleep(10);
1775 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1776
1777 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1778
1779 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1780
1781 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1782}
1783
1784static int stk809x_frontend1_attach(struct dvb_usb_adapter *adap)
1785{
1786 struct dib0700_adapter_state *state = adap->priv;
1787
1788 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1789 return -ENODEV;
1790
1791 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x82, 0);
1792
1793 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1794
1795 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1796}
1797
1798static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1799{
1800 struct dib0700_adapter_state *st = adap->priv;
1801 struct i2c_adapter *tun_i2c;
1802 struct dvb_frontend *fe_slave = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1);
1803
1804 if (fe_slave) {
1805 tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1806 if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1807 return -ENODEV;
1808 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1809 fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1810 }
1811 tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1812 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1813 return -ENODEV;
1814
1815 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1816 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1817
1818 return 0;
1819}
1820
1821static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1822{
1823 struct dvb_frontend *fe_slave;
1824 struct dib0700_adapter_state *state = adap->priv;
1825
1826 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1827 return -ENODEV;
1828
1829 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
1830 msleep(20);
1831 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
1832 msleep(1000);
1833 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
1834 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
1835 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
1836
1837 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
1838
1839 dib0700_ctrl_clock(adap->dev, 72, 1);
1840
1841 msleep(20);
1842 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
1843 msleep(20);
1844 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
1845
1846 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80, 0);
1847
1848 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1849 if (adap->fe_adap[0].fe == NULL)
1850 return -ENODEV;
1851
1852
1853 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1854 return -ENODEV;
1855
1856 fe_slave = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1857 state->dib8000_ops.set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
1858
1859 return fe_slave == NULL ? -ENODEV : 0;
1860}
1861
1862
1863static struct dibx000_agc_config dib8096p_agc_config[2] = {
1864 {
1865 .band_caps = BAND_UHF,
1866
1867
1868
1869
1870
1871 .setup = (0 << 15) | (0 << 14) | (5 << 11)
1872 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1873 | (0 << 4) | (5 << 1) | (0 << 0),
1874
1875 .inv_gain = 684,
1876 .time_stabiliz = 10,
1877
1878 .alpha_level = 0,
1879 .thlock = 118,
1880
1881 .wbd_inv = 0,
1882 .wbd_ref = 1200,
1883 .wbd_sel = 3,
1884 .wbd_alpha = 5,
1885
1886 .agc1_max = 65535,
1887 .agc1_min = 0,
1888
1889 .agc2_max = 32767,
1890 .agc2_min = 0,
1891
1892 .agc1_pt1 = 0,
1893 .agc1_pt2 = 0,
1894 .agc1_pt3 = 105,
1895 .agc1_slope1 = 0,
1896 .agc1_slope2 = 156,
1897 .agc2_pt1 = 105,
1898 .agc2_pt2 = 255,
1899 .agc2_slope1 = 54,
1900 .agc2_slope2 = 0,
1901
1902 .alpha_mant = 28,
1903 .alpha_exp = 26,
1904 .beta_mant = 31,
1905 .beta_exp = 51,
1906
1907 .perform_agc_softsplit = 0,
1908 } , {
1909 .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
1910
1911
1912
1913
1914
1915 .setup = (0 << 15) | (0 << 14) | (5 << 11)
1916 | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5)
1917 | (0 << 4) | (5 << 1) | (0 << 0),
1918
1919 .inv_gain = 732,
1920 .time_stabiliz = 10,
1921
1922 .alpha_level = 0,
1923 .thlock = 118,
1924
1925 .wbd_inv = 0,
1926 .wbd_ref = 1200,
1927 .wbd_sel = 3,
1928 .wbd_alpha = 5,
1929
1930 .agc1_max = 65535,
1931 .agc1_min = 0,
1932
1933 .agc2_max = 32767,
1934 .agc2_min = 0,
1935
1936 .agc1_pt1 = 0,
1937 .agc1_pt2 = 0,
1938 .agc1_pt3 = 98,
1939 .agc1_slope1 = 0,
1940 .agc1_slope2 = 167,
1941 .agc2_pt1 = 98,
1942 .agc2_pt2 = 255,
1943 .agc2_slope1 = 52,
1944 .agc2_slope2 = 0,
1945
1946 .alpha_mant = 28,
1947 .alpha_exp = 26,
1948 .beta_mant = 31,
1949 .beta_exp = 51,
1950
1951 .perform_agc_softsplit = 0,
1952 }
1953};
1954
1955static struct dibx000_bandwidth_config dib8096p_clock_config_12_mhz = {
1956 .internal = 108000,
1957 .sampling = 13500,
1958 .pll_prediv = 1,
1959 .pll_ratio = 9,
1960 .pll_range = 1,
1961 .pll_reset = 0,
1962 .pll_bypass = 0,
1963 .enable_refdiv = 0,
1964 .bypclk_div = 0,
1965 .IO_CLK_en_core = 0,
1966 .ADClkSrc = 0,
1967 .modulo = 2,
1968 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1969 .ifreq = (0 << 25) | 0,
1970 .timf = 20199729,
1971 .xtal_hz = 12000000,
1972};
1973
1974static struct dib8000_config tfe8096p_dib8000_config = {
1975 .output_mpeg2_in_188_bytes = 1,
1976 .hostbus_diversity = 1,
1977 .update_lna = NULL,
1978
1979 .agc_config_count = 2,
1980 .agc = dib8096p_agc_config,
1981 .pll = &dib8096p_clock_config_12_mhz,
1982
1983 .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1984 .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1985 .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1986
1987 .agc_control = NULL,
1988 .diversity_delay = 48,
1989 .output_mode = OUTMODE_MPEG2_FIFO,
1990 .enMpegOutput = 1,
1991};
1992
1993static struct dib0090_wbd_slope dib8096p_wbd_table[] = {
1994 { 380, 81, 850, 64, 540, 4},
1995 { 860, 51, 866, 21, 375, 4},
1996 {1700, 0, 250, 0, 100, 6},
1997 {2600, 0, 250, 0, 100, 6},
1998 { 0xFFFF, 0, 0, 0, 0, 0},
1999};
2000
2001static struct dib0090_config tfe8096p_dib0090_config = {
2002 .io.clock_khz = 12000,
2003 .io.pll_bypass = 0,
2004 .io.pll_range = 0,
2005 .io.pll_prediv = 3,
2006 .io.pll_loopdiv = 6,
2007 .io.adc_clock_ratio = 0,
2008 .io.pll_int_loop_filt = 0,
2009
2010 .freq_offset_khz_uhf = -143,
2011 .freq_offset_khz_vhf = -143,
2012
2013 .get_adc_power = dib8090_get_adc_power,
2014
2015 .clkouttobamse = 1,
2016 .analog_output = 0,
2017
2018 .wbd_vhf_offset = 0,
2019 .wbd_cband_offset = 0,
2020 .use_pwm_agc = 1,
2021 .clkoutdrive = 0,
2022
2023 .fref_clock_ratio = 1,
2024
2025 .ls_cfg_pad_drv = 0,
2026 .data_tx_drv = 0,
2027 .low_if = NULL,
2028 .in_soc = 1,
2029 .force_cband_input = 0,
2030};
2031
2032struct dibx090p_adc {
2033 u32 freq;
2034 u32 timf;
2035 u32 pll_loopdiv;
2036 u32 pll_prediv;
2037};
2038
2039struct dibx090p_best_adc {
2040 u32 timf;
2041 u32 pll_loopdiv;
2042 u32 pll_prediv;
2043};
2044
2045static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc)
2046{
2047 u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2048 u16 xtal = 12000;
2049 u16 fcp_min = 1900;
2050 u16 fcp_max = 20000;
2051 u32 fmem_max = 140000;
2052 u32 fdem_min = 66000;
2053 u32 fcp = 0, fs = 0, fdem = 0, fmem = 0;
2054 u32 harmonic_id = 0;
2055
2056 adc->timf = 0;
2057 adc->pll_loopdiv = loopdiv;
2058 adc->pll_prediv = prediv;
2059
2060 deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz);
2061
2062
2063 while ((xtal / max_prediv) >= fcp_min)
2064 max_prediv++;
2065
2066 max_prediv--;
2067 min_prediv = max_prediv;
2068 while ((xtal / min_prediv) <= fcp_max) {
2069 min_prediv--;
2070 if (min_prediv == 1)
2071 break;
2072 }
2073 deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2074
2075 min_prediv = 1;
2076
2077 for (prediv = min_prediv; prediv < max_prediv; prediv++) {
2078 fcp = xtal / prediv;
2079 if (fcp > fcp_min && fcp < fcp_max) {
2080 for (loopdiv = 1; loopdiv < 64; loopdiv++) {
2081 fmem = ((xtal/prediv) * loopdiv);
2082 fdem = fmem / 2;
2083 fs = fdem / 4;
2084
2085
2086 if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) {
2087 spur = 0;
2088
2089 for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs)); harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) {
2090 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)))) {
2091 spur = 1;
2092 break;
2093 }
2094 }
2095
2096 if (!spur) {
2097 adc->pll_loopdiv = loopdiv;
2098 adc->pll_prediv = prediv;
2099 adc->timf = (4260880253U / fdem) * (1 << 8);
2100 adc->timf += ((4260880253U % fdem) << 8) / fdem;
2101
2102 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);
2103 break;
2104 }
2105 }
2106 }
2107 }
2108 if (!spur)
2109 break;
2110 }
2111
2112 if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2113 return -EINVAL;
2114 return 0;
2115}
2116
2117static int dib8096p_agc_startup(struct dvb_frontend *fe)
2118{
2119 struct dvb_usb_adapter *adap = fe->dvb->priv;
2120 struct dib0700_adapter_state *state = adap->priv;
2121 struct dibx000_bandwidth_config pll;
2122 struct dibx090p_best_adc adc;
2123 u16 target;
2124 int ret;
2125
2126 ret = state->set_param_save(fe);
2127 if (ret < 0)
2128 return ret;
2129 memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2130
2131 dib0090_pwm_gain_reset(fe);
2132
2133
2134 target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2135 state->dib8000_ops.set_wbd_ref(fe, target);
2136
2137 if (dib8096p_get_best_sampling(fe, &adc) == 0) {
2138 pll.pll_ratio = adc.pll_loopdiv;
2139 pll.pll_prediv = adc.pll_prediv;
2140
2141 dib0700_set_i2c_speed(adap->dev, 200);
2142 state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
2143 state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2144 dib0700_set_i2c_speed(adap->dev, 1000);
2145 }
2146 return 0;
2147}
2148
2149static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
2150{
2151 struct dib0700_state *st = adap->dev->priv;
2152 u32 fw_version;
2153 struct dib0700_adapter_state *state = adap->priv;
2154
2155 if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
2156 return -ENODEV;
2157
2158 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2159 if (fw_version >= 0x10200)
2160 st->fw_use_new_i2c_api = 1;
2161
2162 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2163 msleep(20);
2164 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2165 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2166 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2167
2168 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2169
2170 dib0700_ctrl_clock(adap->dev, 72, 1);
2171
2172 msleep(20);
2173 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2174 msleep(20);
2175 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2176
2177 state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
2178
2179 adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap,
2180 0x80, &tfe8096p_dib8000_config);
2181
2182 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2183}
2184
2185static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
2186{
2187 struct dib0700_adapter_state *st = adap->priv;
2188 struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe);
2189
2190 tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep;
2191 tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep;
2192 tfe8096p_dib0090_config.wbd = dib8096p_wbd_table;
2193
2194 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
2195 &tfe8096p_dib0090_config) == NULL)
2196 return -ENODEV;
2197
2198 st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2199
2200 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2201 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
2202 return 0;
2203}
2204
2205
2206static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2207{
2208 return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
2209}
2210
2211static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2212{
2213 return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
2214}
2215
2216static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2217{
2218 return dib9000_set_gpio(fe, 5, 0, !onoff);
2219}
2220
2221static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2222{
2223 return dib9000_set_gpio(fe, 0, 0, onoff);
2224}
2225
2226static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
2227{
2228 u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
2229 u8 rb[2];
2230 struct i2c_msg msg[2] = {
2231 {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
2232 {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
2233 };
2234 u8 index_data;
2235
2236 dibx000_i2c_set_speed(i2c, 250);
2237
2238 if (i2c_transfer(i2c, msg, 2) != 2)
2239 return -EIO;
2240
2241 switch (rb[0] << 8 | rb[1]) {
2242 case 0:
2243 deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
2244 return -EIO;
2245 case 1:
2246 deb_info("Found DiB0170 rev2");
2247 break;
2248 case 2:
2249 deb_info("Found DiB0190 rev2");
2250 break;
2251 default:
2252 deb_info("DiB01x0 not found");
2253 return -EIO;
2254 }
2255
2256 for (index_data = 0; index_data < len; index_data += 2) {
2257 wb[2] = (data[index_data + 1] >> 8) & 0xff;
2258 wb[3] = (data[index_data + 1]) & 0xff;
2259
2260 if (data[index_data] == 0) {
2261 wb[0] = (data[index_data] >> 8) & 0xff;
2262 wb[1] = (data[index_data]) & 0xff;
2263 msg[0].len = 2;
2264 if (i2c_transfer(i2c, msg, 2) != 2)
2265 return -EIO;
2266 wb[2] |= rb[0];
2267 wb[3] |= rb[1] & ~(3 << 4);
2268 }
2269
2270 wb[0] = (data[index_data] >> 8)&0xff;
2271 wb[1] = (data[index_data])&0xff;
2272 msg[0].len = 4;
2273 if (i2c_transfer(i2c, &msg[0], 1) != 1)
2274 return -EIO;
2275 }
2276 return 0;
2277}
2278
2279static struct dib9000_config stk9090m_config = {
2280 .output_mpeg2_in_188_bytes = 1,
2281 .output_mode = OUTMODE_MPEG2_FIFO,
2282 .vcxo_timer = 279620,
2283 .timing_frequency = 20452225,
2284 .demod_clock_khz = 60000,
2285 .xtal_clock_khz = 30000,
2286 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2287 .subband = {
2288 2,
2289 {
2290 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } },
2291 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } },
2292 { 0 },
2293 },
2294 },
2295 .gpio_function = {
2296 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2297 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2298 },
2299};
2300
2301static struct dib9000_config nim9090md_config[2] = {
2302 {
2303 .output_mpeg2_in_188_bytes = 1,
2304 .output_mode = OUTMODE_MPEG2_FIFO,
2305 .vcxo_timer = 279620,
2306 .timing_frequency = 20452225,
2307 .demod_clock_khz = 60000,
2308 .xtal_clock_khz = 30000,
2309 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2310 }, {
2311 .output_mpeg2_in_188_bytes = 1,
2312 .output_mode = OUTMODE_DIVERSITY,
2313 .vcxo_timer = 279620,
2314 .timing_frequency = 20452225,
2315 .demod_clock_khz = 60000,
2316 .xtal_clock_khz = 30000,
2317 .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2318 .subband = {
2319 2,
2320 {
2321 { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } },
2322 { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } },
2323 { 0 },
2324 },
2325 },
2326 .gpio_function = {
2327 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2328 { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2329 },
2330 }
2331};
2332
2333static struct dib0090_config dib9090_dib0090_config = {
2334 .io.pll_bypass = 0,
2335 .io.pll_range = 1,
2336 .io.pll_prediv = 1,
2337 .io.pll_loopdiv = 8,
2338 .io.adc_clock_ratio = 8,
2339 .io.pll_int_loop_filt = 0,
2340 .io.clock_khz = 30000,
2341 .reset = dib90x0_tuner_reset,
2342 .sleep = dib90x0_tuner_sleep,
2343 .clkouttobamse = 0,
2344 .analog_output = 0,
2345 .use_pwm_agc = 0,
2346 .clkoutdrive = 0,
2347 .freq_offset_khz_uhf = 0,
2348 .freq_offset_khz_vhf = 0,
2349};
2350
2351static struct dib0090_config nim9090md_dib0090_config[2] = {
2352 {
2353 .io.pll_bypass = 0,
2354 .io.pll_range = 1,
2355 .io.pll_prediv = 1,
2356 .io.pll_loopdiv = 8,
2357 .io.adc_clock_ratio = 8,
2358 .io.pll_int_loop_filt = 0,
2359 .io.clock_khz = 30000,
2360 .reset = dib90x0_tuner_reset,
2361 .sleep = dib90x0_tuner_sleep,
2362 .clkouttobamse = 1,
2363 .analog_output = 0,
2364 .use_pwm_agc = 0,
2365 .clkoutdrive = 0,
2366 .freq_offset_khz_uhf = 0,
2367 .freq_offset_khz_vhf = 0,
2368 }, {
2369 .io.pll_bypass = 0,
2370 .io.pll_range = 1,
2371 .io.pll_prediv = 1,
2372 .io.pll_loopdiv = 8,
2373 .io.adc_clock_ratio = 8,
2374 .io.pll_int_loop_filt = 0,
2375 .io.clock_khz = 30000,
2376 .reset = dib90x0_tuner_reset,
2377 .sleep = dib90x0_tuner_sleep,
2378 .clkouttobamse = 0,
2379 .analog_output = 0,
2380 .use_pwm_agc = 0,
2381 .clkoutdrive = 0,
2382 .freq_offset_khz_uhf = 0,
2383 .freq_offset_khz_vhf = 0,
2384 }
2385};
2386
2387
2388static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2389{
2390 struct dib0700_adapter_state *state = adap->priv;
2391 struct dib0700_state *st = adap->dev->priv;
2392 u32 fw_version;
2393
2394
2395 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2396 if (fw_version >= 0x10200)
2397 st->fw_use_new_i2c_api = 1;
2398 dib0700_set_i2c_speed(adap->dev, 340);
2399
2400 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2401 msleep(20);
2402 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2403 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2404 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2405 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2406
2407 dib0700_ctrl_clock(adap->dev, 72, 1);
2408
2409 msleep(20);
2410 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2411 msleep(20);
2412 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2413
2414 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2415
2416 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2417 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2418 return -ENODEV;
2419 } else {
2420 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2421 }
2422 stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2423 stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2424
2425 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2426
2427 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
2428}
2429
2430static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2431{
2432 struct dib0700_adapter_state *state = adap->priv;
2433 struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2434 u16 data_dib190[10] = {
2435 1, 0x1374,
2436 2, 0x01a2,
2437 7, 0x0020,
2438 0, 0x00ef,
2439 8, 0x0486,
2440 };
2441
2442 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2443 return -ENODEV;
2444 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2445 if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2446 return -ENODEV;
2447 dib0700_set_i2c_speed(adap->dev, 1500);
2448 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2449 return -ENODEV;
2450 release_firmware(state->frontend_firmware);
2451 return 0;
2452}
2453
2454static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2455{
2456 struct dib0700_adapter_state *state = adap->priv;
2457 struct dib0700_state *st = adap->dev->priv;
2458 struct i2c_adapter *i2c;
2459 struct dvb_frontend *fe_slave;
2460 u32 fw_version;
2461
2462
2463 dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2464 if (fw_version >= 0x10200)
2465 st->fw_use_new_i2c_api = 1;
2466 dib0700_set_i2c_speed(adap->dev, 340);
2467
2468 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2469 msleep(20);
2470 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2471 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2472 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2473 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2474
2475 dib0700_ctrl_clock(adap->dev, 72, 1);
2476
2477 msleep(20);
2478 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2479 msleep(20);
2480 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2481
2482 if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2483 deb_info("%s: Upload failed. (file not found?)\n", __func__);
2484 return -EIO;
2485 } else {
2486 deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2487 }
2488 nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2489 nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2490 nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2491 nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2492
2493 dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2494 adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2495
2496 if (adap->fe_adap[0].fe == NULL)
2497 return -ENODEV;
2498
2499 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
2500 dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
2501
2502 fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2503 dib9000_set_slave_frontend(adap->fe_adap[0].fe, fe_slave);
2504
2505 return fe_slave == NULL ? -ENODEV : 0;
2506}
2507
2508static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2509{
2510 struct dib0700_adapter_state *state = adap->priv;
2511 struct i2c_adapter *i2c;
2512 struct dvb_frontend *fe_slave;
2513 u16 data_dib190[10] = {
2514 1, 0x5374,
2515 2, 0x01ae,
2516 7, 0x0020,
2517 0, 0x00ef,
2518 8, 0x0406,
2519 };
2520 i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2521 if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2522 return -ENODEV;
2523 i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2524 if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
2525 return -ENODEV;
2526
2527 dib0700_set_i2c_speed(adap->dev, 1500);
2528 if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2529 return -ENODEV;
2530
2531 fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
2532 if (fe_slave != NULL) {
2533 i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
2534 dib9000_set_i2c_adapter(fe_slave, i2c);
2535
2536 i2c = dib9000_get_tuner_interface(fe_slave);
2537 if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
2538 return -ENODEV;
2539 fe_slave->dvb = adap->fe_adap[0].fe->dvb;
2540 dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 1500);
2541 if (dib9000_firmware_post_pll_init(fe_slave) < 0)
2542 return -ENODEV;
2543 }
2544 release_firmware(state->frontend_firmware);
2545
2546 return 0;
2547}
2548
2549
2550static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dibx090p_best_adc *adc)
2551{
2552 u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2553
2554 u16 xtal = 12000;
2555 u32 fcp_min = 1900;
2556 u32 fcp_max = 20000;
2557 u32 fdem_max = 76000;
2558 u32 fdem_min = 69500;
2559 u32 fcp = 0, fs = 0, fdem = 0;
2560 u32 harmonic_id = 0;
2561
2562 adc->pll_loopdiv = loopdiv;
2563 adc->pll_prediv = prediv;
2564 adc->timf = 0;
2565
2566 deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2567
2568
2569 while ((xtal/max_prediv) >= fcp_min)
2570 max_prediv++;
2571
2572 max_prediv--;
2573 min_prediv = max_prediv;
2574 while ((xtal/min_prediv) <= fcp_max) {
2575 min_prediv--;
2576 if (min_prediv == 1)
2577 break;
2578 }
2579 deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2580
2581 min_prediv = 2;
2582
2583 for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2584 fcp = xtal / prediv;
2585 if (fcp > fcp_min && fcp < fcp_max) {
2586 for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2587 fdem = ((xtal/prediv) * loopdiv);
2588 fs = fdem / 4;
2589
2590
2591 if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2592 spur = 0;
2593
2594 for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ; harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2595 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)))) {
2596 spur = 1;
2597 break;
2598 }
2599 }
2600
2601 if (!spur) {
2602 adc->pll_loopdiv = loopdiv;
2603 adc->pll_prediv = prediv;
2604 adc->timf = 2396745143UL/fdem*(1 << 9);
2605 adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2606 deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2607 break;
2608 }
2609 }
2610 }
2611 }
2612 if (!spur)
2613 break;
2614 }
2615
2616
2617 if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2618 return -EINVAL;
2619 else
2620 return 0;
2621}
2622
2623static int dib7090_agc_startup(struct dvb_frontend *fe)
2624{
2625 struct dvb_usb_adapter *adap = fe->dvb->priv;
2626 struct dib0700_adapter_state *state = adap->priv;
2627 struct dibx000_bandwidth_config pll;
2628 u16 target;
2629 struct dibx090p_best_adc adc;
2630 int ret;
2631
2632 ret = state->set_param_save(fe);
2633 if (ret < 0)
2634 return ret;
2635
2636 memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2637 dib0090_pwm_gain_reset(fe);
2638 target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2639 state->dib7000p_ops.set_wbd_ref(fe, target);
2640
2641 if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2642 pll.pll_ratio = adc.pll_loopdiv;
2643 pll.pll_prediv = adc.pll_prediv;
2644
2645 state->dib7000p_ops.update_pll(fe, &pll);
2646 state->dib7000p_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2647 }
2648 return 0;
2649}
2650
2651static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
2652{
2653 deb_info("AGC restart callback: %d", restart);
2654 if (restart == 0)
2655 dib0090_set_dc_servo(fe, 1);
2656 return 0;
2657}
2658
2659static int tfe7790p_update_lna(struct dvb_frontend *fe, u16 agc_global)
2660{
2661 struct dvb_usb_adapter *adap = fe->dvb->priv;
2662 struct dib0700_adapter_state *state = adap->priv;
2663
2664 deb_info("update LNA: agc global=%i", agc_global);
2665
2666 if (agc_global < 25000) {
2667 state->dib7000p_ops.set_gpio(fe, 8, 0, 0);
2668 state->dib7000p_ops.set_agc1_min(fe, 0);
2669 } else {
2670 state->dib7000p_ops.set_gpio(fe, 8, 0, 1);
2671 state->dib7000p_ops.set_agc1_min(fe, 32768);
2672 }
2673
2674 return 0;
2675}
2676
2677static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2678 { 380, 81, 850, 64, 540, 4},
2679 { 860, 51, 866, 21, 375, 4},
2680 {1700, 0, 250, 0, 100, 6},
2681 {2600, 0, 250, 0, 100, 6},
2682 { 0xFFFF, 0, 0, 0, 0, 0},
2683};
2684
2685static struct dibx000_agc_config dib7090_agc_config[2] = {
2686 {
2687 .band_caps = BAND_UHF,
2688
2689
2690 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2691
2692 .inv_gain = 687,
2693 .time_stabiliz = 10,
2694
2695 .alpha_level = 0,
2696 .thlock = 118,
2697
2698 .wbd_inv = 0,
2699 .wbd_ref = 1200,
2700 .wbd_sel = 3,
2701 .wbd_alpha = 5,
2702
2703 .agc1_max = 65535,
2704 .agc1_min = 32768,
2705
2706 .agc2_max = 65535,
2707 .agc2_min = 0,
2708
2709 .agc1_pt1 = 0,
2710 .agc1_pt2 = 32,
2711 .agc1_pt3 = 114,
2712 .agc1_slope1 = 143,
2713 .agc1_slope2 = 144,
2714 .agc2_pt1 = 114,
2715 .agc2_pt2 = 227,
2716 .agc2_slope1 = 116,
2717 .agc2_slope2 = 117,
2718
2719 .alpha_mant = 18,
2720 .alpha_exp = 0,
2721 .beta_mant = 20,
2722 .beta_exp = 59,
2723
2724 .perform_agc_softsplit = 0,
2725 } , {
2726 .band_caps = BAND_FM | BAND_VHF | BAND_CBAND,
2727
2728
2729 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2730
2731 .inv_gain = 732,
2732 .time_stabiliz = 10,
2733
2734 .alpha_level = 0,
2735 .thlock = 118,
2736
2737 .wbd_inv = 0,
2738 .wbd_ref = 1200,
2739 .wbd_sel = 3,
2740 .wbd_alpha = 5,
2741
2742 .agc1_max = 65535,
2743 .agc1_min = 0,
2744
2745 .agc2_max = 65535,
2746 .agc2_min = 0,
2747
2748 .agc1_pt1 = 0,
2749 .agc1_pt2 = 0,
2750 .agc1_pt3 = 98,
2751 .agc1_slope1 = 0,
2752 .agc1_slope2 = 167,
2753 .agc2_pt1 = 98,
2754 .agc2_pt2 = 255,
2755 .agc2_slope1 = 104,
2756 .agc2_slope2 = 0,
2757
2758 .alpha_mant = 18,
2759 .alpha_exp = 0,
2760 .beta_mant = 20,
2761 .beta_exp = 59,
2762
2763 .perform_agc_softsplit = 0,
2764 }
2765};
2766
2767static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2768 .internal = 60000,
2769 .sampling = 15000,
2770 .pll_prediv = 1,
2771 .pll_ratio = 5,
2772 .pll_range = 0,
2773 .pll_reset = 0,
2774 .pll_bypass = 0,
2775 .enable_refdiv = 0,
2776 .bypclk_div = 0,
2777 .IO_CLK_en_core = 1,
2778 .ADClkSrc = 1,
2779 .modulo = 2,
2780 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
2781 .ifreq = (0 << 25) | 0,
2782 .timf = 20452225,
2783 .xtal_hz = 15000000,
2784};
2785
2786static struct dib7000p_config nim7090_dib7000p_config = {
2787 .output_mpeg2_in_188_bytes = 1,
2788 .hostbus_diversity = 1,
2789 .tuner_is_baseband = 1,
2790 .update_lna = tfe7790p_update_lna,
2791
2792 .agc_config_count = 2,
2793 .agc = dib7090_agc_config,
2794
2795 .bw = &dib7090_clock_config_12_mhz,
2796
2797 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2798 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2799 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2800
2801 .pwm_freq_div = 0,
2802
2803 .agc_control = dib7090_agc_restart,
2804
2805 .spur_protect = 0,
2806 .disable_sample_and_hold = 0,
2807 .enable_current_mirror = 0,
2808 .diversity_delay = 0,
2809
2810 .output_mode = OUTMODE_MPEG2_FIFO,
2811 .enMpegOutput = 1,
2812};
2813
2814static int tfe7090p_pvr_update_lna(struct dvb_frontend *fe, u16 agc_global)
2815{
2816 struct dvb_usb_adapter *adap = fe->dvb->priv;
2817 struct dib0700_adapter_state *state = adap->priv;
2818
2819 deb_info("TFE7090P-PVR update LNA: agc global=%i", agc_global);
2820 if (agc_global < 25000) {
2821 state->dib7000p_ops.set_gpio(fe, 5, 0, 0);
2822 state->dib7000p_ops.set_agc1_min(fe, 0);
2823 } else {
2824 state->dib7000p_ops.set_gpio(fe, 5, 0, 1);
2825 state->dib7000p_ops.set_agc1_min(fe, 32768);
2826 }
2827
2828 return 0;
2829}
2830
2831static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2832 {
2833 .output_mpeg2_in_188_bytes = 1,
2834 .hostbus_diversity = 1,
2835 .tuner_is_baseband = 1,
2836 .update_lna = tfe7090p_pvr_update_lna,
2837
2838 .agc_config_count = 2,
2839 .agc = dib7090_agc_config,
2840
2841 .bw = &dib7090_clock_config_12_mhz,
2842
2843 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2844 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2845 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2846
2847 .pwm_freq_div = 0,
2848
2849 .agc_control = dib7090_agc_restart,
2850
2851 .spur_protect = 0,
2852 .disable_sample_and_hold = 0,
2853 .enable_current_mirror = 0,
2854 .diversity_delay = 0,
2855
2856 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2857 .default_i2c_addr = 0x90,
2858 .enMpegOutput = 1,
2859 }, {
2860 .output_mpeg2_in_188_bytes = 1,
2861 .hostbus_diversity = 1,
2862 .tuner_is_baseband = 1,
2863 .update_lna = tfe7090p_pvr_update_lna,
2864
2865 .agc_config_count = 2,
2866 .agc = dib7090_agc_config,
2867
2868 .bw = &dib7090_clock_config_12_mhz,
2869
2870 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2871 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2872 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2873
2874 .pwm_freq_div = 0,
2875
2876 .agc_control = dib7090_agc_restart,
2877
2878 .spur_protect = 0,
2879 .disable_sample_and_hold = 0,
2880 .enable_current_mirror = 0,
2881 .diversity_delay = 0,
2882
2883 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2884 .default_i2c_addr = 0x92,
2885 .enMpegOutput = 0,
2886 }
2887};
2888
2889static struct dib0090_config nim7090_dib0090_config = {
2890 .io.clock_khz = 12000,
2891 .io.pll_bypass = 0,
2892 .io.pll_range = 0,
2893 .io.pll_prediv = 3,
2894 .io.pll_loopdiv = 6,
2895 .io.adc_clock_ratio = 0,
2896 .io.pll_int_loop_filt = 0,
2897
2898 .freq_offset_khz_uhf = 0,
2899 .freq_offset_khz_vhf = 0,
2900
2901 .clkouttobamse = 1,
2902 .analog_output = 0,
2903
2904 .wbd_vhf_offset = 0,
2905 .wbd_cband_offset = 0,
2906 .use_pwm_agc = 1,
2907 .clkoutdrive = 0,
2908
2909 .fref_clock_ratio = 0,
2910
2911 .wbd = dib7090_wbd_table,
2912
2913 .ls_cfg_pad_drv = 0,
2914 .data_tx_drv = 0,
2915 .low_if = NULL,
2916 .in_soc = 1,
2917};
2918
2919static struct dib7000p_config tfe7790p_dib7000p_config = {
2920 .output_mpeg2_in_188_bytes = 1,
2921 .hostbus_diversity = 1,
2922 .tuner_is_baseband = 1,
2923 .update_lna = tfe7790p_update_lna,
2924
2925 .agc_config_count = 2,
2926 .agc = dib7090_agc_config,
2927
2928 .bw = &dib7090_clock_config_12_mhz,
2929
2930 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2931 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
2932 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
2933
2934 .pwm_freq_div = 0,
2935
2936 .agc_control = dib7090_agc_restart,
2937
2938 .spur_protect = 0,
2939 .disable_sample_and_hold = 0,
2940 .enable_current_mirror = 0,
2941 .diversity_delay = 0,
2942
2943 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
2944 .enMpegOutput = 1,
2945};
2946
2947static struct dib0090_config tfe7790p_dib0090_config = {
2948 .io.clock_khz = 12000,
2949 .io.pll_bypass = 0,
2950 .io.pll_range = 0,
2951 .io.pll_prediv = 3,
2952 .io.pll_loopdiv = 6,
2953 .io.adc_clock_ratio = 0,
2954 .io.pll_int_loop_filt = 0,
2955
2956 .freq_offset_khz_uhf = 0,
2957 .freq_offset_khz_vhf = 0,
2958
2959 .clkouttobamse = 1,
2960 .analog_output = 0,
2961
2962 .wbd_vhf_offset = 0,
2963 .wbd_cband_offset = 0,
2964 .use_pwm_agc = 1,
2965 .clkoutdrive = 0,
2966
2967 .fref_clock_ratio = 0,
2968
2969 .wbd = dib7090_wbd_table,
2970
2971 .ls_cfg_pad_drv = 0,
2972 .data_tx_drv = 0,
2973 .low_if = NULL,
2974 .in_soc = 1,
2975 .force_cband_input = 0,
2976 .is_dib7090e = 0,
2977 .force_crystal_mode = 1,
2978};
2979
2980static struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2981 {
2982 .io.clock_khz = 12000,
2983 .io.pll_bypass = 0,
2984 .io.pll_range = 0,
2985 .io.pll_prediv = 3,
2986 .io.pll_loopdiv = 6,
2987 .io.adc_clock_ratio = 0,
2988 .io.pll_int_loop_filt = 0,
2989
2990 .freq_offset_khz_uhf = 50,
2991 .freq_offset_khz_vhf = 70,
2992
2993 .clkouttobamse = 1,
2994 .analog_output = 0,
2995
2996 .wbd_vhf_offset = 0,
2997 .wbd_cband_offset = 0,
2998 .use_pwm_agc = 1,
2999 .clkoutdrive = 0,
3000
3001 .fref_clock_ratio = 0,
3002
3003 .wbd = dib7090_wbd_table,
3004
3005 .ls_cfg_pad_drv = 0,
3006 .data_tx_drv = 0,
3007 .low_if = NULL,
3008 .in_soc = 1,
3009 }, {
3010 .io.clock_khz = 12000,
3011 .io.pll_bypass = 0,
3012 .io.pll_range = 0,
3013 .io.pll_prediv = 3,
3014 .io.pll_loopdiv = 6,
3015 .io.adc_clock_ratio = 0,
3016 .io.pll_int_loop_filt = 0,
3017
3018 .freq_offset_khz_uhf = -50,
3019 .freq_offset_khz_vhf = -70,
3020
3021 .clkouttobamse = 1,
3022 .analog_output = 0,
3023
3024 .wbd_vhf_offset = 0,
3025 .wbd_cband_offset = 0,
3026 .use_pwm_agc = 1,
3027 .clkoutdrive = 0,
3028
3029 .fref_clock_ratio = 0,
3030
3031 .wbd = dib7090_wbd_table,
3032
3033 .ls_cfg_pad_drv = 0,
3034 .data_tx_drv = 0,
3035 .low_if = NULL,
3036 .in_soc = 1,
3037 }
3038};
3039
3040static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
3041{
3042 struct dib0700_adapter_state *state = adap->priv;
3043
3044 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3045 return -ENODEV;
3046
3047 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3048 msleep(20);
3049 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3050 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3051 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3052 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3053
3054 msleep(20);
3055 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3056 msleep(20);
3057 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3058
3059 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
3060 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__);
3061 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3062 return -ENODEV;
3063 }
3064 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
3065
3066 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3067}
3068
3069static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
3070{
3071 struct dib0700_adapter_state *st = adap->priv;
3072 struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3073
3074 nim7090_dib0090_config.reset = st->dib7000p_ops.tuner_sleep,
3075 nim7090_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep,
3076 nim7090_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3077
3078 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
3079 return -ENODEV;
3080
3081 st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3082
3083 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3084 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3085 return 0;
3086}
3087
3088static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
3089{
3090 struct dib0700_state *st = adap->dev->priv;
3091 struct dib0700_adapter_state *state = adap->priv;
3092
3093 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3094 return -ENODEV;
3095
3096
3097 st->disable_streaming_master_mode = 1;
3098
3099 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3100 msleep(20);
3101 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3102 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3103 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3104 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3105
3106 msleep(20);
3107 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3108 msleep(20);
3109 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3110
3111
3112 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
3113 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__);
3114 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3115 return -ENODEV;
3116 }
3117
3118 dib0700_set_i2c_speed(adap->dev, 340);
3119 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
3120 if (adap->fe_adap[0].fe == NULL)
3121 return -ENODEV;
3122
3123 state->dib7000p_ops.slave_reset(adap->fe_adap[0].fe);
3124
3125 return 0;
3126}
3127
3128static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
3129{
3130 struct i2c_adapter *i2c;
3131 struct dib0700_adapter_state *state = adap->priv;
3132
3133 if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
3134 err("the master dib7090 has to be initialized first");
3135 return -ENODEV;
3136 }
3137
3138 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3139 return -ENODEV;
3140
3141 i2c = state->dib7000p_ops.get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
3142 if (state->dib7000p_ops.i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
3143 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__);
3144 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3145 return -ENODEV;
3146 }
3147
3148 adap->fe_adap[0].fe = state->dib7000p_ops.init(i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
3149 dib0700_set_i2c_speed(adap->dev, 200);
3150
3151 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3152}
3153
3154static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
3155{
3156 struct dib0700_adapter_state *st = adap->priv;
3157 struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3158
3159 tfe7090pvr_dib0090_config[0].reset = st->dib7000p_ops.tuner_sleep;
3160 tfe7090pvr_dib0090_config[0].sleep = st->dib7000p_ops.tuner_sleep;
3161 tfe7090pvr_dib0090_config[0].get_adc_power = st->dib7000p_ops.get_adc_power;
3162
3163 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
3164 return -ENODEV;
3165
3166 st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3167
3168 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3169 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3170 return 0;
3171}
3172
3173static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
3174{
3175 struct dib0700_adapter_state *st = adap->priv;
3176 struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3177
3178 tfe7090pvr_dib0090_config[1].reset = st->dib7000p_ops.tuner_sleep;
3179 tfe7090pvr_dib0090_config[1].sleep = st->dib7000p_ops.tuner_sleep;
3180 tfe7090pvr_dib0090_config[1].get_adc_power = st->dib7000p_ops.get_adc_power;
3181
3182 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
3183 return -ENODEV;
3184
3185 st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3186
3187 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3188 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3189 return 0;
3190}
3191
3192static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
3193{
3194 struct dib0700_state *st = adap->dev->priv;
3195 struct dib0700_adapter_state *state = adap->priv;
3196
3197 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3198 return -ENODEV;
3199
3200
3201 st->disable_streaming_master_mode = 1;
3202
3203 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3204 msleep(20);
3205 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3206 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3207 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3208 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3209 msleep(20);
3210 dib0700_ctrl_clock(adap->dev, 72, 1);
3211 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3212 msleep(20);
3213 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3214
3215 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap,
3216 1, 0x10, &tfe7790p_dib7000p_config) != 0) {
3217 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
3218 __func__);
3219 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3220 return -ENODEV;
3221 }
3222 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
3223 0x80, &tfe7790p_dib7000p_config);
3224
3225 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3226}
3227
3228static int tfe7790p_tuner_attach(struct dvb_usb_adapter *adap)
3229{
3230 struct dib0700_adapter_state *st = adap->priv;
3231 struct i2c_adapter *tun_i2c =
3232 st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3233
3234
3235 tfe7790p_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
3236 tfe7790p_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
3237 tfe7790p_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3238
3239 if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3240 &tfe7790p_dib0090_config) == NULL)
3241 return -ENODEV;
3242
3243 st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3244
3245 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3246 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3247 return 0;
3248}
3249
3250
3251static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
3252 {
3253 .output_mpeg2_in_188_bytes = 1,
3254
3255 .agc_config_count = 1,
3256 .agc = &dib7070_agc_config,
3257 .bw = &dib7070_bw_config_12_mhz,
3258 .tuner_is_baseband = 1,
3259 .spur_protect = 1,
3260
3261 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3262 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3263 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3264
3265 .hostbus_diversity = 1,
3266 }, {
3267 .output_mpeg2_in_188_bytes = 1,
3268
3269 .agc_config_count = 1,
3270 .agc = &dib7070_agc_config,
3271 .bw = &dib7070_bw_config_12_mhz,
3272 .tuner_is_baseband = 1,
3273 .spur_protect = 1,
3274
3275 .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3276 .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3277 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3278
3279 .hostbus_diversity = 1,
3280 }
3281};
3282
3283static void stk7070pd_init(struct dvb_usb_device *dev)
3284{
3285 dib0700_set_gpio(dev, GPIO6, GPIO_OUT, 1);
3286 msleep(10);
3287 dib0700_set_gpio(dev, GPIO9, GPIO_OUT, 1);
3288 dib0700_set_gpio(dev, GPIO4, GPIO_OUT, 1);
3289 dib0700_set_gpio(dev, GPIO7, GPIO_OUT, 1);
3290 dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 0);
3291
3292 dib0700_ctrl_clock(dev, 72, 1);
3293
3294 msleep(10);
3295 dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 1);
3296}
3297
3298static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
3299{
3300 struct dib0700_adapter_state *state = adap->priv;
3301
3302 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3303 return -ENODEV;
3304
3305 stk7070pd_init(adap->dev);
3306
3307 msleep(10);
3308 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3309
3310 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
3311 stk7070pd_dib7000p_config) != 0) {
3312 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
3313 __func__);
3314 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3315 return -ENODEV;
3316 }
3317
3318 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
3319 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3320}
3321
3322static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
3323{
3324 struct dib0700_adapter_state *state = adap->priv;
3325
3326 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3327 return -ENODEV;
3328
3329 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
3330 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3331}
3332
3333static int novatd_read_status_override(struct dvb_frontend *fe,
3334 enum fe_status *stat)
3335{
3336 struct dvb_usb_adapter *adap = fe->dvb->priv;
3337 struct dvb_usb_device *dev = adap->dev;
3338 struct dib0700_state *state = dev->priv;
3339 int ret;
3340
3341 ret = state->read_status(fe, stat);
3342
3343 if (!ret)
3344 dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3345 !!(*stat & FE_HAS_LOCK));
3346
3347 return ret;
3348}
3349
3350static int novatd_sleep_override(struct dvb_frontend* fe)
3351{
3352 struct dvb_usb_adapter *adap = fe->dvb->priv;
3353 struct dvb_usb_device *dev = adap->dev;
3354 struct dib0700_state *state = dev->priv;
3355
3356
3357 dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, 0);
3358
3359 return state->sleep(fe);
3360}
3361
3362
3363
3364
3365
3366
3367
3368static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
3369{
3370 struct dvb_usb_device *dev = adap->dev;
3371 struct dib0700_state *st = dev->priv;
3372 struct dib0700_adapter_state *state = adap->priv;
3373
3374 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3375 return -ENODEV;
3376
3377 if (adap->id == 0) {
3378 stk7070pd_init(dev);
3379
3380
3381 dib0700_set_gpio(dev, GPIO0, GPIO_OUT, 0);
3382 dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
3383 dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
3384
3385 if (state->dib7000p_ops.i2c_enumeration(&dev->i2c_adap, 2, 18,
3386 stk7070pd_dib7000p_config) != 0) {
3387 err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
3388 __func__);
3389 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3390 return -ENODEV;
3391 }
3392 }
3393
3394 adap->fe_adap[0].fe = state->dib7000p_ops.init(&dev->i2c_adap,
3395 adap->id == 0 ? 0x80 : 0x82,
3396 &stk7070pd_dib7000p_config[adap->id]);
3397
3398 if (adap->fe_adap[0].fe == NULL)
3399 return -ENODEV;
3400
3401 st->read_status = adap->fe_adap[0].fe->ops.read_status;
3402 adap->fe_adap[0].fe->ops.read_status = novatd_read_status_override;
3403 st->sleep = adap->fe_adap[0].fe->ops.sleep;
3404 adap->fe_adap[0].fe->ops.sleep = novatd_sleep_override;
3405
3406 return 0;
3407}
3408
3409
3410static struct s5h1411_config pinnacle_801e_config = {
3411 .output_mode = S5H1411_PARALLEL_OUTPUT,
3412 .gpio = S5H1411_GPIO_OFF,
3413 .mpeg_timing = S5H1411_MPEGTIMING_NONCONTINUOUS_NONINVERTING_CLOCK,
3414 .qam_if = S5H1411_IF_44000,
3415 .vsb_if = S5H1411_IF_44000,
3416 .inversion = S5H1411_INVERSION_OFF,
3417 .status_mode = S5H1411_DEMODLOCKING
3418};
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
3432{
3433 struct dib0700_state *st = adap->dev->priv;
3434
3435
3436 st->fw_use_new_i2c_api = 1;
3437
3438
3439 st->disable_streaming_master_mode = 1;
3440
3441
3442 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
3443 dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
3444 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3445 msleep(400);
3446 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3447 msleep(60);
3448 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3449 msleep(30);
3450 dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3451 dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3452 dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3453 dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3454 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
3455 msleep(30);
3456
3457
3458 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3459
3460
3461 adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
3462 &adap->dev->i2c_adap);
3463 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3464}
3465
3466static int dib0700_xc5000_tuner_callback(void *priv, int component,
3467 int command, int arg)
3468{
3469 struct dvb_usb_adapter *adap = priv;
3470
3471 if (command == XC5000_TUNER_RESET) {
3472
3473 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
3474 msleep(10);
3475 dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
3476 msleep(10);
3477 } else {
3478 err("xc5000: unknown tuner callback command: %d\n", command);
3479 return -EINVAL;
3480 }
3481
3482 return 0;
3483}
3484
3485static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3486 .i2c_address = 0x64,
3487 .if_khz = 5380,
3488};
3489
3490static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
3491{
3492
3493 adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
3494
3495 return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
3496 &s5h1411_xc5000_tunerconfig)
3497 == NULL ? -ENODEV : 0;
3498}
3499
3500static int dib0700_xc4000_tuner_callback(void *priv, int component,
3501 int command, int arg)
3502{
3503 struct dvb_usb_adapter *adap = priv;
3504 struct dib0700_adapter_state *state = adap->priv;
3505
3506 if (command == XC4000_TUNER_RESET) {
3507
3508 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
3509 msleep(10);
3510 state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3511 } else {
3512 err("xc4000: unknown tuner callback command: %d\n", command);
3513 return -EINVAL;
3514 }
3515
3516 return 0;
3517}
3518
3519static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
3520 .band_caps = BAND_UHF | BAND_VHF,
3521 .setup = 0x64,
3522 .inv_gain = 0x02c8,
3523 .time_stabiliz = 0x15,
3524 .alpha_level = 0x00,
3525 .thlock = 0x76,
3526 .wbd_inv = 0x01,
3527 .wbd_ref = 0x0b33,
3528 .wbd_sel = 0x00,
3529 .wbd_alpha = 0x02,
3530 .agc1_max = 0x00,
3531 .agc1_min = 0x00,
3532 .agc2_max = 0x9b26,
3533 .agc2_min = 0x26ca,
3534 .agc1_pt1 = 0x00,
3535 .agc1_pt2 = 0x00,
3536 .agc1_pt3 = 0x00,
3537 .agc1_slope1 = 0x00,
3538 .agc1_slope2 = 0x00,
3539 .agc2_pt1 = 0x00,
3540 .agc2_pt2 = 0x80,
3541 .agc2_slope1 = 0x1d,
3542 .agc2_slope2 = 0x1d,
3543 .alpha_mant = 0x11,
3544 .alpha_exp = 0x1b,
3545 .beta_mant = 0x17,
3546 .beta_exp = 0x33,
3547 .perform_agc_softsplit = 0x00,
3548};
3549
3550static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
3551 .internal = 60000,
3552 .sampling = 30000,
3553 .pll_prediv = 1,
3554 .pll_ratio = 8,
3555 .pll_range = 3,
3556 .pll_reset = 1,
3557 .pll_bypass = 0,
3558 .enable_refdiv = 0,
3559 .bypclk_div = 0,
3560 .IO_CLK_en_core = 1,
3561 .ADClkSrc = 1,
3562 .modulo = 0,
3563 .sad_cfg = (3 << 14) | (1 << 12) | 524,
3564 .ifreq = 39370534,
3565 .timf = 20452225,
3566 .xtal_hz = 30000000
3567};
3568
3569
3570static struct dib7000p_config pctv_340e_config = {
3571 .output_mpeg2_in_188_bytes = 1,
3572
3573 .agc_config_count = 1,
3574 .agc = &stk7700p_7000p_xc4000_agc_config,
3575 .bw = &stk7700p_xc4000_pll_config,
3576
3577 .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
3578 .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
3579 .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
3580};
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
3594{
3595 struct dib0700_state *st = adap->dev->priv;
3596 struct dib0700_adapter_state *state = adap->priv;
3597
3598 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3599 return -ENODEV;
3600
3601
3602 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3603 msleep(50);
3604 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3605 msleep(100);
3606
3607
3608 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3609 msleep(1);
3610 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3611
3612
3613 dib0700_set_gpio(adap->dev, GPIO8, GPIO_OUT, 1);
3614
3615
3616 dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3617
3618
3619 dib0700_ctrl_clock(adap->dev, 72, 1);
3620
3621 msleep(500);
3622
3623 if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
3624
3625 dvb_detach(state->dib7000p_ops.set_wbd_ref);
3626 return -ENODEV;
3627 }
3628
3629 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x12,
3630 &pctv_340e_config);
3631 st->is_dib7000pc = 1;
3632
3633 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3634}
3635
3636static struct xc4000_config dib7000p_xc4000_tunerconfig = {
3637 .i2c_address = 0x61,
3638 .default_pm = 1,
3639 .dvb_amplitude = 0,
3640 .set_smoothedcvbs = 0,
3641 .if_khz = 5400
3642};
3643
3644static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
3645{
3646 struct i2c_adapter *tun_i2c;
3647 struct dib0700_adapter_state *state = adap->priv;
3648
3649
3650 tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
3651 DIBX000_I2C_INTERFACE_TUNER, 1);
3652 if (tun_i2c == NULL) {
3653 printk(KERN_ERR "Could not reach tuner i2c bus\n");
3654 return 0;
3655 }
3656
3657
3658 adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
3659
3660 return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
3661 &dib7000p_xc4000_tunerconfig)
3662 == NULL ? -ENODEV : 0;
3663}
3664
3665static struct lgdt3305_config hcw_lgdt3305_config = {
3666 .i2c_addr = 0x0e,
3667 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
3668 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
3669 .tpvalid_polarity = LGDT3305_TP_VALID_LOW,
3670 .deny_i2c_rptr = 0,
3671 .spectral_inversion = 1,
3672 .qam_if_khz = 6000,
3673 .vsb_if_khz = 6000,
3674 .usref_8vsb = 0x0500,
3675};
3676
3677static struct mxl5007t_config hcw_mxl5007t_config = {
3678 .xtal_freq_hz = MxL_XTAL_25_MHZ,
3679 .if_freq_hz = MxL_IF_6_MHZ,
3680 .invert_if = 1,
3681};
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
3694{
3695 struct dib0700_state *st = adap->dev->priv;
3696
3697
3698 st->fw_use_new_i2c_api = 1;
3699
3700 st->disable_streaming_master_mode = 1;
3701
3702
3703 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3704 msleep(30);
3705 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3706 msleep(30);
3707
3708
3709 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3710 msleep(30);
3711 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3712 msleep(30);
3713 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3714 msleep(30);
3715
3716 adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
3717 &hcw_lgdt3305_config,
3718 &adap->dev->i2c_adap);
3719
3720 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3721}
3722
3723static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
3724{
3725 return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
3726 &adap->dev->i2c_adap, 0x60,
3727 &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
3728}
3729
3730static int xbox_one_attach(struct dvb_usb_adapter *adap)
3731{
3732 struct dib0700_state *st = adap->dev->priv;
3733 struct i2c_client *client_demod, *client_tuner;
3734 struct dvb_usb_device *d = adap->dev;
3735 struct mn88472_config mn88472_config = { };
3736 struct tda18250_config tda18250_config;
3737 struct i2c_board_info info;
3738
3739 st->fw_use_new_i2c_api = 1;
3740 st->disable_streaming_master_mode = 1;
3741
3742
3743 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3744 msleep(30);
3745 dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3746 msleep(30);
3747
3748
3749 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3750 msleep(30);
3751 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3752 msleep(30);
3753 dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3754 msleep(30);
3755
3756
3757 mn88472_config.fe = &adap->fe_adap[0].fe;
3758 mn88472_config.i2c_wr_max = 22;
3759 mn88472_config.xtal = 20500000;
3760 mn88472_config.ts_mode = PARALLEL_TS_MODE;
3761 mn88472_config.ts_clock = FIXED_TS_CLOCK;
3762 memset(&info, 0, sizeof(struct i2c_board_info));
3763 strscpy(info.type, "mn88472", I2C_NAME_SIZE);
3764 info.addr = 0x18;
3765 info.platform_data = &mn88472_config;
3766 request_module(info.type);
3767 client_demod = i2c_new_device(&d->i2c_adap, &info);
3768 if (client_demod == NULL || client_demod->dev.driver == NULL)
3769 goto fail_demod_device;
3770 if (!try_module_get(client_demod->dev.driver->owner))
3771 goto fail_demod_module;
3772
3773 st->i2c_client_demod = client_demod;
3774
3775 adap->fe_adap[0].fe = mn88472_config.get_dvb_frontend(client_demod);
3776
3777
3778 memset(&tda18250_config, 0, sizeof(tda18250_config));
3779 tda18250_config.if_dvbt_6 = 3950;
3780 tda18250_config.if_dvbt_7 = 4450;
3781 tda18250_config.if_dvbt_8 = 4950;
3782 tda18250_config.if_dvbc_6 = 4950;
3783 tda18250_config.if_dvbc_8 = 4950;
3784 tda18250_config.if_atsc = 4079;
3785 tda18250_config.loopthrough = true;
3786 tda18250_config.xtal_freq = TDA18250_XTAL_FREQ_27MHZ;
3787 tda18250_config.fe = adap->fe_adap[0].fe;
3788
3789 memset(&info, 0, sizeof(struct i2c_board_info));
3790 strscpy(info.type, "tda18250", I2C_NAME_SIZE);
3791 info.addr = 0x60;
3792 info.platform_data = &tda18250_config;
3793
3794 request_module(info.type);
3795 client_tuner = i2c_new_device(&adap->dev->i2c_adap, &info);
3796 if (client_tuner == NULL || client_tuner->dev.driver == NULL)
3797 goto fail_tuner_device;
3798 if (!try_module_get(client_tuner->dev.driver->owner))
3799 goto fail_tuner_module;
3800
3801 st->i2c_client_tuner = client_tuner;
3802 return 0;
3803
3804fail_tuner_module:
3805 i2c_unregister_device(client_tuner);
3806fail_tuner_device:
3807 module_put(client_demod->dev.driver->owner);
3808fail_demod_module:
3809 i2c_unregister_device(client_demod);
3810fail_demod_device:
3811 return -ENODEV;
3812}
3813
3814
3815
3816struct usb_device_id dib0700_usb_id_table[] = {
3817 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) },
3818 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P_PC) },
3819 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
3820 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
3821 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
3822 { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
3823 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500) },
3824 { USB_DEVICE(USB_VID_UNIWILL, USB_PID_UNIWILL_STK7700P) },
3825 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
3826 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
3827{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
3828 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV2000E) },
3829 { USB_DEVICE(USB_VID_TERRATEC,
3830 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
3831 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
3832 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700D) },
3833{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070P) },
3834 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
3835 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7070PD) },
3836 { USB_DEVICE(USB_VID_PINNACLE,
3837 USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
3838 { USB_DEVICE(USB_VID_COMPRO, USB_PID_COMPRO_VIDEOMATE_U500_PC) },
3839{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
3840 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U7000) },
3841 { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
3842 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000) },
3843 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100) },
3844{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
3845 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
3846 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
3847 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_EXPRESSCARD_320CX) },
3848 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV72E) },
3849{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73E) },
3850 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_EC372S) },
3851 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
3852 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS) },
3853 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
3854{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
3855 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
3856 { USB_DEVICE(USB_VID_GIGABYTE, USB_PID_GIGABYTE_U8000) },
3857 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700PH) },
3858 { USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3000H) },
3859{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E) },
3860 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV801E_SE) },
3861 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
3862 { USB_DEVICE(USB_VID_TERRATEC,
3863 USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
3864 { USB_DEVICE(USB_VID_SONY, USB_PID_SONY_PLAYTV) },
3865{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_PD378S) },
3866 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
3867 { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
3868 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_MC770) },
3869 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT) },
3870{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_Dlx) },
3871 { USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_H) },
3872 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T3) },
3873 { USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T5) },
3874 { USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D) },
3875{ USB_DEVICE(USB_VID_YUAN, USB_PID_YUAN_STK7700D_2) },
3876 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73A) },
3877 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV73ESE) },
3878 { USB_DEVICE(USB_VID_PCTV, USB_PID_PINNACLE_PCTV282E) },
3879 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7770P) },
3880{ USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_XXS_2) },
3881 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XPVR) },
3882 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK807XP) },
3883 { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
3884 { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
3885{ USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV73ESE) },
3886 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV282E) },
3887 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK8096GP) },
3888 { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DIVERSITY) },
3889 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090M) },
3890{ USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM8096MD) },
3891 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM9090MD) },
3892 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_NIM7090) },
3893 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7090PVR) },
3894 { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
3895{ USB_DEVICE(USB_VID_MEDION, USB_PID_CREATIX_CTX1921) },
3896 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E) },
3897 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV340E_SE) },
3898 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE7790P) },
3899 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_TFE8096P) },
3900{ USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_DTT_2) },
3901 { USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_2002E) },
3902 { USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_2002E_SE) },
3903 { USB_DEVICE(USB_VID_PCTV, USB_PID_DIBCOM_STK8096PVR) },
3904 { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK8096PVR) },
3905{ USB_DEVICE(USB_VID_HAMA, USB_PID_HAMA_DVBT_HYBRID) },
3906 { USB_DEVICE(USB_VID_MICROSOFT, USB_PID_XBOX_ONE_TUNER) },
3907 { 0 }
3908};
3909MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
3910
3911#define DIB0700_DEFAULT_DEVICE_PROPERTIES \
3912 .caps = DVB_USB_IS_AN_I2C_ADAPTER, \
3913 .usb_ctrl = DEVICE_SPECIFIC, \
3914 .firmware = "dvb-usb-dib0700-1.20.fw", \
3915 .download_firmware = dib0700_download_firmware, \
3916 .no_reconnect = 1, \
3917 .size_of_priv = sizeof(struct dib0700_state), \
3918 .i2c_algo = &dib0700_i2c_algo, \
3919 .identify_state = dib0700_identify_state
3920
3921#define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
3922 .streaming_ctrl = dib0700_streaming_ctrl, \
3923 .stream = { \
3924 .type = USB_BULK, \
3925 .count = 4, \
3926 .endpoint = ep, \
3927 .u = { \
3928 .bulk = { \
3929 .buffersize = 39480, \
3930 } \
3931 } \
3932 }
3933
3934#define DIB0700_NUM_FRONTENDS(n) \
3935 .num_frontends = n, \
3936 .size_of_priv = sizeof(struct dib0700_adapter_state)
3937
3938struct dvb_usb_device_properties dib0700_devices[] = {
3939 {
3940 DIB0700_DEFAULT_DEVICE_PROPERTIES,
3941
3942 .num_adapters = 1,
3943 .adapter = {
3944 {
3945 DIB0700_NUM_FRONTENDS(1),
3946 .fe = {{
3947 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
3948 .pid_filter_count = 32,
3949 .pid_filter = stk7700p_pid_filter,
3950 .pid_filter_ctrl = stk7700p_pid_filter_ctrl,
3951 .frontend_attach = stk7700p_frontend_attach,
3952 .tuner_attach = stk7700p_tuner_attach,
3953
3954 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
3955 }},
3956 },
3957 },
3958
3959 .num_device_descs = 8,
3960 .devices = {
3961 { "DiBcom STK7700P reference design",
3962 { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
3963 { NULL },
3964 },
3965 { "Hauppauge Nova-T Stick",
3966 { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
3967 { NULL },
3968 },
3969 { "AVerMedia AVerTV DVB-T Volar",
3970 { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
3971 { NULL },
3972 },
3973 { "Compro Videomate U500",
3974 { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
3975 { NULL },
3976 },
3977 { "Uniwill STK7700P based (Hama and others)",
3978 { &dib0700_usb_id_table[7], NULL },
3979 { NULL },
3980 },
3981 { "Leadtek Winfast DTV Dongle (STK7700P based)",
3982 { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
3983 { NULL },
3984 },
3985 { "AVerMedia AVerTV DVB-T Express",
3986 { &dib0700_usb_id_table[20] },
3987 { NULL },
3988 },
3989 { "Gigabyte U7000",
3990 { &dib0700_usb_id_table[21], NULL },
3991 { NULL },
3992 }
3993 },
3994
3995 .rc.core = {
3996 .rc_interval = DEFAULT_RC_INTERVAL,
3997 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
3998 .rc_query = dib0700_rc_query_old_firmware,
3999 .allowed_protos = RC_PROTO_BIT_RC5 |
4000 RC_PROTO_BIT_RC6_MCE |
4001 RC_PROTO_BIT_NEC,
4002 .change_protocol = dib0700_change_protocol,
4003 },
4004 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4005
4006 .num_adapters = 2,
4007 .adapter = {
4008 {
4009 DIB0700_NUM_FRONTENDS(1),
4010 .fe = {{
4011 .frontend_attach = bristol_frontend_attach,
4012 .tuner_attach = bristol_tuner_attach,
4013
4014 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4015 }},
4016 }, {
4017 DIB0700_NUM_FRONTENDS(1),
4018 .fe = {{
4019 .frontend_attach = bristol_frontend_attach,
4020 .tuner_attach = bristol_tuner_attach,
4021
4022 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4023 }},
4024 }
4025 },
4026
4027 .num_device_descs = 1,
4028 .devices = {
4029 { "Hauppauge Nova-T 500 Dual DVB-T",
4030 { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
4031 { NULL },
4032 },
4033 },
4034
4035 .rc.core = {
4036 .rc_interval = DEFAULT_RC_INTERVAL,
4037 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4038 .rc_query = dib0700_rc_query_old_firmware,
4039 .allowed_protos = RC_PROTO_BIT_RC5 |
4040 RC_PROTO_BIT_RC6_MCE |
4041 RC_PROTO_BIT_NEC,
4042 .change_protocol = dib0700_change_protocol,
4043 },
4044 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4045
4046 .num_adapters = 2,
4047 .adapter = {
4048 {
4049 DIB0700_NUM_FRONTENDS(1),
4050 .fe = {{
4051 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4052 .pid_filter_count = 32,
4053 .pid_filter = stk70x0p_pid_filter,
4054 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4055 .frontend_attach = stk7700d_frontend_attach,
4056 .tuner_attach = stk7700d_tuner_attach,
4057
4058 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4059 }},
4060 }, {
4061 DIB0700_NUM_FRONTENDS(1),
4062 .fe = {{
4063 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4064 .pid_filter_count = 32,
4065 .pid_filter = stk70x0p_pid_filter,
4066 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4067 .frontend_attach = stk7700d_frontend_attach,
4068 .tuner_attach = stk7700d_tuner_attach,
4069
4070 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4071 }},
4072 }
4073 },
4074
4075 .num_device_descs = 5,
4076 .devices = {
4077 { "Pinnacle PCTV 2000e",
4078 { &dib0700_usb_id_table[11], NULL },
4079 { NULL },
4080 },
4081 { "Terratec Cinergy DT XS Diversity",
4082 { &dib0700_usb_id_table[12], NULL },
4083 { NULL },
4084 },
4085 { "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
4086 { &dib0700_usb_id_table[13], NULL },
4087 { NULL },
4088 },
4089 { "DiBcom STK7700D reference design",
4090 { &dib0700_usb_id_table[14], NULL },
4091 { NULL },
4092 },
4093 { "YUAN High-Tech DiBcom STK7700D",
4094 { &dib0700_usb_id_table[55], NULL },
4095 { NULL },
4096 },
4097
4098 },
4099
4100 .rc.core = {
4101 .rc_interval = DEFAULT_RC_INTERVAL,
4102 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4103 .rc_query = dib0700_rc_query_old_firmware,
4104 .allowed_protos = RC_PROTO_BIT_RC5 |
4105 RC_PROTO_BIT_RC6_MCE |
4106 RC_PROTO_BIT_NEC,
4107 .change_protocol = dib0700_change_protocol,
4108 },
4109 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4110
4111 .num_adapters = 1,
4112 .adapter = {
4113 {
4114 DIB0700_NUM_FRONTENDS(1),
4115 .fe = {{
4116 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4117 .pid_filter_count = 32,
4118 .pid_filter = stk70x0p_pid_filter,
4119 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4120 .frontend_attach = stk7700P2_frontend_attach,
4121 .tuner_attach = stk7700d_tuner_attach,
4122
4123 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4124 }},
4125 },
4126 },
4127
4128 .num_device_descs = 3,
4129 .devices = {
4130 { "ASUS My Cinema U3000 Mini DVBT Tuner",
4131 { &dib0700_usb_id_table[23], NULL },
4132 { NULL },
4133 },
4134 { "Yuan EC372S",
4135 { &dib0700_usb_id_table[31], NULL },
4136 { NULL },
4137 },
4138 { "Terratec Cinergy T Express",
4139 { &dib0700_usb_id_table[42], NULL },
4140 { NULL },
4141 }
4142 },
4143
4144 .rc.core = {
4145 .rc_interval = DEFAULT_RC_INTERVAL,
4146 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4147 .module_name = "dib0700",
4148 .rc_query = dib0700_rc_query_old_firmware,
4149 .allowed_protos = RC_PROTO_BIT_RC5 |
4150 RC_PROTO_BIT_RC6_MCE |
4151 RC_PROTO_BIT_NEC,
4152 .change_protocol = dib0700_change_protocol,
4153 },
4154 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4155
4156 .num_adapters = 1,
4157 .adapter = {
4158 {
4159 DIB0700_NUM_FRONTENDS(1),
4160 .fe = {{
4161 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4162 .pid_filter_count = 32,
4163 .pid_filter = stk70x0p_pid_filter,
4164 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4165 .frontend_attach = stk7070p_frontend_attach,
4166 .tuner_attach = dib7070p_tuner_attach,
4167
4168 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4169 }},
4170 },
4171 },
4172
4173 .num_device_descs = 12,
4174 .devices = {
4175 { "DiBcom STK7070P reference design",
4176 { &dib0700_usb_id_table[15], NULL },
4177 { NULL },
4178 },
4179 { "Pinnacle PCTV DVB-T Flash Stick",
4180 { &dib0700_usb_id_table[16], NULL },
4181 { NULL },
4182 },
4183 { "Artec T14BR DVB-T",
4184 { &dib0700_usb_id_table[22], NULL },
4185 { NULL },
4186 },
4187 { "ASUS My Cinema U3100 Mini DVBT Tuner",
4188 { &dib0700_usb_id_table[24], NULL },
4189 { NULL },
4190 },
4191 { "Hauppauge Nova-T Stick",
4192 { &dib0700_usb_id_table[25], NULL },
4193 { NULL },
4194 },
4195 { "Hauppauge Nova-T MyTV.t",
4196 { &dib0700_usb_id_table[26], NULL },
4197 { NULL },
4198 },
4199 { "Pinnacle PCTV 72e",
4200 { &dib0700_usb_id_table[29], NULL },
4201 { NULL },
4202 },
4203 { "Pinnacle PCTV 73e",
4204 { &dib0700_usb_id_table[30], NULL },
4205 { NULL },
4206 },
4207 { "Elgato EyeTV DTT",
4208 { &dib0700_usb_id_table[49], NULL },
4209 { NULL },
4210 },
4211 { "Yuan PD378S",
4212 { &dib0700_usb_id_table[45], NULL },
4213 { NULL },
4214 },
4215 { "Elgato EyeTV Dtt Dlx PD378S",
4216 { &dib0700_usb_id_table[50], NULL },
4217 { NULL },
4218 },
4219 { "Elgato EyeTV DTT rev. 2",
4220 { &dib0700_usb_id_table[80], NULL },
4221 { NULL },
4222 },
4223 },
4224
4225 .rc.core = {
4226 .rc_interval = DEFAULT_RC_INTERVAL,
4227 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4228 .module_name = "dib0700",
4229 .rc_query = dib0700_rc_query_old_firmware,
4230 .allowed_protos = RC_PROTO_BIT_RC5 |
4231 RC_PROTO_BIT_RC6_MCE |
4232 RC_PROTO_BIT_NEC,
4233 .change_protocol = dib0700_change_protocol,
4234 },
4235 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4236
4237 .num_adapters = 1,
4238 .adapter = {
4239 {
4240 DIB0700_NUM_FRONTENDS(1),
4241 .fe = {{
4242 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4243 .pid_filter_count = 32,
4244 .pid_filter = stk70x0p_pid_filter,
4245 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4246 .frontend_attach = stk7070p_frontend_attach,
4247 .tuner_attach = dib7070p_tuner_attach,
4248
4249 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4250 }},
4251 },
4252 },
4253
4254 .num_device_descs = 3,
4255 .devices = {
4256 { "Pinnacle PCTV 73A",
4257 { &dib0700_usb_id_table[56], NULL },
4258 { NULL },
4259 },
4260 { "Pinnacle PCTV 73e SE",
4261 { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
4262 { NULL },
4263 },
4264 { "Pinnacle PCTV 282e",
4265 { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
4266 { NULL },
4267 },
4268 },
4269
4270 .rc.core = {
4271 .rc_interval = DEFAULT_RC_INTERVAL,
4272 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4273 .module_name = "dib0700",
4274 .rc_query = dib0700_rc_query_old_firmware,
4275 .allowed_protos = RC_PROTO_BIT_RC5 |
4276 RC_PROTO_BIT_RC6_MCE |
4277 RC_PROTO_BIT_NEC,
4278 .change_protocol = dib0700_change_protocol,
4279 },
4280 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4281
4282 .num_adapters = 2,
4283 .adapter = {
4284 {
4285 DIB0700_NUM_FRONTENDS(1),
4286 .fe = {{
4287 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4288 .pid_filter_count = 32,
4289 .pid_filter = stk70x0p_pid_filter,
4290 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4291 .frontend_attach = novatd_frontend_attach,
4292 .tuner_attach = dib7070p_tuner_attach,
4293
4294 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4295 }},
4296 }, {
4297 DIB0700_NUM_FRONTENDS(1),
4298 .fe = {{
4299 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4300 .pid_filter_count = 32,
4301 .pid_filter = stk70x0p_pid_filter,
4302 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4303 .frontend_attach = novatd_frontend_attach,
4304 .tuner_attach = dib7070p_tuner_attach,
4305
4306 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4307 }},
4308 }
4309 },
4310
4311 .num_device_descs = 3,
4312 .devices = {
4313 { "Hauppauge Nova-TD Stick (52009)",
4314 { &dib0700_usb_id_table[35], NULL },
4315 { NULL },
4316 },
4317 { "PCTV 2002e",
4318 { &dib0700_usb_id_table[81], NULL },
4319 { NULL },
4320 },
4321 { "PCTV 2002e SE",
4322 { &dib0700_usb_id_table[82], NULL },
4323 { NULL },
4324 },
4325 },
4326
4327 .rc.core = {
4328 .rc_interval = DEFAULT_RC_INTERVAL,
4329 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4330 .module_name = "dib0700",
4331 .rc_query = dib0700_rc_query_old_firmware,
4332 .allowed_protos = RC_PROTO_BIT_RC5 |
4333 RC_PROTO_BIT_RC6_MCE |
4334 RC_PROTO_BIT_NEC,
4335 .change_protocol = dib0700_change_protocol,
4336 },
4337 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4338
4339 .num_adapters = 2,
4340 .adapter = {
4341 {
4342 DIB0700_NUM_FRONTENDS(1),
4343 .fe = {{
4344 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4345 .pid_filter_count = 32,
4346 .pid_filter = stk70x0p_pid_filter,
4347 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4348 .frontend_attach = stk7070pd_frontend_attach0,
4349 .tuner_attach = dib7070p_tuner_attach,
4350
4351 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4352 }},
4353 }, {
4354 DIB0700_NUM_FRONTENDS(1),
4355 .fe = {{
4356 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4357 .pid_filter_count = 32,
4358 .pid_filter = stk70x0p_pid_filter,
4359 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4360 .frontend_attach = stk7070pd_frontend_attach1,
4361 .tuner_attach = dib7070p_tuner_attach,
4362
4363 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4364 }},
4365 }
4366 },
4367
4368 .num_device_descs = 5,
4369 .devices = {
4370 { "DiBcom STK7070PD reference design",
4371 { &dib0700_usb_id_table[17], NULL },
4372 { NULL },
4373 },
4374 { "Pinnacle PCTV Dual DVB-T Diversity Stick",
4375 { &dib0700_usb_id_table[18], NULL },
4376 { NULL },
4377 },
4378 { "Hauppauge Nova-TD-500 (84xxx)",
4379 { &dib0700_usb_id_table[36], NULL },
4380 { NULL },
4381 },
4382 { "Terratec Cinergy DT USB XS Diversity/ T5",
4383 { &dib0700_usb_id_table[43],
4384 &dib0700_usb_id_table[53], NULL},
4385 { NULL },
4386 },
4387 { "Sony PlayTV",
4388 { &dib0700_usb_id_table[44], NULL },
4389 { NULL },
4390 },
4391 },
4392
4393 .rc.core = {
4394 .rc_interval = DEFAULT_RC_INTERVAL,
4395 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4396 .module_name = "dib0700",
4397 .rc_query = dib0700_rc_query_old_firmware,
4398 .allowed_protos = RC_PROTO_BIT_RC5 |
4399 RC_PROTO_BIT_RC6_MCE |
4400 RC_PROTO_BIT_NEC,
4401 .change_protocol = dib0700_change_protocol,
4402 },
4403 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4404
4405 .num_adapters = 2,
4406 .adapter = {
4407 {
4408 DIB0700_NUM_FRONTENDS(1),
4409 .fe = {{
4410 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4411 .pid_filter_count = 32,
4412 .pid_filter = stk70x0p_pid_filter,
4413 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4414 .frontend_attach = stk7070pd_frontend_attach0,
4415 .tuner_attach = dib7070p_tuner_attach,
4416
4417 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4418 }},
4419 }, {
4420 DIB0700_NUM_FRONTENDS(1),
4421 .fe = {{
4422 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4423 .pid_filter_count = 32,
4424 .pid_filter = stk70x0p_pid_filter,
4425 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4426 .frontend_attach = stk7070pd_frontend_attach1,
4427 .tuner_attach = dib7070p_tuner_attach,
4428
4429 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4430 }},
4431 }
4432 },
4433
4434 .num_device_descs = 1,
4435 .devices = {
4436 { "Elgato EyeTV Diversity",
4437 { &dib0700_usb_id_table[68], NULL },
4438 { NULL },
4439 },
4440 },
4441
4442 .rc.core = {
4443 .rc_interval = DEFAULT_RC_INTERVAL,
4444 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
4445 .module_name = "dib0700",
4446 .rc_query = dib0700_rc_query_old_firmware,
4447 .allowed_protos = RC_PROTO_BIT_RC5 |
4448 RC_PROTO_BIT_RC6_MCE |
4449 RC_PROTO_BIT_NEC,
4450 .change_protocol = dib0700_change_protocol,
4451 },
4452 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4453
4454 .num_adapters = 1,
4455 .adapter = {
4456 {
4457 DIB0700_NUM_FRONTENDS(1),
4458 .fe = {{
4459 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4460 .pid_filter_count = 32,
4461 .pid_filter = stk70x0p_pid_filter,
4462 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4463 .frontend_attach = stk7700ph_frontend_attach,
4464 .tuner_attach = stk7700ph_tuner_attach,
4465
4466 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4467 }},
4468 },
4469 },
4470
4471 .num_device_descs = 10,
4472 .devices = {
4473 { "Terratec Cinergy HT USB XE",
4474 { &dib0700_usb_id_table[27], NULL },
4475 { NULL },
4476 },
4477 { "Pinnacle Expresscard 320cx",
4478 { &dib0700_usb_id_table[28], NULL },
4479 { NULL },
4480 },
4481 { "Terratec Cinergy HT Express",
4482 { &dib0700_usb_id_table[32], NULL },
4483 { NULL },
4484 },
4485 { "Gigabyte U8000-RH",
4486 { &dib0700_usb_id_table[37], NULL },
4487 { NULL },
4488 },
4489 { "YUAN High-Tech STK7700PH",
4490 { &dib0700_usb_id_table[38], NULL },
4491 { NULL },
4492 },
4493 { "Asus My Cinema-U3000Hybrid",
4494 { &dib0700_usb_id_table[39], NULL },
4495 { NULL },
4496 },
4497 { "YUAN High-Tech MC770",
4498 { &dib0700_usb_id_table[48], NULL },
4499 { NULL },
4500 },
4501 { "Leadtek WinFast DTV Dongle H",
4502 { &dib0700_usb_id_table[51], NULL },
4503 { NULL },
4504 },
4505 { "YUAN High-Tech STK7700D",
4506 { &dib0700_usb_id_table[54], NULL },
4507 { NULL },
4508 },
4509 { "Hama DVB=T Hybrid USB Stick",
4510 { &dib0700_usb_id_table[85], NULL },
4511 { NULL },
4512 },
4513 },
4514
4515 .rc.core = {
4516 .rc_interval = DEFAULT_RC_INTERVAL,
4517 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4518 .module_name = "dib0700",
4519 .rc_query = dib0700_rc_query_old_firmware,
4520 .allowed_protos = RC_PROTO_BIT_RC5 |
4521 RC_PROTO_BIT_RC6_MCE |
4522 RC_PROTO_BIT_NEC,
4523 .change_protocol = dib0700_change_protocol,
4524 },
4525 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4526 .num_adapters = 1,
4527 .adapter = {
4528 {
4529 DIB0700_NUM_FRONTENDS(1),
4530 .fe = {{
4531 .frontend_attach = s5h1411_frontend_attach,
4532 .tuner_attach = xc5000_tuner_attach,
4533
4534 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4535 }},
4536 },
4537 },
4538
4539 .num_device_descs = 2,
4540 .devices = {
4541 { "Pinnacle PCTV HD Pro USB Stick",
4542 { &dib0700_usb_id_table[40], NULL },
4543 { NULL },
4544 },
4545 { "Pinnacle PCTV HD USB Stick",
4546 { &dib0700_usb_id_table[41], NULL },
4547 { NULL },
4548 },
4549 },
4550
4551 .rc.core = {
4552 .rc_interval = DEFAULT_RC_INTERVAL,
4553 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4554 .module_name = "dib0700",
4555 .rc_query = dib0700_rc_query_old_firmware,
4556 .allowed_protos = RC_PROTO_BIT_RC5 |
4557 RC_PROTO_BIT_RC6_MCE |
4558 RC_PROTO_BIT_NEC,
4559 .change_protocol = dib0700_change_protocol,
4560 },
4561 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4562 .num_adapters = 1,
4563 .adapter = {
4564 {
4565 DIB0700_NUM_FRONTENDS(1),
4566 .fe = {{
4567 .frontend_attach = lgdt3305_frontend_attach,
4568 .tuner_attach = mxl5007t_tuner_attach,
4569
4570 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4571 }},
4572 },
4573 },
4574
4575 .num_device_descs = 2,
4576 .devices = {
4577 { "Hauppauge ATSC MiniCard (B200)",
4578 { &dib0700_usb_id_table[46], NULL },
4579 { NULL },
4580 },
4581 { "Hauppauge ATSC MiniCard (B210)",
4582 { &dib0700_usb_id_table[47], NULL },
4583 { NULL },
4584 },
4585 },
4586 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4587
4588 .num_adapters = 1,
4589 .adapter = {
4590 {
4591 DIB0700_NUM_FRONTENDS(1),
4592 .fe = {{
4593 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4594 .pid_filter_count = 32,
4595 .pid_filter = stk70x0p_pid_filter,
4596 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4597 .frontend_attach = stk7770p_frontend_attach,
4598 .tuner_attach = dib7770p_tuner_attach,
4599
4600 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4601 }},
4602 },
4603 },
4604
4605 .num_device_descs = 4,
4606 .devices = {
4607 { "DiBcom STK7770P reference design",
4608 { &dib0700_usb_id_table[59], NULL },
4609 { NULL },
4610 },
4611 { "Terratec Cinergy T USB XXS (HD)/ T3",
4612 { &dib0700_usb_id_table[33],
4613 &dib0700_usb_id_table[52],
4614 &dib0700_usb_id_table[60], NULL},
4615 { NULL },
4616 },
4617 { "TechniSat AirStar TeleStick 2",
4618 { &dib0700_usb_id_table[74], NULL },
4619 { NULL },
4620 },
4621 { "Medion CTX1921 DVB-T USB",
4622 { &dib0700_usb_id_table[75], NULL },
4623 { NULL },
4624 },
4625 },
4626
4627 .rc.core = {
4628 .rc_interval = DEFAULT_RC_INTERVAL,
4629 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4630 .module_name = "dib0700",
4631 .rc_query = dib0700_rc_query_old_firmware,
4632 .allowed_protos = RC_PROTO_BIT_RC5 |
4633 RC_PROTO_BIT_RC6_MCE |
4634 RC_PROTO_BIT_NEC,
4635 .change_protocol = dib0700_change_protocol,
4636 },
4637 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4638 .num_adapters = 1,
4639 .adapter = {
4640 {
4641 DIB0700_NUM_FRONTENDS(1),
4642 .fe = {{
4643 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4644 .pid_filter_count = 32,
4645 .pid_filter = stk80xx_pid_filter,
4646 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4647 .frontend_attach = stk807x_frontend_attach,
4648 .tuner_attach = dib807x_tuner_attach,
4649
4650 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4651 }},
4652 },
4653 },
4654
4655 .num_device_descs = 3,
4656 .devices = {
4657 { "DiBcom STK807xP reference design",
4658 { &dib0700_usb_id_table[62], NULL },
4659 { NULL },
4660 },
4661 { "Prolink Pixelview SBTVD",
4662 { &dib0700_usb_id_table[63], NULL },
4663 { NULL },
4664 },
4665 { "EvolutePC TVWay+",
4666 { &dib0700_usb_id_table[64], NULL },
4667 { NULL },
4668 },
4669 },
4670
4671 .rc.core = {
4672 .rc_interval = DEFAULT_RC_INTERVAL,
4673 .rc_codes = RC_MAP_DIB0700_NEC_TABLE,
4674 .module_name = "dib0700",
4675 .rc_query = dib0700_rc_query_old_firmware,
4676 .allowed_protos = RC_PROTO_BIT_RC5 |
4677 RC_PROTO_BIT_RC6_MCE |
4678 RC_PROTO_BIT_NEC,
4679 .change_protocol = dib0700_change_protocol,
4680 },
4681 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4682 .num_adapters = 2,
4683 .adapter = {
4684 {
4685 DIB0700_NUM_FRONTENDS(1),
4686 .fe = {{
4687 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4688 .pid_filter_count = 32,
4689 .pid_filter = stk80xx_pid_filter,
4690 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4691 .frontend_attach = stk807xpvr_frontend_attach0,
4692 .tuner_attach = dib807x_tuner_attach,
4693
4694 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4695 }},
4696 },
4697 {
4698 DIB0700_NUM_FRONTENDS(1),
4699 .fe = {{
4700 .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4701 .pid_filter_count = 32,
4702 .pid_filter = stk80xx_pid_filter,
4703 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4704 .frontend_attach = stk807xpvr_frontend_attach1,
4705 .tuner_attach = dib807x_tuner_attach,
4706
4707 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4708 }},
4709 },
4710 },
4711
4712 .num_device_descs = 1,
4713 .devices = {
4714 { "DiBcom STK807xPVR reference design",
4715 { &dib0700_usb_id_table[61], NULL },
4716 { NULL },
4717 },
4718 },
4719
4720 .rc.core = {
4721 .rc_interval = DEFAULT_RC_INTERVAL,
4722 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4723 .module_name = "dib0700",
4724 .rc_query = dib0700_rc_query_old_firmware,
4725 .allowed_protos = RC_PROTO_BIT_RC5 |
4726 RC_PROTO_BIT_RC6_MCE |
4727 RC_PROTO_BIT_NEC,
4728 .change_protocol = dib0700_change_protocol,
4729 },
4730 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4731 .num_adapters = 1,
4732 .adapter = {
4733 {
4734 DIB0700_NUM_FRONTENDS(1),
4735 .fe = {{
4736 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4737 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4738 .pid_filter_count = 32,
4739 .pid_filter = stk80xx_pid_filter,
4740 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4741 .frontend_attach = stk809x_frontend_attach,
4742 .tuner_attach = dib809x_tuner_attach,
4743
4744 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4745 }},
4746 },
4747 },
4748
4749 .num_device_descs = 1,
4750 .devices = {
4751 { "DiBcom STK8096GP reference design",
4752 { &dib0700_usb_id_table[67], NULL },
4753 { NULL },
4754 },
4755 },
4756
4757 .rc.core = {
4758 .rc_interval = DEFAULT_RC_INTERVAL,
4759 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4760 .module_name = "dib0700",
4761 .rc_query = dib0700_rc_query_old_firmware,
4762 .allowed_protos = RC_PROTO_BIT_RC5 |
4763 RC_PROTO_BIT_RC6_MCE |
4764 RC_PROTO_BIT_NEC,
4765 .change_protocol = dib0700_change_protocol,
4766 },
4767 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4768 .num_adapters = 1,
4769 .adapter = {
4770 {
4771 DIB0700_NUM_FRONTENDS(1),
4772 .fe = {{
4773 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4774 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4775 .pid_filter_count = 32,
4776 .pid_filter = dib90x0_pid_filter,
4777 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4778 .frontend_attach = stk9090m_frontend_attach,
4779 .tuner_attach = dib9090_tuner_attach,
4780
4781 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4782 }},
4783 },
4784 },
4785
4786 .num_device_descs = 1,
4787 .devices = {
4788 { "DiBcom STK9090M reference design",
4789 { &dib0700_usb_id_table[69], NULL },
4790 { NULL },
4791 },
4792 },
4793
4794 .rc.core = {
4795 .rc_interval = DEFAULT_RC_INTERVAL,
4796 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4797 .module_name = "dib0700",
4798 .rc_query = dib0700_rc_query_old_firmware,
4799 .allowed_protos = RC_PROTO_BIT_RC5 |
4800 RC_PROTO_BIT_RC6_MCE |
4801 RC_PROTO_BIT_NEC,
4802 .change_protocol = dib0700_change_protocol,
4803 },
4804 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4805 .num_adapters = 1,
4806 .adapter = {
4807 {
4808 DIB0700_NUM_FRONTENDS(1),
4809 .fe = {{
4810 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4811 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4812 .pid_filter_count = 32,
4813 .pid_filter = stk80xx_pid_filter,
4814 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4815 .frontend_attach = nim8096md_frontend_attach,
4816 .tuner_attach = nim8096md_tuner_attach,
4817
4818 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4819 }},
4820 },
4821 },
4822
4823 .num_device_descs = 1,
4824 .devices = {
4825 { "DiBcom NIM8096MD reference design",
4826 { &dib0700_usb_id_table[70], NULL },
4827 { NULL },
4828 },
4829 },
4830
4831 .rc.core = {
4832 .rc_interval = DEFAULT_RC_INTERVAL,
4833 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4834 .module_name = "dib0700",
4835 .rc_query = dib0700_rc_query_old_firmware,
4836 .allowed_protos = RC_PROTO_BIT_RC5 |
4837 RC_PROTO_BIT_RC6_MCE |
4838 RC_PROTO_BIT_NEC,
4839 .change_protocol = dib0700_change_protocol,
4840 },
4841 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4842 .num_adapters = 1,
4843 .adapter = {
4844 {
4845 DIB0700_NUM_FRONTENDS(1),
4846 .fe = {{
4847 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4848 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4849 .pid_filter_count = 32,
4850 .pid_filter = dib90x0_pid_filter,
4851 .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4852 .frontend_attach = nim9090md_frontend_attach,
4853 .tuner_attach = nim9090md_tuner_attach,
4854
4855 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4856 }},
4857 },
4858 },
4859
4860 .num_device_descs = 1,
4861 .devices = {
4862 { "DiBcom NIM9090MD reference design",
4863 { &dib0700_usb_id_table[71], NULL },
4864 { NULL },
4865 },
4866 },
4867
4868 .rc.core = {
4869 .rc_interval = DEFAULT_RC_INTERVAL,
4870 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4871 .module_name = "dib0700",
4872 .rc_query = dib0700_rc_query_old_firmware,
4873 .allowed_protos = RC_PROTO_BIT_RC5 |
4874 RC_PROTO_BIT_RC6_MCE |
4875 RC_PROTO_BIT_NEC,
4876 .change_protocol = dib0700_change_protocol,
4877 },
4878 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4879 .num_adapters = 1,
4880 .adapter = {
4881 {
4882 DIB0700_NUM_FRONTENDS(1),
4883 .fe = {{
4884 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4885 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4886 .pid_filter_count = 32,
4887 .pid_filter = stk70x0p_pid_filter,
4888 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4889 .frontend_attach = nim7090_frontend_attach,
4890 .tuner_attach = nim7090_tuner_attach,
4891
4892 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4893 }},
4894 },
4895 },
4896
4897 .num_device_descs = 1,
4898 .devices = {
4899 { "DiBcom NIM7090 reference design",
4900 { &dib0700_usb_id_table[72], NULL },
4901 { NULL },
4902 },
4903 },
4904
4905 .rc.core = {
4906 .rc_interval = DEFAULT_RC_INTERVAL,
4907 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4908 .module_name = "dib0700",
4909 .rc_query = dib0700_rc_query_old_firmware,
4910 .allowed_protos = RC_PROTO_BIT_RC5 |
4911 RC_PROTO_BIT_RC6_MCE |
4912 RC_PROTO_BIT_NEC,
4913 .change_protocol = dib0700_change_protocol,
4914 },
4915 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4916 .num_adapters = 2,
4917 .adapter = {
4918 {
4919 DIB0700_NUM_FRONTENDS(1),
4920 .fe = {{
4921 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4922 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4923 .pid_filter_count = 32,
4924 .pid_filter = stk70x0p_pid_filter,
4925 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4926 .frontend_attach = tfe7090pvr_frontend0_attach,
4927 .tuner_attach = tfe7090pvr_tuner0_attach,
4928
4929 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4930 }},
4931 },
4932 {
4933 DIB0700_NUM_FRONTENDS(1),
4934 .fe = {{
4935 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
4936 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4937 .pid_filter_count = 32,
4938 .pid_filter = stk70x0p_pid_filter,
4939 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4940 .frontend_attach = tfe7090pvr_frontend1_attach,
4941 .tuner_attach = tfe7090pvr_tuner1_attach,
4942
4943 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4944 }},
4945 },
4946 },
4947
4948 .num_device_descs = 1,
4949 .devices = {
4950 { "DiBcom TFE7090PVR reference design",
4951 { &dib0700_usb_id_table[73], NULL },
4952 { NULL },
4953 },
4954 },
4955
4956 .rc.core = {
4957 .rc_interval = DEFAULT_RC_INTERVAL,
4958 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4959 .module_name = "dib0700",
4960 .rc_query = dib0700_rc_query_old_firmware,
4961 .allowed_protos = RC_PROTO_BIT_RC5 |
4962 RC_PROTO_BIT_RC6_MCE |
4963 RC_PROTO_BIT_NEC,
4964 .change_protocol = dib0700_change_protocol,
4965 },
4966 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4967 .num_adapters = 1,
4968 .adapter = {
4969 {
4970 DIB0700_NUM_FRONTENDS(1),
4971 .fe = {{
4972 .frontend_attach = pctv340e_frontend_attach,
4973 .tuner_attach = xc4000_tuner_attach,
4974
4975 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4976 }},
4977 },
4978 },
4979
4980 .num_device_descs = 2,
4981 .devices = {
4982 { "Pinnacle PCTV 340e HD Pro USB Stick",
4983 { &dib0700_usb_id_table[76], NULL },
4984 { NULL },
4985 },
4986 { "Pinnacle PCTV Hybrid Stick Solo",
4987 { &dib0700_usb_id_table[77], NULL },
4988 { NULL },
4989 },
4990 },
4991 .rc.core = {
4992 .rc_interval = DEFAULT_RC_INTERVAL,
4993 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
4994 .module_name = "dib0700",
4995 .rc_query = dib0700_rc_query_old_firmware,
4996 .allowed_protos = RC_PROTO_BIT_RC5 |
4997 RC_PROTO_BIT_RC6_MCE |
4998 RC_PROTO_BIT_NEC,
4999 .change_protocol = dib0700_change_protocol,
5000 },
5001 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5002 .num_adapters = 1,
5003 .adapter = {
5004 {
5005 DIB0700_NUM_FRONTENDS(1),
5006 .fe = {{
5007 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
5008 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5009 .pid_filter_count = 32,
5010 .pid_filter = stk70x0p_pid_filter,
5011 .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5012 .frontend_attach = tfe7790p_frontend_attach,
5013 .tuner_attach = tfe7790p_tuner_attach,
5014
5015 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5016 } },
5017 },
5018 },
5019
5020 .num_device_descs = 1,
5021 .devices = {
5022 { "DiBcom TFE7790P reference design",
5023 { &dib0700_usb_id_table[78], NULL },
5024 { NULL },
5025 },
5026 },
5027
5028 .rc.core = {
5029 .rc_interval = DEFAULT_RC_INTERVAL,
5030 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
5031 .module_name = "dib0700",
5032 .rc_query = dib0700_rc_query_old_firmware,
5033 .allowed_protos = RC_PROTO_BIT_RC5 |
5034 RC_PROTO_BIT_RC6_MCE |
5035 RC_PROTO_BIT_NEC,
5036 .change_protocol = dib0700_change_protocol,
5037 },
5038 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5039 .num_adapters = 1,
5040 .adapter = {
5041 {
5042 DIB0700_NUM_FRONTENDS(1),
5043 .fe = {{
5044 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
5045 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5046 .pid_filter_count = 32,
5047 .pid_filter = stk80xx_pid_filter,
5048 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5049 .frontend_attach = tfe8096p_frontend_attach,
5050 .tuner_attach = tfe8096p_tuner_attach,
5051
5052 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5053
5054 } },
5055 },
5056 },
5057
5058 .num_device_descs = 1,
5059 .devices = {
5060 { "DiBcom TFE8096P reference design",
5061 { &dib0700_usb_id_table[79], NULL },
5062 { NULL },
5063 },
5064 },
5065
5066 .rc.core = {
5067 .rc_interval = DEFAULT_RC_INTERVAL,
5068 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
5069 .module_name = "dib0700",
5070 .rc_query = dib0700_rc_query_old_firmware,
5071 .allowed_protos = RC_PROTO_BIT_RC5 |
5072 RC_PROTO_BIT_RC6_MCE |
5073 RC_PROTO_BIT_NEC,
5074 .change_protocol = dib0700_change_protocol,
5075 },
5076 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5077 .num_adapters = 2,
5078 .adapter = {
5079 {
5080 .num_frontends = 1,
5081 .fe = {{
5082 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
5083 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5084 .pid_filter_count = 32,
5085 .pid_filter = stk80xx_pid_filter,
5086 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5087 .frontend_attach = stk809x_frontend_attach,
5088 .tuner_attach = dib809x_tuner_attach,
5089
5090 DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5091 } },
5092 .size_of_priv =
5093 sizeof(struct dib0700_adapter_state),
5094 }, {
5095 .num_frontends = 1,
5096 .fe = { {
5097 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
5098 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5099 .pid_filter_count = 32,
5100 .pid_filter = stk80xx_pid_filter,
5101 .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5102 .frontend_attach = stk809x_frontend1_attach,
5103 .tuner_attach = dib809x_tuner_attach,
5104
5105 DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5106 } },
5107 .size_of_priv =
5108 sizeof(struct dib0700_adapter_state),
5109 },
5110 },
5111 .num_device_descs = 1,
5112 .devices = {
5113 { "DiBcom STK8096-PVR reference design",
5114 { &dib0700_usb_id_table[83],
5115 &dib0700_usb_id_table[84], NULL},
5116 { NULL },
5117 },
5118 },
5119
5120 .rc.core = {
5121 .rc_interval = DEFAULT_RC_INTERVAL,
5122 .rc_codes = RC_MAP_DIB0700_RC5_TABLE,
5123 .module_name = "dib0700",
5124 .rc_query = dib0700_rc_query_old_firmware,
5125 .allowed_protos = RC_PROTO_BIT_RC5 |
5126 RC_PROTO_BIT_RC6_MCE |
5127 RC_PROTO_BIT_NEC,
5128 .change_protocol = dib0700_change_protocol,
5129 },
5130 }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5131 .num_adapters = 1,
5132 .adapter = {
5133 {
5134 DIB0700_NUM_FRONTENDS(1),
5135 .fe = {{
5136 .frontend_attach = xbox_one_attach,
5137
5138 DIB0700_DEFAULT_STREAMING_CONFIG(0x82),
5139 } },
5140 },
5141 },
5142 .num_device_descs = 1,
5143 .devices = {
5144 { "Microsoft Xbox One Digital TV Tuner",
5145 { &dib0700_usb_id_table[86], NULL },
5146 { NULL },
5147 },
5148 },
5149 },
5150};
5151
5152int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
5153