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