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