xref: /linux/drivers/media/usb/dvb-usb/dib0700_devices.c (revision 6fd600d742744dc7ef7fc65ca26daa2b1163158a)
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 "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 
bristol_frontend_attach(struct dvb_usb_adapter * adap)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 
eeprom_read(struct i2c_adapter * adap,u8 adrs,u8 * pval)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 
bristol_tuner_attach(struct dvb_usb_adapter * adap)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 
stk7700P2_frontend_attach(struct dvb_usb_adapter * adap)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 
stk7700d_frontend_attach(struct dvb_usb_adapter * adap)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 
stk7700d_tuner_attach(struct dvb_usb_adapter * adap)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 
stk7700ph_xc3028_callback(void * ptr,int component,int command,int arg)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 
stk7700ph_frontend_attach(struct dvb_usb_adapter * adap)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 
stk7700ph_tuner_attach(struct dvb_usb_adapter * adap)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  */
dib0700_rc_query_old_firmware(struct dvb_usb_device * d)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 
stk7700p_frontend_attach(struct dvb_usb_adapter * adap)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 
stk7700p_tuner_attach(struct dvb_usb_adapter * adap)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 
dib7070_tuner_reset(struct dvb_frontend * fe,int onoff)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 
dib7070_tuner_sleep(struct dvb_frontend * fe,int onoff)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 
dib7070_set_param_override(struct dvb_frontend * fe)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 
dib7770_set_param_override(struct dvb_frontend * fe)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 
dib7770p_tuner_attach(struct dvb_usb_adapter * adap)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 
dib7070p_tuner_attach(struct dvb_usb_adapter * adap)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 
stk7700p_pid_filter(struct dvb_usb_adapter * adapter,int index,u16 pid,int onoff)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 
stk7700p_pid_filter_ctrl(struct dvb_usb_adapter * adapter,int onoff)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 
stk70x0p_pid_filter(struct dvb_usb_adapter * adapter,int index,u16 pid,int onoff)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 
stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter * adapter,int onoff)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 */
stk7070p_frontend_attach(struct dvb_usb_adapter * adap)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 
stk7770p_frontend_attach(struct dvb_usb_adapter * adap)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 
dib80xx_tuner_reset(struct dvb_frontend * fe,int onoff)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 
dib80xx_tuner_sleep(struct dvb_frontend * fe,int onoff)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 
dib807x_set_param_override(struct dvb_frontend * fe)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 
dib807x_tuner_attach(struct dvb_usb_adapter * adap)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 
stk80xx_pid_filter(struct dvb_usb_adapter * adapter,int index,u16 pid,int onoff)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 
stk80xx_pid_filter_ctrl(struct dvb_usb_adapter * adapter,int onoff)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 */
stk807x_frontend_attach(struct dvb_usb_adapter * adap)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 */
stk807xpvr_frontend_attach0(struct dvb_usb_adapter * adap)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 
stk807xpvr_frontend_attach1(struct dvb_usb_adapter * adap)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 
dib8090_get_adc_power(struct dvb_frontend * fe)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 
dib8090_agc_control(struct dvb_frontend * fe,u8 restart)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 
dib8090_compute_pll_parameters(struct dvb_frontend * fe)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 
dib8096_set_param_override(struct dvb_frontend * fe)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 
dib809x_tuner_attach(struct dvb_usb_adapter * adap)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 
stk809x_frontend_attach(struct dvb_usb_adapter * adap)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 
stk809x_frontend1_attach(struct dvb_usb_adapter * adap)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 
nim8096md_tuner_attach(struct dvb_usb_adapter * adap)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 
nim8096md_frontend_attach(struct dvb_usb_adapter * adap)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_best_adc {
2028 	u32 timf;
2029 	u32 pll_loopdiv;
2030 	u32 pll_prediv;
2031 };
2032 
dib8096p_get_best_sampling(struct dvb_frontend * fe,struct dibx090p_best_adc * adc)2033 static int dib8096p_get_best_sampling(struct dvb_frontend *fe, struct dibx090p_best_adc *adc)
2034 {
2035 	u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2036 	u16 xtal = 12000;
2037 	u16 fcp_min = 1900;  /* PLL, Minimum Frequency of phase comparator (KHz) */
2038 	u16 fcp_max = 20000; /* PLL, Maximum Frequency of phase comparator (KHz) */
2039 	u32 fmem_max = 140000; /* 140MHz max SDRAM freq */
2040 	u32 fdem_min = 66000;
2041 	u32 fcp = 0, fs = 0, fdem = 0, fmem = 0;
2042 	u32 harmonic_id = 0;
2043 
2044 	adc->timf = 0;
2045 	adc->pll_loopdiv = loopdiv;
2046 	adc->pll_prediv = prediv;
2047 
2048 	deb_info("bandwidth = %d", fe->dtv_property_cache.bandwidth_hz);
2049 
2050 	/* Find Min and Max prediv */
2051 	while ((xtal / max_prediv) >= fcp_min)
2052 		max_prediv++;
2053 
2054 	max_prediv--;
2055 	min_prediv = max_prediv;
2056 	while ((xtal / min_prediv) <= fcp_max) {
2057 		min_prediv--;
2058 		if (min_prediv == 1)
2059 			break;
2060 	}
2061 	deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2062 
2063 	min_prediv = 1;
2064 
2065 	for (prediv = min_prediv; prediv < max_prediv; prediv++) {
2066 		fcp = xtal / prediv;
2067 		if (fcp > fcp_min && fcp < fcp_max) {
2068 			for (loopdiv = 1; loopdiv < 64; loopdiv++) {
2069 				fmem = ((xtal/prediv) * loopdiv);
2070 				fdem = fmem / 2;
2071 				fs   = fdem / 4;
2072 
2073 				/* test min/max system restrictions */
2074 				if ((fdem >= fdem_min) && (fmem <= fmem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz / 1000)) {
2075 					spur = 0;
2076 					/* test fs harmonics positions */
2077 					for (harmonic_id = (fe->dtv_property_cache.frequency / (1000 * fs));  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000 * fs)) + 1); harmonic_id++) {
2078 						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)))) {
2079 							spur = 1;
2080 							break;
2081 						}
2082 					}
2083 
2084 					if (!spur) {
2085 						adc->pll_loopdiv = loopdiv;
2086 						adc->pll_prediv = prediv;
2087 						adc->timf = (4260880253U / fdem) * (1 << 8);
2088 						adc->timf += ((4260880253U % fdem) << 8) / fdem;
2089 
2090 						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);
2091 						break;
2092 					}
2093 				}
2094 			}
2095 		}
2096 		if (!spur)
2097 			break;
2098 	}
2099 
2100 	if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2101 		return -EINVAL;
2102 	return 0;
2103 }
2104 
dib8096p_agc_startup(struct dvb_frontend * fe)2105 static int dib8096p_agc_startup(struct dvb_frontend *fe)
2106 {
2107 	struct dvb_usb_adapter *adap = fe->dvb->priv;
2108 	struct dib0700_adapter_state *state = adap->priv;
2109 	struct dibx000_bandwidth_config pll;
2110 	struct dibx090p_best_adc adc;
2111 	u16 target;
2112 	int ret;
2113 
2114 	ret = state->set_param_save(fe);
2115 	if (ret < 0)
2116 		return ret;
2117 	memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2118 
2119 	dib0090_pwm_gain_reset(fe);
2120 	/* dib0090_get_wbd_target is returning any possible
2121 	   temperature compensated wbd-target */
2122 	target = (dib0090_get_wbd_target(fe) * 8  + 1) / 2;
2123 	state->dib8000_ops.set_wbd_ref(fe, target);
2124 
2125 	if (dib8096p_get_best_sampling(fe, &adc) == 0) {
2126 		pll.pll_ratio  = adc.pll_loopdiv;
2127 		pll.pll_prediv = adc.pll_prediv;
2128 
2129 		dib0700_set_i2c_speed(adap->dev, 200);
2130 		state->dib8000_ops.update_pll(fe, &pll, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
2131 		state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2132 		dib0700_set_i2c_speed(adap->dev, 1000);
2133 	}
2134 	return 0;
2135 }
2136 
tfe8096p_frontend_attach(struct dvb_usb_adapter * adap)2137 static int tfe8096p_frontend_attach(struct dvb_usb_adapter *adap)
2138 {
2139 	struct dib0700_state *st = adap->dev->priv;
2140 	u32 fw_version;
2141 	struct dib0700_adapter_state *state = adap->priv;
2142 
2143 	if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
2144 		return -ENODEV;
2145 
2146 	dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2147 	if (fw_version >= 0x10200)
2148 		st->fw_use_new_i2c_api = 1;
2149 
2150 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2151 	msleep(20);
2152 	dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2153 	dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2154 	dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2155 
2156 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2157 
2158 	dib0700_ctrl_clock(adap->dev, 72, 1);
2159 
2160 	msleep(20);
2161 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2162 	msleep(20);
2163 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2164 
2165 	state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80, 1);
2166 
2167 	adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap,
2168 					     0x80, &tfe8096p_dib8000_config);
2169 
2170 	return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
2171 }
2172 
tfe8096p_tuner_attach(struct dvb_usb_adapter * adap)2173 static int tfe8096p_tuner_attach(struct dvb_usb_adapter *adap)
2174 {
2175 	struct dib0700_adapter_state *st = adap->priv;
2176 	struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_tuner(adap->fe_adap[0].fe);
2177 
2178 	tfe8096p_dib0090_config.reset = st->dib8000_ops.tuner_sleep;
2179 	tfe8096p_dib0090_config.sleep = st->dib8000_ops.tuner_sleep;
2180 	tfe8096p_dib0090_config.wbd = dib8096p_wbd_table;
2181 
2182 	if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
2183 				&tfe8096p_dib0090_config) == NULL)
2184 		return -ENODEV;
2185 
2186 	st->dib8000_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
2187 
2188 	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
2189 	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096p_agc_startup;
2190 	return 0;
2191 }
2192 
2193 /* STK9090M */
dib90x0_pid_filter(struct dvb_usb_adapter * adapter,int index,u16 pid,int onoff)2194 static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2195 {
2196 	return dib9000_fw_pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
2197 }
2198 
dib90x0_pid_filter_ctrl(struct dvb_usb_adapter * adapter,int onoff)2199 static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2200 {
2201 	return dib9000_fw_pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
2202 }
2203 
dib90x0_tuner_reset(struct dvb_frontend * fe,int onoff)2204 static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2205 {
2206 	return dib9000_set_gpio(fe, 5, 0, !onoff);
2207 }
2208 
dib90x0_tuner_sleep(struct dvb_frontend * fe,int onoff)2209 static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2210 {
2211 	return dib9000_set_gpio(fe, 0, 0, onoff);
2212 }
2213 
dib01x0_pmu_update(struct i2c_adapter * i2c,u16 * data,u8 len)2214 static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
2215 {
2216 	u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
2217 	u8 rb[2];
2218 	struct i2c_msg msg[2] = {
2219 		{.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
2220 		{.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
2221 	};
2222 	u8 index_data;
2223 
2224 	dibx000_i2c_set_speed(i2c, 250);
2225 
2226 	if (i2c_transfer(i2c, msg, 2) != 2)
2227 		return -EIO;
2228 
2229 	switch (rb[0] << 8 | rb[1]) {
2230 	case 0:
2231 			deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
2232 			return -EIO;
2233 	case 1:
2234 			deb_info("Found DiB0170 rev2");
2235 			break;
2236 	case 2:
2237 			deb_info("Found DiB0190 rev2");
2238 			break;
2239 	default:
2240 			deb_info("DiB01x0 not found");
2241 			return -EIO;
2242 	}
2243 
2244 	for (index_data = 0; index_data < len; index_data += 2) {
2245 		wb[2] = (data[index_data + 1] >> 8) & 0xff;
2246 		wb[3] = (data[index_data + 1]) & 0xff;
2247 
2248 		if (data[index_data] == 0) {
2249 			wb[0] = (data[index_data] >> 8) & 0xff;
2250 			wb[1] = (data[index_data]) & 0xff;
2251 			msg[0].len = 2;
2252 			if (i2c_transfer(i2c, msg, 2) != 2)
2253 				return -EIO;
2254 			wb[2] |= rb[0];
2255 			wb[3] |= rb[1] & ~(3 << 4);
2256 		}
2257 
2258 		wb[0] = (data[index_data] >> 8)&0xff;
2259 		wb[1] = (data[index_data])&0xff;
2260 		msg[0].len = 4;
2261 		if (i2c_transfer(i2c, &msg[0], 1) != 1)
2262 			return -EIO;
2263 	}
2264 	return 0;
2265 }
2266 
2267 static struct dib9000_config stk9090m_config = {
2268 	.output_mpeg2_in_188_bytes = 1,
2269 	.output_mode = OUTMODE_MPEG2_FIFO,
2270 	.vcxo_timer = 279620,
2271 	.timing_frequency = 20452225,
2272 	.demod_clock_khz = 60000,
2273 	.xtal_clock_khz = 30000,
2274 	.if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2275 	.subband = {
2276 		2,
2277 		{
2278 			{ 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
2279 			{ 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
2280 			{ 0 },
2281 		},
2282 	},
2283 	.gpio_function = {
2284 		{ .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2285 		{ .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2286 	},
2287 };
2288 
2289 static struct dib9000_config nim9090md_config[2] = {
2290 	{
2291 		.output_mpeg2_in_188_bytes = 1,
2292 		.output_mode = OUTMODE_MPEG2_FIFO,
2293 		.vcxo_timer = 279620,
2294 		.timing_frequency = 20452225,
2295 		.demod_clock_khz = 60000,
2296 		.xtal_clock_khz = 30000,
2297 		.if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2298 	}, {
2299 		.output_mpeg2_in_188_bytes = 1,
2300 		.output_mode = OUTMODE_DIVERSITY,
2301 		.vcxo_timer = 279620,
2302 		.timing_frequency = 20452225,
2303 		.demod_clock_khz = 60000,
2304 		.xtal_clock_khz = 30000,
2305 		.if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
2306 		.subband = {
2307 			2,
2308 			{
2309 				{ 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
2310 				{ 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
2311 				{ 0 },
2312 			},
2313 		},
2314 		.gpio_function = {
2315 			{ .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
2316 			{ .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
2317 		},
2318 	}
2319 };
2320 
2321 static struct dib0090_config dib9090_dib0090_config = {
2322 	.io.pll_bypass = 0,
2323 	.io.pll_range = 1,
2324 	.io.pll_prediv = 1,
2325 	.io.pll_loopdiv = 8,
2326 	.io.adc_clock_ratio = 8,
2327 	.io.pll_int_loop_filt = 0,
2328 	.io.clock_khz = 30000,
2329 	.reset = dib90x0_tuner_reset,
2330 	.sleep = dib90x0_tuner_sleep,
2331 	.clkouttobamse = 0,
2332 	.analog_output = 0,
2333 	.use_pwm_agc = 0,
2334 	.clkoutdrive = 0,
2335 	.freq_offset_khz_uhf = 0,
2336 	.freq_offset_khz_vhf = 0,
2337 };
2338 
2339 static struct dib0090_config nim9090md_dib0090_config[2] = {
2340 	{
2341 		.io.pll_bypass = 0,
2342 		.io.pll_range = 1,
2343 		.io.pll_prediv = 1,
2344 		.io.pll_loopdiv = 8,
2345 		.io.adc_clock_ratio = 8,
2346 		.io.pll_int_loop_filt = 0,
2347 		.io.clock_khz = 30000,
2348 		.reset = dib90x0_tuner_reset,
2349 		.sleep = dib90x0_tuner_sleep,
2350 		.clkouttobamse = 1,
2351 		.analog_output = 0,
2352 		.use_pwm_agc = 0,
2353 		.clkoutdrive = 0,
2354 		.freq_offset_khz_uhf = 0,
2355 		.freq_offset_khz_vhf = 0,
2356 	}, {
2357 		.io.pll_bypass = 0,
2358 		.io.pll_range = 1,
2359 		.io.pll_prediv = 1,
2360 		.io.pll_loopdiv = 8,
2361 		.io.adc_clock_ratio = 8,
2362 		.io.pll_int_loop_filt = 0,
2363 		.io.clock_khz = 30000,
2364 		.reset = dib90x0_tuner_reset,
2365 		.sleep = dib90x0_tuner_sleep,
2366 		.clkouttobamse = 0,
2367 		.analog_output = 0,
2368 		.use_pwm_agc = 0,
2369 		.clkoutdrive = 0,
2370 		.freq_offset_khz_uhf = 0,
2371 		.freq_offset_khz_vhf = 0,
2372 	}
2373 };
2374 
2375 
stk9090m_frontend_attach(struct dvb_usb_adapter * adap)2376 static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
2377 {
2378 	struct dib0700_adapter_state *state = adap->priv;
2379 	struct dib0700_state *st = adap->dev->priv;
2380 	u32 fw_version;
2381 
2382 	/* Make use of the new i2c functions from FW 1.20 */
2383 	dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2384 	if (fw_version >= 0x10200)
2385 		st->fw_use_new_i2c_api = 1;
2386 	dib0700_set_i2c_speed(adap->dev, 340);
2387 
2388 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2389 	msleep(20);
2390 	dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2391 	dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2392 	dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2393 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2394 
2395 	dib0700_ctrl_clock(adap->dev, 72, 1);
2396 
2397 	msleep(20);
2398 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2399 	msleep(20);
2400 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2401 
2402 	dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
2403 
2404 	if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2405 		deb_info("%s: Upload failed. (file not found?)\n", __func__);
2406 		return -ENODEV;
2407 	} else {
2408 		deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2409 	}
2410 	stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
2411 	stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
2412 
2413 	adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
2414 
2415 	if (!adap->fe_adap[0].fe) {
2416 		release_firmware(state->frontend_firmware);
2417 		return -ENODEV;
2418 	}
2419 
2420 	return 0;
2421 }
2422 
dib9090_tuner_attach(struct dvb_usb_adapter * adap)2423 static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
2424 {
2425 	struct dib0700_adapter_state *state = adap->priv;
2426 	struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2427 	u16 data_dib190[10] = {
2428 		1, 0x1374,
2429 		2, 0x01a2,
2430 		7, 0x0020,
2431 		0, 0x00ef,
2432 		8, 0x0486,
2433 	};
2434 
2435 	if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2436 		return -ENODEV;
2437 	if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
2438 		return -ENODEV;
2439 	i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2440 	if (!i2c)
2441 		return -ENODEV;
2442 	if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
2443 		return -ENODEV;
2444 	dib0700_set_i2c_speed(adap->dev, 1500);
2445 	if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2446 		return -ENODEV;
2447 	release_firmware(state->frontend_firmware);
2448 	return 0;
2449 }
2450 
nim9090md_frontend_attach(struct dvb_usb_adapter * adap)2451 static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
2452 {
2453 	struct dib0700_adapter_state *state = adap->priv;
2454 	struct dib0700_state *st = adap->dev->priv;
2455 	struct i2c_adapter *i2c;
2456 	struct dvb_frontend *fe_slave;
2457 	u32 fw_version;
2458 
2459 	/* Make use of the new i2c functions from FW 1.20 */
2460 	dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
2461 	if (fw_version >= 0x10200)
2462 		st->fw_use_new_i2c_api = 1;
2463 	dib0700_set_i2c_speed(adap->dev, 340);
2464 
2465 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
2466 	msleep(20);
2467 	dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
2468 	dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
2469 	dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
2470 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
2471 
2472 	dib0700_ctrl_clock(adap->dev, 72, 1);
2473 
2474 	msleep(20);
2475 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
2476 	msleep(20);
2477 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
2478 
2479 	if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
2480 		deb_info("%s: Upload failed. (file not found?)\n", __func__);
2481 		return -EIO;
2482 	} else {
2483 		deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
2484 	}
2485 	nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
2486 	nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
2487 	nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
2488 	nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
2489 
2490 	dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
2491 	adap->fe_adap[0].fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
2492 
2493 	if (!adap->fe_adap[0].fe) {
2494 		release_firmware(state->frontend_firmware);
2495 		return -ENODEV;
2496 	}
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 	if (!fe_slave) {
2505 		release_firmware(state->frontend_firmware);
2506 		return -ENODEV;
2507 	}
2508 
2509 	return 0;
2510 }
2511 
nim9090md_tuner_attach(struct dvb_usb_adapter * adap)2512 static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
2513 {
2514 	struct dib0700_adapter_state *state = adap->priv;
2515 	struct i2c_adapter *i2c;
2516 	struct dvb_frontend *fe_slave;
2517 	u16 data_dib190[10] = {
2518 		1, 0x5374,
2519 		2, 0x01ae,
2520 		7, 0x0020,
2521 		0, 0x00ef,
2522 		8, 0x0406,
2523 	};
2524 	if (!IS_ENABLED(CONFIG_DVB_DIB9000))
2525 		return -ENODEV;
2526 	i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
2527 	if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
2528 		return -ENODEV;
2529 	i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
2530 	if (!i2c)
2531 		return -ENODEV;
2532 	if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
2533 		return -ENODEV;
2534 
2535 	dib0700_set_i2c_speed(adap->dev, 1500);
2536 	if (dib9000_firmware_post_pll_init(adap->fe_adap[0].fe) < 0)
2537 		return -ENODEV;
2538 
2539 	fe_slave = dib9000_get_slave_frontend(adap->fe_adap[0].fe, 1);
2540 	if (fe_slave != NULL) {
2541 		i2c = dib9000_get_component_bus_interface(adap->fe_adap[0].fe);
2542 		dib9000_set_i2c_adapter(fe_slave, i2c);
2543 
2544 		i2c = dib9000_get_tuner_interface(fe_slave);
2545 		if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
2546 			return -ENODEV;
2547 		fe_slave->dvb = adap->fe_adap[0].fe->dvb;
2548 		dib9000_fw_set_component_bus_speed(adap->fe_adap[0].fe, 1500);
2549 		if (dib9000_firmware_post_pll_init(fe_slave) < 0)
2550 			return -ENODEV;
2551 	}
2552 	release_firmware(state->frontend_firmware);
2553 
2554 	return 0;
2555 }
2556 
2557 /* NIM7090 */
dib7090p_get_best_sampling(struct dvb_frontend * fe,struct dibx090p_best_adc * adc)2558 static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dibx090p_best_adc *adc)
2559 {
2560 	u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
2561 
2562 	u16 xtal = 12000;
2563 	u32 fcp_min = 1900;  /* PLL Minimum Frequency comparator KHz */
2564 	u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
2565 	u32 fdem_max = 76000;
2566 	u32 fdem_min = 69500;
2567 	u32 fcp = 0, fs = 0, fdem = 0;
2568 	u32 harmonic_id = 0;
2569 
2570 	adc->pll_loopdiv = loopdiv;
2571 	adc->pll_prediv = prediv;
2572 	adc->timf = 0;
2573 
2574 	deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
2575 
2576 	/* Find Min and Max prediv */
2577 	while ((xtal/max_prediv) >= fcp_min)
2578 		max_prediv++;
2579 
2580 	max_prediv--;
2581 	min_prediv = max_prediv;
2582 	while ((xtal/min_prediv) <= fcp_max) {
2583 		min_prediv--;
2584 		if (min_prediv == 1)
2585 			break;
2586 	}
2587 	deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
2588 
2589 	min_prediv = 2;
2590 
2591 	for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
2592 		fcp = xtal / prediv;
2593 		if (fcp > fcp_min && fcp < fcp_max) {
2594 			for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
2595 				fdem = ((xtal/prediv) * loopdiv);
2596 				fs   = fdem / 4;
2597 				/* test min/max system restrictions */
2598 
2599 				if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
2600 					spur = 0;
2601 					/* test fs harmonics positions */
2602 					for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ;  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
2603 						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)))) {
2604 							spur = 1;
2605 							break;
2606 						}
2607 					}
2608 
2609 					if (!spur) {
2610 						adc->pll_loopdiv = loopdiv;
2611 						adc->pll_prediv = prediv;
2612 						adc->timf = 2396745143UL/fdem*(1 << 9);
2613 						adc->timf += ((2396745143UL%fdem) << 9)/fdem;
2614 						deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
2615 						break;
2616 					}
2617 				}
2618 			}
2619 		}
2620 		if (!spur)
2621 			break;
2622 	}
2623 
2624 
2625 	if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
2626 		return -EINVAL;
2627 	else
2628 		return 0;
2629 }
2630 
dib7090_agc_startup(struct dvb_frontend * fe)2631 static int dib7090_agc_startup(struct dvb_frontend *fe)
2632 {
2633 	struct dvb_usb_adapter *adap = fe->dvb->priv;
2634 	struct dib0700_adapter_state *state = adap->priv;
2635 	struct dibx000_bandwidth_config pll;
2636 	u16 target;
2637 	struct dibx090p_best_adc adc;
2638 	int ret;
2639 
2640 	ret = state->set_param_save(fe);
2641 	if (ret < 0)
2642 		return ret;
2643 
2644 	memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
2645 	dib0090_pwm_gain_reset(fe);
2646 	target = (dib0090_get_wbd_target(fe) * 8 + 1) / 2;
2647 	state->dib7000p_ops.set_wbd_ref(fe, target);
2648 
2649 	if (dib7090p_get_best_sampling(fe, &adc) == 0) {
2650 		pll.pll_ratio  = adc.pll_loopdiv;
2651 		pll.pll_prediv = adc.pll_prediv;
2652 
2653 		state->dib7000p_ops.update_pll(fe, &pll);
2654 		state->dib7000p_ops.ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
2655 	}
2656 	return 0;
2657 }
2658 
dib7090_agc_restart(struct dvb_frontend * fe,u8 restart)2659 static int dib7090_agc_restart(struct dvb_frontend *fe, u8 restart)
2660 {
2661 	deb_info("AGC restart callback: %d", restart);
2662 	if (restart == 0) /* before AGC startup */
2663 		dib0090_set_dc_servo(fe, 1);
2664 	return 0;
2665 }
2666 
tfe7790p_update_lna(struct dvb_frontend * fe,u16 agc_global)2667 static int tfe7790p_update_lna(struct dvb_frontend *fe, u16 agc_global)
2668 {
2669 	struct dvb_usb_adapter *adap = fe->dvb->priv;
2670 	struct dib0700_adapter_state *state = adap->priv;
2671 
2672 	deb_info("update LNA: agc global=%i", agc_global);
2673 
2674 	if (agc_global < 25000) {
2675 		state->dib7000p_ops.set_gpio(fe, 8, 0, 0);
2676 		state->dib7000p_ops.set_agc1_min(fe, 0);
2677 	} else {
2678 		state->dib7000p_ops.set_gpio(fe, 8, 0, 1);
2679 		state->dib7000p_ops.set_agc1_min(fe, 32768);
2680 	}
2681 
2682 	return 0;
2683 }
2684 
2685 static struct dib0090_wbd_slope dib7090_wbd_table[] = {
2686 	{ 380,   81, 850, 64, 540,  4},
2687 	{ 860,   51, 866, 21,  375, 4},
2688 	{1700,    0, 250, 0,   100, 6},
2689 	{2600,    0, 250, 0,   100, 6},
2690 	{ 0xFFFF, 0,   0, 0,   0,   0},
2691 };
2692 
2693 static struct dibx000_agc_config dib7090_agc_config[2] = {
2694 	{
2695 		.band_caps      = BAND_UHF,
2696 		/* 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,
2697 		* 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 */
2698 		.setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2699 
2700 		.inv_gain       = 687,
2701 		.time_stabiliz  = 10,
2702 
2703 		.alpha_level    = 0,
2704 		.thlock         = 118,
2705 
2706 		.wbd_inv        = 0,
2707 		.wbd_ref        = 1200,
2708 		.wbd_sel        = 3,
2709 		.wbd_alpha      = 5,
2710 
2711 		.agc1_max       = 65535,
2712 		.agc1_min       = 32768,
2713 
2714 		.agc2_max       = 65535,
2715 		.agc2_min       = 0,
2716 
2717 		.agc1_pt1       = 0,
2718 		.agc1_pt2       = 32,
2719 		.agc1_pt3       = 114,
2720 		.agc1_slope1    = 143,
2721 		.agc1_slope2    = 144,
2722 		.agc2_pt1       = 114,
2723 		.agc2_pt2       = 227,
2724 		.agc2_slope1    = 116,
2725 		.agc2_slope2    = 117,
2726 
2727 		.alpha_mant     = 18,
2728 		.alpha_exp      = 0,
2729 		.beta_mant      = 20,
2730 		.beta_exp       = 59,
2731 
2732 		.perform_agc_softsplit = 0,
2733 	} , {
2734 		.band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
2735 		/* 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,
2736 		* 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 */
2737 		.setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
2738 
2739 		.inv_gain       = 732,
2740 		.time_stabiliz  = 10,
2741 
2742 		.alpha_level    = 0,
2743 		.thlock         = 118,
2744 
2745 		.wbd_inv        = 0,
2746 		.wbd_ref        = 1200,
2747 		.wbd_sel        = 3,
2748 		.wbd_alpha      = 5,
2749 
2750 		.agc1_max       = 65535,
2751 		.agc1_min       = 0,
2752 
2753 		.agc2_max       = 65535,
2754 		.agc2_min       = 0,
2755 
2756 		.agc1_pt1       = 0,
2757 		.agc1_pt2       = 0,
2758 		.agc1_pt3       = 98,
2759 		.agc1_slope1    = 0,
2760 		.agc1_slope2    = 167,
2761 		.agc2_pt1       = 98,
2762 		.agc2_pt2       = 255,
2763 		.agc2_slope1    = 104,
2764 		.agc2_slope2    = 0,
2765 
2766 		.alpha_mant     = 18,
2767 		.alpha_exp      = 0,
2768 		.beta_mant      = 20,
2769 		.beta_exp       = 59,
2770 
2771 		.perform_agc_softsplit = 0,
2772 	}
2773 };
2774 
2775 static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
2776 	.internal = 60000,
2777 	.sampling = 15000,
2778 	.pll_prediv = 1,
2779 	.pll_ratio = 5,
2780 	.pll_range = 0,
2781 	.pll_reset = 0,
2782 	.pll_bypass = 0,
2783 	.enable_refdiv = 0,
2784 	.bypclk_div = 0,
2785 	.IO_CLK_en_core = 1,
2786 	.ADClkSrc = 1,
2787 	.modulo = 2,
2788 	.sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
2789 	.ifreq = (0 << 25) | 0,
2790 	.timf = 20452225,
2791 	.xtal_hz = 15000000,
2792 };
2793 
2794 static struct dib7000p_config nim7090_dib7000p_config = {
2795 	.output_mpeg2_in_188_bytes  = 1,
2796 	.hostbus_diversity			= 1,
2797 	.tuner_is_baseband			= 1,
2798 	.update_lna					= tfe7790p_update_lna, /* GPIO used is the same as TFE7790 */
2799 
2800 	.agc_config_count			= 2,
2801 	.agc						= dib7090_agc_config,
2802 
2803 	.bw							= &dib7090_clock_config_12_mhz,
2804 
2805 	.gpio_dir					= DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2806 	.gpio_val					= DIB7000P_GPIO_DEFAULT_VALUES,
2807 	.gpio_pwm_pos				= DIB7000P_GPIO_DEFAULT_PWM_POS,
2808 
2809 	.pwm_freq_div				= 0,
2810 
2811 	.agc_control				= dib7090_agc_restart,
2812 
2813 	.spur_protect				= 0,
2814 	.disable_sample_and_hold	= 0,
2815 	.enable_current_mirror		= 0,
2816 	.diversity_delay			= 0,
2817 
2818 	.output_mode				= OUTMODE_MPEG2_FIFO,
2819 	.enMpegOutput				= 1,
2820 };
2821 
tfe7090p_pvr_update_lna(struct dvb_frontend * fe,u16 agc_global)2822 static int tfe7090p_pvr_update_lna(struct dvb_frontend *fe, u16 agc_global)
2823 {
2824 	struct dvb_usb_adapter *adap = fe->dvb->priv;
2825 	struct dib0700_adapter_state *state = adap->priv;
2826 
2827 	deb_info("TFE7090P-PVR update LNA: agc global=%i", agc_global);
2828 	if (agc_global < 25000) {
2829 		state->dib7000p_ops.set_gpio(fe, 5, 0, 0);
2830 		state->dib7000p_ops.set_agc1_min(fe, 0);
2831 	} else {
2832 		state->dib7000p_ops.set_gpio(fe, 5, 0, 1);
2833 		state->dib7000p_ops.set_agc1_min(fe, 32768);
2834 	}
2835 
2836 	return 0;
2837 }
2838 
2839 static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
2840 	{
2841 		.output_mpeg2_in_188_bytes  = 1,
2842 		.hostbus_diversity			= 1,
2843 		.tuner_is_baseband			= 1,
2844 		.update_lna					= tfe7090p_pvr_update_lna,
2845 
2846 		.agc_config_count			= 2,
2847 		.agc						= dib7090_agc_config,
2848 
2849 		.bw							= &dib7090_clock_config_12_mhz,
2850 
2851 		.gpio_dir					= DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2852 		.gpio_val					= DIB7000P_GPIO_DEFAULT_VALUES,
2853 		.gpio_pwm_pos				= DIB7000P_GPIO_DEFAULT_PWM_POS,
2854 
2855 		.pwm_freq_div				= 0,
2856 
2857 		.agc_control				= dib7090_agc_restart,
2858 
2859 		.spur_protect				= 0,
2860 		.disable_sample_and_hold	= 0,
2861 		.enable_current_mirror		= 0,
2862 		.diversity_delay			= 0,
2863 
2864 		.output_mode				= OUTMODE_MPEG2_PAR_GATED_CLK,
2865 		.default_i2c_addr			= 0x90,
2866 		.enMpegOutput				= 1,
2867 	}, {
2868 		.output_mpeg2_in_188_bytes  = 1,
2869 		.hostbus_diversity			= 1,
2870 		.tuner_is_baseband			= 1,
2871 		.update_lna					= tfe7090p_pvr_update_lna,
2872 
2873 		.agc_config_count			= 2,
2874 		.agc						= dib7090_agc_config,
2875 
2876 		.bw							= &dib7090_clock_config_12_mhz,
2877 
2878 		.gpio_dir					= DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2879 		.gpio_val					= DIB7000P_GPIO_DEFAULT_VALUES,
2880 		.gpio_pwm_pos				= DIB7000P_GPIO_DEFAULT_PWM_POS,
2881 
2882 		.pwm_freq_div				= 0,
2883 
2884 		.agc_control				= dib7090_agc_restart,
2885 
2886 		.spur_protect				= 0,
2887 		.disable_sample_and_hold	= 0,
2888 		.enable_current_mirror		= 0,
2889 		.diversity_delay			= 0,
2890 
2891 		.output_mode				= OUTMODE_MPEG2_PAR_GATED_CLK,
2892 		.default_i2c_addr			= 0x92,
2893 		.enMpegOutput				= 0,
2894 	}
2895 };
2896 
2897 static struct dib0090_config nim7090_dib0090_config = {
2898 	.io.clock_khz = 12000,
2899 	.io.pll_bypass = 0,
2900 	.io.pll_range = 0,
2901 	.io.pll_prediv = 3,
2902 	.io.pll_loopdiv = 6,
2903 	.io.adc_clock_ratio = 0,
2904 	.io.pll_int_loop_filt = 0,
2905 
2906 	.freq_offset_khz_uhf = 0,
2907 	.freq_offset_khz_vhf = 0,
2908 
2909 	.clkouttobamse = 1,
2910 	.analog_output = 0,
2911 
2912 	.wbd_vhf_offset = 0,
2913 	.wbd_cband_offset = 0,
2914 	.use_pwm_agc = 1,
2915 	.clkoutdrive = 0,
2916 
2917 	.fref_clock_ratio = 0,
2918 
2919 	.wbd = dib7090_wbd_table,
2920 
2921 	.ls_cfg_pad_drv = 0,
2922 	.data_tx_drv = 0,
2923 	.low_if = NULL,
2924 	.in_soc = 1,
2925 };
2926 
2927 static struct dib7000p_config tfe7790p_dib7000p_config = {
2928 	.output_mpeg2_in_188_bytes  = 1,
2929 	.hostbus_diversity			= 1,
2930 	.tuner_is_baseband			= 1,
2931 	.update_lna					= tfe7790p_update_lna,
2932 
2933 	.agc_config_count			= 2,
2934 	.agc						= dib7090_agc_config,
2935 
2936 	.bw							= &dib7090_clock_config_12_mhz,
2937 
2938 	.gpio_dir					= DIB7000P_GPIO_DEFAULT_DIRECTIONS,
2939 	.gpio_val					= DIB7000P_GPIO_DEFAULT_VALUES,
2940 	.gpio_pwm_pos				= DIB7000P_GPIO_DEFAULT_PWM_POS,
2941 
2942 	.pwm_freq_div				= 0,
2943 
2944 	.agc_control				= dib7090_agc_restart,
2945 
2946 	.spur_protect				= 0,
2947 	.disable_sample_and_hold	= 0,
2948 	.enable_current_mirror		= 0,
2949 	.diversity_delay			= 0,
2950 
2951 	.output_mode				= OUTMODE_MPEG2_PAR_GATED_CLK,
2952 	.enMpegOutput				= 1,
2953 };
2954 
2955 static struct dib0090_config tfe7790p_dib0090_config = {
2956 	.io.clock_khz = 12000,
2957 	.io.pll_bypass = 0,
2958 	.io.pll_range = 0,
2959 	.io.pll_prediv = 3,
2960 	.io.pll_loopdiv = 6,
2961 	.io.adc_clock_ratio = 0,
2962 	.io.pll_int_loop_filt = 0,
2963 
2964 	.freq_offset_khz_uhf = 0,
2965 	.freq_offset_khz_vhf = 0,
2966 
2967 	.clkouttobamse = 1,
2968 	.analog_output = 0,
2969 
2970 	.wbd_vhf_offset = 0,
2971 	.wbd_cband_offset = 0,
2972 	.use_pwm_agc = 1,
2973 	.clkoutdrive = 0,
2974 
2975 	.fref_clock_ratio = 0,
2976 
2977 	.wbd = dib7090_wbd_table,
2978 
2979 	.ls_cfg_pad_drv = 0,
2980 	.data_tx_drv = 0,
2981 	.low_if = NULL,
2982 	.in_soc = 1,
2983 	.force_cband_input = 0,
2984 	.is_dib7090e = 0,
2985 	.force_crystal_mode = 1,
2986 };
2987 
2988 static struct dib0090_config tfe7090pvr_dib0090_config[2] = {
2989 	{
2990 		.io.clock_khz = 12000,
2991 		.io.pll_bypass = 0,
2992 		.io.pll_range = 0,
2993 		.io.pll_prediv = 3,
2994 		.io.pll_loopdiv = 6,
2995 		.io.adc_clock_ratio = 0,
2996 		.io.pll_int_loop_filt = 0,
2997 
2998 		.freq_offset_khz_uhf = 50,
2999 		.freq_offset_khz_vhf = 70,
3000 
3001 		.clkouttobamse = 1,
3002 		.analog_output = 0,
3003 
3004 		.wbd_vhf_offset = 0,
3005 		.wbd_cband_offset = 0,
3006 		.use_pwm_agc = 1,
3007 		.clkoutdrive = 0,
3008 
3009 		.fref_clock_ratio = 0,
3010 
3011 		.wbd = dib7090_wbd_table,
3012 
3013 		.ls_cfg_pad_drv = 0,
3014 		.data_tx_drv = 0,
3015 		.low_if = NULL,
3016 		.in_soc = 1,
3017 	}, {
3018 		.io.clock_khz = 12000,
3019 		.io.pll_bypass = 0,
3020 		.io.pll_range = 0,
3021 		.io.pll_prediv = 3,
3022 		.io.pll_loopdiv = 6,
3023 		.io.adc_clock_ratio = 0,
3024 		.io.pll_int_loop_filt = 0,
3025 
3026 		.freq_offset_khz_uhf = -50,
3027 		.freq_offset_khz_vhf = -70,
3028 
3029 		.clkouttobamse = 1,
3030 		.analog_output = 0,
3031 
3032 		.wbd_vhf_offset = 0,
3033 		.wbd_cband_offset = 0,
3034 		.use_pwm_agc = 1,
3035 		.clkoutdrive = 0,
3036 
3037 		.fref_clock_ratio = 0,
3038 
3039 		.wbd = dib7090_wbd_table,
3040 
3041 		.ls_cfg_pad_drv = 0,
3042 		.data_tx_drv = 0,
3043 		.low_if = NULL,
3044 		.in_soc = 1,
3045 	}
3046 };
3047 
nim7090_frontend_attach(struct dvb_usb_adapter * adap)3048 static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
3049 {
3050 	struct dib0700_adapter_state *state = adap->priv;
3051 
3052 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3053 		return -ENODEV;
3054 
3055 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3056 	msleep(20);
3057 	dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3058 	dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3059 	dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3060 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3061 
3062 	msleep(20);
3063 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3064 	msleep(20);
3065 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3066 
3067 	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
3068 		err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3069 		dvb_detach(state->dib7000p_ops.set_wbd_ref);
3070 		return -ENODEV;
3071 	}
3072 	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
3073 
3074 	return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3075 }
3076 
nim7090_tuner_attach(struct dvb_usb_adapter * adap)3077 static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
3078 {
3079 	struct dib0700_adapter_state *st = adap->priv;
3080 	struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3081 
3082 	nim7090_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
3083 	nim7090_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
3084 	nim7090_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3085 
3086 	if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &nim7090_dib0090_config) == NULL)
3087 		return -ENODEV;
3088 
3089 	st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3090 
3091 	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3092 	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3093 	return 0;
3094 }
3095 
tfe7090pvr_frontend0_attach(struct dvb_usb_adapter * adap)3096 static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
3097 {
3098 	struct dib0700_state *st = adap->dev->priv;
3099 	struct dib0700_adapter_state *state = adap->priv;
3100 
3101 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3102 		return -ENODEV;
3103 
3104 	/* The TFE7090 requires the dib0700 to not be in master mode */
3105 	st->disable_streaming_master_mode = 1;
3106 
3107 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3108 	msleep(20);
3109 	dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3110 	dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3111 	dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3112 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3113 
3114 	msleep(20);
3115 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3116 	msleep(20);
3117 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3118 
3119 	/* initialize IC 0 */
3120 	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
3121 		err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3122 		dvb_detach(state->dib7000p_ops.set_wbd_ref);
3123 		return -ENODEV;
3124 	}
3125 
3126 	dib0700_set_i2c_speed(adap->dev, 340);
3127 	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
3128 	if (adap->fe_adap[0].fe == NULL)
3129 		return -ENODEV;
3130 
3131 	state->dib7000p_ops.slave_reset(adap->fe_adap[0].fe);
3132 
3133 	return 0;
3134 }
3135 
tfe7090pvr_frontend1_attach(struct dvb_usb_adapter * adap)3136 static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
3137 {
3138 	struct i2c_adapter *i2c;
3139 	struct dib0700_adapter_state *state = adap->priv;
3140 
3141 	if (adap->dev->adapter[0].fe_adap[0].fe == NULL) {
3142 		err("the master dib7090 has to be initialized first");
3143 		return -ENODEV; /* the master device has not been initialized */
3144 	}
3145 
3146 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3147 		return -ENODEV;
3148 
3149 	i2c = state->dib7000p_ops.get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
3150 	if (state->dib7000p_ops.i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
3151 		err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n", __func__);
3152 		dvb_detach(state->dib7000p_ops.set_wbd_ref);
3153 		return -ENODEV;
3154 	}
3155 
3156 	adap->fe_adap[0].fe = state->dib7000p_ops.init(i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
3157 	dib0700_set_i2c_speed(adap->dev, 200);
3158 
3159 	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3160 }
3161 
tfe7090pvr_tuner0_attach(struct dvb_usb_adapter * adap)3162 static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
3163 {
3164 	struct dib0700_adapter_state *st = adap->priv;
3165 	struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3166 
3167 	tfe7090pvr_dib0090_config[0].reset = st->dib7000p_ops.tuner_sleep;
3168 	tfe7090pvr_dib0090_config[0].sleep = st->dib7000p_ops.tuner_sleep;
3169 	tfe7090pvr_dib0090_config[0].get_adc_power = st->dib7000p_ops.get_adc_power;
3170 
3171 	if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
3172 		return -ENODEV;
3173 
3174 	st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3175 
3176 	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3177 	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3178 	return 0;
3179 }
3180 
tfe7090pvr_tuner1_attach(struct dvb_usb_adapter * adap)3181 static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
3182 {
3183 	struct dib0700_adapter_state *st = adap->priv;
3184 	struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3185 
3186 	tfe7090pvr_dib0090_config[1].reset = st->dib7000p_ops.tuner_sleep;
3187 	tfe7090pvr_dib0090_config[1].sleep = st->dib7000p_ops.tuner_sleep;
3188 	tfe7090pvr_dib0090_config[1].get_adc_power = st->dib7000p_ops.get_adc_power;
3189 
3190 	if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
3191 		return -ENODEV;
3192 
3193 	st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3194 
3195 	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3196 	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3197 	return 0;
3198 }
3199 
tfe7790p_frontend_attach(struct dvb_usb_adapter * adap)3200 static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap)
3201 {
3202 	struct dib0700_state *st = adap->dev->priv;
3203 	struct dib0700_adapter_state *state = adap->priv;
3204 
3205 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3206 		return -ENODEV;
3207 
3208 	/* The TFE7790P requires the dib0700 to not be in master mode */
3209 	st->disable_streaming_master_mode = 1;
3210 
3211 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3212 	msleep(20);
3213 	dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3214 	dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3215 	dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3216 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3217 	msleep(20);
3218 	dib0700_ctrl_clock(adap->dev, 72, 1);
3219 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3220 	msleep(20);
3221 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3222 
3223 	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap,
3224 				1, 0x10, &tfe7790p_dib7000p_config) != 0) {
3225 		err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3226 				__func__);
3227 		dvb_detach(state->dib7000p_ops.set_wbd_ref);
3228 		return -ENODEV;
3229 	}
3230 	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
3231 			0x80, &tfe7790p_dib7000p_config);
3232 
3233 	return adap->fe_adap[0].fe == NULL ?  -ENODEV : 0;
3234 }
3235 
tfe7790p_tuner_attach(struct dvb_usb_adapter * adap)3236 static int tfe7790p_tuner_attach(struct dvb_usb_adapter *adap)
3237 {
3238 	struct dib0700_adapter_state *st = adap->priv;
3239 	struct i2c_adapter *tun_i2c =
3240 		st->dib7000p_ops.get_i2c_tuner(adap->fe_adap[0].fe);
3241 
3242 
3243 	tfe7790p_dib0090_config.reset = st->dib7000p_ops.tuner_sleep;
3244 	tfe7790p_dib0090_config.sleep = st->dib7000p_ops.tuner_sleep;
3245 	tfe7790p_dib0090_config.get_adc_power = st->dib7000p_ops.get_adc_power;
3246 
3247 	if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c,
3248 				&tfe7790p_dib0090_config) == NULL)
3249 		return -ENODEV;
3250 
3251 	st->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3252 
3253 	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
3254 	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7090_agc_startup;
3255 	return 0;
3256 }
3257 
3258 /* STK7070PD */
3259 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
3260 	{
3261 		.output_mpeg2_in_188_bytes = 1,
3262 
3263 		.agc_config_count = 1,
3264 		.agc = &dib7070_agc_config,
3265 		.bw  = &dib7070_bw_config_12_mhz,
3266 		.tuner_is_baseband = 1,
3267 		.spur_protect = 1,
3268 
3269 		.gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3270 		.gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3271 		.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3272 
3273 		.hostbus_diversity = 1,
3274 	}, {
3275 		.output_mpeg2_in_188_bytes = 1,
3276 
3277 		.agc_config_count = 1,
3278 		.agc = &dib7070_agc_config,
3279 		.bw  = &dib7070_bw_config_12_mhz,
3280 		.tuner_is_baseband = 1,
3281 		.spur_protect = 1,
3282 
3283 		.gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
3284 		.gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
3285 		.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
3286 
3287 		.hostbus_diversity = 1,
3288 	}
3289 };
3290 
stk7070pd_init(struct dvb_usb_device * dev)3291 static void stk7070pd_init(struct dvb_usb_device *dev)
3292 {
3293 	dib0700_set_gpio(dev, GPIO6, GPIO_OUT, 1);
3294 	msleep(10);
3295 	dib0700_set_gpio(dev, GPIO9, GPIO_OUT, 1);
3296 	dib0700_set_gpio(dev, GPIO4, GPIO_OUT, 1);
3297 	dib0700_set_gpio(dev, GPIO7, GPIO_OUT, 1);
3298 	dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 0);
3299 
3300 	dib0700_ctrl_clock(dev, 72, 1);
3301 
3302 	msleep(10);
3303 	dib0700_set_gpio(dev, GPIO10, GPIO_OUT, 1);
3304 }
3305 
stk7070pd_frontend_attach0(struct dvb_usb_adapter * adap)3306 static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
3307 {
3308 	struct dib0700_adapter_state *state = adap->priv;
3309 
3310 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3311 		return -ENODEV;
3312 
3313 	stk7070pd_init(adap->dev);
3314 
3315 	msleep(10);
3316 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3317 
3318 	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
3319 				     stk7070pd_dib7000p_config) != 0) {
3320 		err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3321 		    __func__);
3322 		dvb_detach(state->dib7000p_ops.set_wbd_ref);
3323 		return -ENODEV;
3324 	}
3325 
3326 	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
3327 	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3328 }
3329 
stk7070pd_frontend_attach1(struct dvb_usb_adapter * adap)3330 static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
3331 {
3332 	struct dib0700_adapter_state *state = adap->priv;
3333 
3334 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3335 		return -ENODEV;
3336 
3337 	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
3338 	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3339 }
3340 
novatd_read_status_override(struct dvb_frontend * fe,enum fe_status * stat)3341 static int novatd_read_status_override(struct dvb_frontend *fe,
3342 				       enum fe_status *stat)
3343 {
3344 	struct dvb_usb_adapter *adap = fe->dvb->priv;
3345 	struct dvb_usb_device *dev = adap->dev;
3346 	struct dib0700_state *state = dev->priv;
3347 	int ret;
3348 
3349 	ret = state->read_status(fe, stat);
3350 
3351 	if (!ret)
3352 		dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3353 				!!(*stat & FE_HAS_LOCK));
3354 
3355 	return ret;
3356 }
3357 
novatd_sleep_override(struct dvb_frontend * fe)3358 static int novatd_sleep_override(struct dvb_frontend* fe)
3359 {
3360 	struct dvb_usb_adapter *adap = fe->dvb->priv;
3361 	struct dvb_usb_device *dev = adap->dev;
3362 	struct dib0700_state *state = dev->priv;
3363 
3364 	/* turn off LED */
3365 	dib0700_set_gpio(dev, adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, 0);
3366 
3367 	return state->sleep(fe);
3368 }
3369 
3370 /*
3371  * novatd_frontend_attach - Nova-TD specific attach
3372  *
3373  * Nova-TD has GPIO0, 1 and 2 for LEDs. So do not fiddle with them except for
3374  * information purposes.
3375  */
novatd_frontend_attach(struct dvb_usb_adapter * adap)3376 static int novatd_frontend_attach(struct dvb_usb_adapter *adap)
3377 {
3378 	struct dvb_usb_device *dev = adap->dev;
3379 	struct dib0700_state *st = dev->priv;
3380 	struct dib0700_adapter_state *state = adap->priv;
3381 
3382 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3383 		return -ENODEV;
3384 
3385 	if (adap->id == 0) {
3386 		stk7070pd_init(dev);
3387 
3388 		/* turn the power LED on, the other two off (just in case) */
3389 		dib0700_set_gpio(dev, GPIO0, GPIO_OUT, 0);
3390 		dib0700_set_gpio(dev, GPIO1, GPIO_OUT, 0);
3391 		dib0700_set_gpio(dev, GPIO2, GPIO_OUT, 1);
3392 
3393 		if (state->dib7000p_ops.i2c_enumeration(&dev->i2c_adap, 2, 18,
3394 					     stk7070pd_dib7000p_config) != 0) {
3395 			err("%s: state->dib7000p_ops.i2c_enumeration failed.  Cannot continue\n",
3396 			    __func__);
3397 			dvb_detach(state->dib7000p_ops.set_wbd_ref);
3398 			return -ENODEV;
3399 		}
3400 	}
3401 
3402 	adap->fe_adap[0].fe = state->dib7000p_ops.init(&dev->i2c_adap,
3403 			adap->id == 0 ? 0x80 : 0x82,
3404 			&stk7070pd_dib7000p_config[adap->id]);
3405 
3406 	if (adap->fe_adap[0].fe == NULL)
3407 		return -ENODEV;
3408 
3409 	st->read_status = adap->fe_adap[0].fe->ops.read_status;
3410 	adap->fe_adap[0].fe->ops.read_status = novatd_read_status_override;
3411 	st->sleep = adap->fe_adap[0].fe->ops.sleep;
3412 	adap->fe_adap[0].fe->ops.sleep = novatd_sleep_override;
3413 
3414 	return 0;
3415 }
3416 
3417 /* S5H1411 */
3418 static struct s5h1411_config pinnacle_801e_config = {
3419 	.output_mode   = S5H1411_PARALLEL_OUTPUT,
3420 	.gpio          = S5H1411_GPIO_OFF,
3421 	.mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINUOUS_NONINVERTING_CLOCK,
3422 	.qam_if        = S5H1411_IF_44000,
3423 	.vsb_if        = S5H1411_IF_44000,
3424 	.inversion     = S5H1411_INVERSION_OFF,
3425 	.status_mode   = S5H1411_DEMODLOCKING
3426 };
3427 
3428 /* Pinnacle PCTV HD Pro 801e GPIOs map:
3429    GPIO0  - currently unknown
3430    GPIO1  - xc5000 tuner reset
3431    GPIO2  - CX25843 sleep
3432    GPIO3  - currently unknown
3433    GPIO4  - currently unknown
3434    GPIO6  - currently unknown
3435    GPIO7  - currently unknown
3436    GPIO9  - currently unknown
3437    GPIO10 - CX25843 reset
3438  */
s5h1411_frontend_attach(struct dvb_usb_adapter * adap)3439 static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
3440 {
3441 	struct dib0700_state *st = adap->dev->priv;
3442 
3443 	/* Make use of the new i2c functions from FW 1.20 */
3444 	st->fw_use_new_i2c_api = 1;
3445 
3446 	/* The s5h1411 requires the dib0700 to not be in master mode */
3447 	st->disable_streaming_master_mode = 1;
3448 
3449 	/* All msleep values taken from Windows USB trace */
3450 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
3451 	dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
3452 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3453 	msleep(400);
3454 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3455 	msleep(60);
3456 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3457 	msleep(30);
3458 	dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
3459 	dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
3460 	dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
3461 	dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
3462 	dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
3463 	msleep(30);
3464 
3465 	/* Put the CX25843 to sleep for now since we're in digital mode */
3466 	dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3467 
3468 	/* GPIOs are initialized, do the attach */
3469 	adap->fe_adap[0].fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
3470 			      &adap->dev->i2c_adap);
3471 	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3472 }
3473 
dib0700_xc5000_tuner_callback(void * priv,int component,int command,int arg)3474 static int dib0700_xc5000_tuner_callback(void *priv, int component,
3475 					 int command, int arg)
3476 {
3477 	struct dvb_usb_adapter *adap = priv;
3478 
3479 	if (command == XC5000_TUNER_RESET) {
3480 		/* Reset the tuner */
3481 		dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
3482 		msleep(10);
3483 		dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
3484 		msleep(10);
3485 	} else {
3486 		err("xc5000: unknown tuner callback command: %d\n", command);
3487 		return -EINVAL;
3488 	}
3489 
3490 	return 0;
3491 }
3492 
3493 static struct xc5000_config s5h1411_xc5000_tunerconfig = {
3494 	.i2c_address      = 0x64,
3495 	.if_khz           = 5380,
3496 };
3497 
xc5000_tuner_attach(struct dvb_usb_adapter * adap)3498 static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
3499 {
3500 	/* FIXME: generalize & move to common area */
3501 	adap->fe_adap[0].fe->callback = dib0700_xc5000_tuner_callback;
3502 
3503 	return dvb_attach(xc5000_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
3504 			  &s5h1411_xc5000_tunerconfig)
3505 		== NULL ? -ENODEV : 0;
3506 }
3507 
dib0700_xc4000_tuner_callback(void * priv,int component,int command,int arg)3508 static int dib0700_xc4000_tuner_callback(void *priv, int component,
3509 					 int command, int arg)
3510 {
3511 	struct dvb_usb_adapter *adap = priv;
3512 	struct dib0700_adapter_state *state = adap->priv;
3513 
3514 	if (command == XC4000_TUNER_RESET) {
3515 		/* Reset the tuner */
3516 		state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
3517 		msleep(10);
3518 		state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
3519 	} else {
3520 		err("xc4000: unknown tuner callback command: %d\n", command);
3521 		return -EINVAL;
3522 	}
3523 
3524 	return 0;
3525 }
3526 
3527 static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
3528 	.band_caps = BAND_UHF | BAND_VHF,
3529 	.setup = 0x64,
3530 	.inv_gain = 0x02c8,
3531 	.time_stabiliz = 0x15,
3532 	.alpha_level = 0x00,
3533 	.thlock = 0x76,
3534 	.wbd_inv = 0x01,
3535 	.wbd_ref = 0x0b33,
3536 	.wbd_sel = 0x00,
3537 	.wbd_alpha = 0x02,
3538 	.agc1_max = 0x00,
3539 	.agc1_min = 0x00,
3540 	.agc2_max = 0x9b26,
3541 	.agc2_min = 0x26ca,
3542 	.agc1_pt1 = 0x00,
3543 	.agc1_pt2 = 0x00,
3544 	.agc1_pt3 = 0x00,
3545 	.agc1_slope1 = 0x00,
3546 	.agc1_slope2 = 0x00,
3547 	.agc2_pt1 = 0x00,
3548 	.agc2_pt2 = 0x80,
3549 	.agc2_slope1 = 0x1d,
3550 	.agc2_slope2 = 0x1d,
3551 	.alpha_mant = 0x11,
3552 	.alpha_exp = 0x1b,
3553 	.beta_mant = 0x17,
3554 	.beta_exp = 0x33,
3555 	.perform_agc_softsplit = 0x00,
3556 };
3557 
3558 static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
3559 	.internal = 60000,
3560 	.sampling = 30000,
3561 	.pll_prediv = 1,
3562 	.pll_ratio = 8,
3563 	.pll_range = 3,
3564 	.pll_reset = 1,
3565 	.pll_bypass = 0,
3566 	.enable_refdiv = 0,
3567 	.bypclk_div = 0,
3568 	.IO_CLK_en_core = 1,
3569 	.ADClkSrc = 1,
3570 	.modulo = 0,
3571 	.sad_cfg = (3 << 14) | (1 << 12) | 524, /* sad_cfg: refsel, sel, freq_15k */
3572 	.ifreq = 39370534,
3573 	.timf = 20452225,
3574 	.xtal_hz = 30000000
3575 };
3576 
3577 /* FIXME: none of these inputs are validated yet */
3578 static struct dib7000p_config pctv_340e_config = {
3579 	.output_mpeg2_in_188_bytes = 1,
3580 
3581 	.agc_config_count = 1,
3582 	.agc = &stk7700p_7000p_xc4000_agc_config,
3583 	.bw  = &stk7700p_xc4000_pll_config,
3584 
3585 	.gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
3586 	.gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
3587 	.gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
3588 };
3589 
3590 /* PCTV 340e GPIOs map:
3591    dib0700:
3592    GPIO2  - CX25843 sleep
3593    GPIO3  - CS5340 reset
3594    GPIO5  - IRD
3595    GPIO6  - Power Supply
3596    GPIO8  - LNA (1=off 0=on)
3597    GPIO10 - CX25843 reset
3598    dib7000:
3599    GPIO8  - xc4000 reset
3600  */
pctv340e_frontend_attach(struct dvb_usb_adapter * adap)3601 static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
3602 {
3603 	struct dib0700_state *st = adap->dev->priv;
3604 	struct dib0700_adapter_state *state = adap->priv;
3605 
3606 	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
3607 		return -ENODEV;
3608 
3609 	/* Power Supply on */
3610 	dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0);
3611 	msleep(50);
3612 	dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1);
3613 	msleep(100); /* Allow power supply to settle before probing */
3614 
3615 	/* cx25843 reset */
3616 	dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 0);
3617 	msleep(1); /* cx25843 datasheet say 350us required */
3618 	dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 1);
3619 
3620 	/* LNA off for now */
3621 	dib0700_set_gpio(adap->dev, GPIO8,  GPIO_OUT, 1);
3622 
3623 	/* Put the CX25843 to sleep for now since we're in digital mode */
3624 	dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
3625 
3626 	/* FIXME: not verified yet */
3627 	dib0700_ctrl_clock(adap->dev, 72, 1);
3628 
3629 	msleep(500);
3630 
3631 	if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
3632 		/* Demodulator not found for some reason? */
3633 		dvb_detach(state->dib7000p_ops.set_wbd_ref);
3634 		return -ENODEV;
3635 	}
3636 
3637 	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x12,
3638 			      &pctv_340e_config);
3639 	st->is_dib7000pc = 1;
3640 
3641 	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3642 }
3643 
3644 static struct xc4000_config dib7000p_xc4000_tunerconfig = {
3645 	.i2c_address	  = 0x61,
3646 	.default_pm	  = 1,
3647 	.dvb_amplitude	  = 0,
3648 	.set_smoothedcvbs = 0,
3649 	.if_khz		  = 5400
3650 };
3651 
xc4000_tuner_attach(struct dvb_usb_adapter * adap)3652 static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
3653 {
3654 	struct i2c_adapter *tun_i2c;
3655 	struct dib0700_adapter_state *state = adap->priv;
3656 
3657 	/* The xc4000 is not on the main i2c bus */
3658 	tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
3659 					  DIBX000_I2C_INTERFACE_TUNER, 1);
3660 	if (tun_i2c == NULL) {
3661 		printk(KERN_ERR "Could not reach tuner i2c bus\n");
3662 		return 0;
3663 	}
3664 
3665 	/* Setup the reset callback */
3666 	adap->fe_adap[0].fe->callback = dib0700_xc4000_tuner_callback;
3667 
3668 	return dvb_attach(xc4000_attach, adap->fe_adap[0].fe, tun_i2c,
3669 			  &dib7000p_xc4000_tunerconfig)
3670 		== NULL ? -ENODEV : 0;
3671 }
3672 
3673 static struct lgdt3305_config hcw_lgdt3305_config = {
3674 	.i2c_addr           = 0x0e,
3675 	.mpeg_mode          = LGDT3305_MPEG_PARALLEL,
3676 	.tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
3677 	.tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
3678 	.deny_i2c_rptr      = 0,
3679 	.spectral_inversion = 1,
3680 	.qam_if_khz         = 6000,
3681 	.vsb_if_khz         = 6000,
3682 	.usref_8vsb         = 0x0500,
3683 };
3684 
3685 static struct mxl5007t_config hcw_mxl5007t_config = {
3686 	.xtal_freq_hz = MxL_XTAL_25_MHZ,
3687 	.if_freq_hz = MxL_IF_6_MHZ,
3688 	.invert_if = 1,
3689 };
3690 
3691 /* TIGER-ATSC map:
3692    GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
3693    GPIO1  - ANT_SEL  (H: VPA, L: MCX)
3694    GPIO4  - SCL2
3695    GPIO6  - EN_TUNER
3696    GPIO7  - SDA2
3697    GPIO10 - DEM_RST
3698 
3699    MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
3700  */
lgdt3305_frontend_attach(struct dvb_usb_adapter * adap)3701 static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
3702 {
3703 	struct dib0700_state *st = adap->dev->priv;
3704 
3705 	/* Make use of the new i2c functions from FW 1.20 */
3706 	st->fw_use_new_i2c_api = 1;
3707 
3708 	st->disable_streaming_master_mode = 1;
3709 
3710 	/* fe power enable */
3711 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3712 	msleep(30);
3713 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3714 	msleep(30);
3715 
3716 	/* demod reset */
3717 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3718 	msleep(30);
3719 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3720 	msleep(30);
3721 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3722 	msleep(30);
3723 
3724 	adap->fe_adap[0].fe = dvb_attach(lgdt3305_attach,
3725 			      &hcw_lgdt3305_config,
3726 			      &adap->dev->i2c_adap);
3727 
3728 	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3729 }
3730 
mxl5007t_tuner_attach(struct dvb_usb_adapter * adap)3731 static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
3732 {
3733 	return dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
3734 			  &adap->dev->i2c_adap, 0x60,
3735 			  &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
3736 }
3737 
xbox_one_attach(struct dvb_usb_adapter * adap)3738 static int xbox_one_attach(struct dvb_usb_adapter *adap)
3739 {
3740 	struct dib0700_state *st = adap->dev->priv;
3741 	struct i2c_client *client_demod, *client_tuner;
3742 	struct dvb_usb_device *d = adap->dev;
3743 	struct mn88472_config mn88472_config = { };
3744 	struct tda18250_config tda18250_config;
3745 	struct i2c_board_info info;
3746 
3747 	st->fw_use_new_i2c_api = 1;
3748 	st->disable_streaming_master_mode = 1;
3749 
3750 	/* fe power enable */
3751 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
3752 	msleep(30);
3753 	dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
3754 	msleep(30);
3755 
3756 	/* demod reset */
3757 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3758 	msleep(30);
3759 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
3760 	msleep(30);
3761 	dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
3762 	msleep(30);
3763 
3764 	/* attach demod */
3765 	mn88472_config.fe = &adap->fe_adap[0].fe;
3766 	mn88472_config.i2c_wr_max = 22;
3767 	mn88472_config.xtal = 20500000;
3768 	mn88472_config.ts_mode = PARALLEL_TS_MODE;
3769 	mn88472_config.ts_clock = FIXED_TS_CLOCK;
3770 	memset(&info, 0, sizeof(struct i2c_board_info));
3771 	strscpy(info.type, "mn88472", I2C_NAME_SIZE);
3772 	info.addr = 0x18;
3773 	info.platform_data = &mn88472_config;
3774 	request_module(info.type);
3775 	client_demod = i2c_new_client_device(&d->i2c_adap, &info);
3776 	if (!i2c_client_has_driver(client_demod))
3777 		goto fail_demod_device;
3778 	if (!try_module_get(client_demod->dev.driver->owner))
3779 		goto fail_demod_module;
3780 
3781 	st->i2c_client_demod = client_demod;
3782 
3783 	adap->fe_adap[0].fe = mn88472_config.get_dvb_frontend(client_demod);
3784 
3785 	/* attach tuner */
3786 	memset(&tda18250_config, 0, sizeof(tda18250_config));
3787 	tda18250_config.if_dvbt_6 = 3950;
3788 	tda18250_config.if_dvbt_7 = 4450;
3789 	tda18250_config.if_dvbt_8 = 4950;
3790 	tda18250_config.if_dvbc_6 = 4950;
3791 	tda18250_config.if_dvbc_8 = 4950;
3792 	tda18250_config.if_atsc = 4079;
3793 	tda18250_config.loopthrough = true;
3794 	tda18250_config.xtal_freq = TDA18250_XTAL_FREQ_27MHZ;
3795 	tda18250_config.fe = adap->fe_adap[0].fe;
3796 
3797 	memset(&info, 0, sizeof(struct i2c_board_info));
3798 	strscpy(info.type, "tda18250", I2C_NAME_SIZE);
3799 	info.addr = 0x60;
3800 	info.platform_data = &tda18250_config;
3801 
3802 	request_module(info.type);
3803 	client_tuner = i2c_new_client_device(&adap->dev->i2c_adap, &info);
3804 	if (!i2c_client_has_driver(client_tuner))
3805 		goto fail_tuner_device;
3806 	if (!try_module_get(client_tuner->dev.driver->owner))
3807 		goto fail_tuner_module;
3808 
3809 	st->i2c_client_tuner = client_tuner;
3810 	return 0;
3811 
3812 fail_tuner_module:
3813 	i2c_unregister_device(client_tuner);
3814 fail_tuner_device:
3815 	module_put(client_demod->dev.driver->owner);
3816 fail_demod_module:
3817 	i2c_unregister_device(client_demod);
3818 fail_demod_device:
3819 	return -ENODEV;
3820 }
3821 
3822 
3823 /* DVB-USB and USB stuff follows */
3824 enum {
3825 	DIBCOM_STK7700P,
3826 	DIBCOM_STK7700P_PC,
3827 	HAUPPAUGE_NOVA_T_500,
3828 	HAUPPAUGE_NOVA_T_500_2,
3829 	HAUPPAUGE_NOVA_T_STICK,
3830 	AVERMEDIA_VOLAR,
3831 	COMPRO_VIDEOMATE_U500,
3832 	UNIWILL_STK7700P,
3833 	LEADTEK_WINFAST_DTV_DONGLE_STK7700P,
3834 	HAUPPAUGE_NOVA_T_STICK_2,
3835 	AVERMEDIA_VOLAR_2,
3836 	PINNACLE_PCTV2000E,
3837 	TERRATEC_CINERGY_DT_XS_DIVERSITY,
3838 	HAUPPAUGE_NOVA_TD_STICK,
3839 	DIBCOM_STK7700D,
3840 	DIBCOM_STK7070P,
3841 	PINNACLE_PCTV_DVB_T_FLASH,
3842 	DIBCOM_STK7070PD,
3843 	PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T,
3844 	COMPRO_VIDEOMATE_U500_PC,
3845 	AVERMEDIA_EXPRESS,
3846 	GIGABYTE_U7000,
3847 	ULTIMA_ARTEC_T14BR,
3848 	ASUS_U3000,
3849 	ASUS_U3100,
3850 	HAUPPAUGE_NOVA_T_STICK_3,
3851 	HAUPPAUGE_MYTV_T,
3852 	TERRATEC_CINERGY_HT_USB_XE,
3853 	PINNACLE_EXPRESSCARD_320CX,
3854 	PINNACLE_PCTV72E,
3855 	PINNACLE_PCTV73E,
3856 	YUAN_EC372S,
3857 	TERRATEC_CINERGY_HT_EXPRESS,
3858 	TERRATEC_CINERGY_T_XXS,
3859 	LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2,
3860 	HAUPPAUGE_NOVA_TD_STICK_52009,
3861 	HAUPPAUGE_NOVA_T_500_3,
3862 	GIGABYTE_U8000,
3863 	YUAN_STK7700PH,
3864 	ASUS_U3000H,
3865 	PINNACLE_PCTV801E,
3866 	PINNACLE_PCTV801E_SE,
3867 	TERRATEC_CINERGY_T_EXPRESS,
3868 	TERRATEC_CINERGY_DT_XS_DIVERSITY_2,
3869 	SONY_PLAYTV,
3870 	YUAN_PD378S,
3871 	HAUPPAUGE_TIGER_ATSC,
3872 	HAUPPAUGE_TIGER_ATSC_B210,
3873 	YUAN_MC770,
3874 	ELGATO_EYETV_DTT,
3875 	ELGATO_EYETV_DTT_Dlx,
3876 	LEADTEK_WINFAST_DTV_DONGLE_H,
3877 	TERRATEC_T3,
3878 	TERRATEC_T5,
3879 	YUAN_STK7700D,
3880 	YUAN_STK7700D_2,
3881 	PINNACLE_PCTV73A,
3882 	PCTV_PINNACLE_PCTV73ESE,
3883 	PCTV_PINNACLE_PCTV282E,
3884 	DIBCOM_STK7770P,
3885 	TERRATEC_CINERGY_T_XXS_2,
3886 	DIBCOM_STK807XPVR,
3887 	DIBCOM_STK807XP,
3888 	PIXELVIEW_SBTVD,
3889 	EVOLUTEPC_TVWAY_PLUS,
3890 	PINNACLE_PCTV73ESE,
3891 	PINNACLE_PCTV282E,
3892 	DIBCOM_STK8096GP,
3893 	ELGATO_EYETV_DIVERSITY,
3894 	DIBCOM_NIM9090M,
3895 	DIBCOM_NIM8096MD,
3896 	DIBCOM_NIM9090MD,
3897 	DIBCOM_NIM7090,
3898 	DIBCOM_TFE7090PVR,
3899 	TECHNISAT_AIRSTAR_TELESTICK_2,
3900 	MEDION_CREATIX_CTX1921,
3901 	PINNACLE_PCTV340E,
3902 	PINNACLE_PCTV340E_SE,
3903 	DIBCOM_TFE7790P,
3904 	DIBCOM_TFE8096P,
3905 	ELGATO_EYETV_DTT_2,
3906 	PCTV_2002E,
3907 	PCTV_2002E_SE,
3908 	PCTV_DIBCOM_STK8096PVR,
3909 	DIBCOM_STK8096PVR,
3910 	HAMA_DVBT_HYBRID,
3911 	MICROSOFT_XBOX_ONE_TUNER,
3912 };
3913 
3914 struct usb_device_id dib0700_usb_id_table[] = {
3915 	DVB_USB_DEV(DIBCOM, DIBCOM_STK7700P),
3916 	DVB_USB_DEV(DIBCOM, DIBCOM_STK7700P_PC),
3917 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500),
3918 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500_2),
3919 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK),
3920 	DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR),
3921 	DVB_USB_DEV(COMPRO, COMPRO_VIDEOMATE_U500),
3922 	DVB_USB_DEV(UNIWILL, UNIWILL_STK7700P),
3923 	DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_STK7700P),
3924 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK_2),
3925 	DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR_2),
3926 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV2000E),
3927 	DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_DT_XS_DIVERSITY),
3928 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_TD_STICK),
3929 	DVB_USB_DEV(DIBCOM, DIBCOM_STK7700D),
3930 	DVB_USB_DEV(DIBCOM, DIBCOM_STK7070P),
3931 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_DVB_T_FLASH),
3932 	DVB_USB_DEV(DIBCOM, DIBCOM_STK7070PD),
3933 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T),
3934 	DVB_USB_DEV(COMPRO, COMPRO_VIDEOMATE_U500_PC),
3935 	DVB_USB_DEV(AVERMEDIA, AVERMEDIA_EXPRESS),
3936 	DVB_USB_DEV(GIGABYTE, GIGABYTE_U7000),
3937 	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_ARTEC_T14BR),
3938 	DVB_USB_DEV(ASUS, ASUS_U3000),
3939 	DVB_USB_DEV(ASUS, ASUS_U3100),
3940 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_STICK_3),
3941 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_MYTV_T),
3942 	DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_HT_USB_XE),
3943 	DVB_USB_DEV(PINNACLE, PINNACLE_EXPRESSCARD_320CX),
3944 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV72E),
3945 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73E),
3946 	DVB_USB_DEV(YUAN, YUAN_EC372S),
3947 	DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_HT_EXPRESS),
3948 	DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_XXS),
3949 	DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2),
3950 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_TD_STICK_52009),
3951 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_NOVA_T_500_3),
3952 	DVB_USB_DEV(GIGABYTE, GIGABYTE_U8000),
3953 	DVB_USB_DEV(YUAN, YUAN_STK7700PH),
3954 	DVB_USB_DEV(ASUS, ASUS_U3000H),
3955 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV801E),
3956 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV801E_SE),
3957 	DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_EXPRESS),
3958 	DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_DT_XS_DIVERSITY_2),
3959 	DVB_USB_DEV(SONY, SONY_PLAYTV),
3960 	DVB_USB_DEV(YUAN, YUAN_PD378S),
3961 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_TIGER_ATSC),
3962 	DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_TIGER_ATSC_B210),
3963 	DVB_USB_DEV(YUAN, YUAN_MC770),
3964 	DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT),
3965 	DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT_Dlx),
3966 	DVB_USB_DEV(LEADTEK, LEADTEK_WINFAST_DTV_DONGLE_H),
3967 	DVB_USB_DEV(TERRATEC, TERRATEC_T3),
3968 	DVB_USB_DEV(TERRATEC, TERRATEC_T5),
3969 	DVB_USB_DEV(YUAN, YUAN_STK7700D),
3970 	DVB_USB_DEV(YUAN, YUAN_STK7700D_2),
3971 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73A),
3972 	DVB_USB_DEV(PCTV, PCTV_PINNACLE_PCTV73ESE),
3973 	DVB_USB_DEV(PCTV, PCTV_PINNACLE_PCTV282E),
3974 	DVB_USB_DEV(DIBCOM, DIBCOM_STK7770P),
3975 	DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_XXS_2),
3976 	DVB_USB_DEV(DIBCOM, DIBCOM_STK807XPVR),
3977 	DVB_USB_DEV(DIBCOM, DIBCOM_STK807XP),
3978 	DVB_USB_DEV_VER(PIXELVIEW, PIXELVIEW_SBTVD, 0x000, 0x3f00),
3979 	DVB_USB_DEV(EVOLUTEPC, EVOLUTEPC_TVWAY_PLUS),
3980 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV73ESE),
3981 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV282E),
3982 	DVB_USB_DEV(DIBCOM, DIBCOM_STK8096GP),
3983 	DVB_USB_DEV(ELGATO, ELGATO_EYETV_DIVERSITY),
3984 	DVB_USB_DEV(DIBCOM, DIBCOM_NIM9090M),
3985 	DVB_USB_DEV(DIBCOM, DIBCOM_NIM8096MD),
3986 	DVB_USB_DEV(DIBCOM, DIBCOM_NIM9090MD),
3987 	DVB_USB_DEV(DIBCOM, DIBCOM_NIM7090),
3988 	DVB_USB_DEV(DIBCOM, DIBCOM_TFE7090PVR),
3989 	DVB_USB_DEV(TECHNISAT, TECHNISAT_AIRSTAR_TELESTICK_2),
3990 	DVB_USB_DEV(MEDION, MEDION_CREATIX_CTX1921),
3991 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV340E),
3992 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV340E_SE),
3993 	DVB_USB_DEV(DIBCOM, DIBCOM_TFE7790P),
3994 	DVB_USB_DEV(DIBCOM, DIBCOM_TFE8096P),
3995 	DVB_USB_DEV(ELGATO, ELGATO_EYETV_DTT_2),
3996 	DVB_USB_DEV(PCTV, PCTV_2002E),
3997 	DVB_USB_DEV(PCTV, PCTV_2002E_SE),
3998 	DVB_USB_DEV(PCTV, PCTV_DIBCOM_STK8096PVR),
3999 	DVB_USB_DEV(DIBCOM, DIBCOM_STK8096PVR),
4000 	DVB_USB_DEV(HAMA, HAMA_DVBT_HYBRID),
4001 	DVB_USB_DEV(MICROSOFT, MICROSOFT_XBOX_ONE_TUNER),
4002 	{ }
4003 };
4004 
4005 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
4006 
4007 #define DIB0700_DEFAULT_DEVICE_PROPERTIES \
4008 	.caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
4009 	.usb_ctrl          = DEVICE_SPECIFIC, \
4010 	.firmware          = "dvb-usb-dib0700-1.20.fw", \
4011 	.download_firmware = dib0700_download_firmware, \
4012 	.no_reconnect      = 1, \
4013 	.size_of_priv      = sizeof(struct dib0700_state), \
4014 	.i2c_algo          = &dib0700_i2c_algo, \
4015 	.identify_state    = dib0700_identify_state
4016 
4017 #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
4018 	.streaming_ctrl   = dib0700_streaming_ctrl, \
4019 	.stream = { \
4020 		.type = USB_BULK, \
4021 		.count = 4, \
4022 		.endpoint = ep, \
4023 		.u = { \
4024 			.bulk = { \
4025 				.buffersize = 39480, \
4026 			} \
4027 		} \
4028 	}
4029 
4030 #define DIB0700_NUM_FRONTENDS(n) \
4031 	.num_frontends = n, \
4032 	.size_of_priv     = sizeof(struct dib0700_adapter_state)
4033 
4034 struct dvb_usb_device_properties dib0700_devices[] = {
4035 	{
4036 		DIB0700_DEFAULT_DEVICE_PROPERTIES,
4037 
4038 		.num_adapters = 1,
4039 		.adapter = {
4040 			{
4041 			DIB0700_NUM_FRONTENDS(1),
4042 			.fe = {{
4043 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4044 				.pid_filter_count = 32,
4045 				.pid_filter       = stk7700p_pid_filter,
4046 				.pid_filter_ctrl  = stk7700p_pid_filter_ctrl,
4047 				.frontend_attach  = stk7700p_frontend_attach,
4048 				.tuner_attach     = stk7700p_tuner_attach,
4049 
4050 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4051 			}},
4052 			},
4053 		},
4054 
4055 		.num_device_descs = 8,
4056 		.devices = {
4057 			{   "DiBcom STK7700P reference design",
4058 				{ &dib0700_usb_id_table[DIBCOM_STK7700P], &dib0700_usb_id_table[DIBCOM_STK7700P_PC] },
4059 				{ NULL },
4060 			},
4061 			{   "Hauppauge Nova-T Stick",
4062 				{ &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK], &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK_2], NULL },
4063 				{ NULL },
4064 			},
4065 			{   "AVerMedia AVerTV DVB-T Volar",
4066 				{ &dib0700_usb_id_table[AVERMEDIA_VOLAR], &dib0700_usb_id_table[AVERMEDIA_VOLAR_2] },
4067 				{ NULL },
4068 			},
4069 			{   "Compro Videomate U500",
4070 				{ &dib0700_usb_id_table[COMPRO_VIDEOMATE_U500], &dib0700_usb_id_table[COMPRO_VIDEOMATE_U500_PC] },
4071 				{ NULL },
4072 			},
4073 			{   "Uniwill STK7700P based (Hama and others)",
4074 				{ &dib0700_usb_id_table[UNIWILL_STK7700P], NULL },
4075 				{ NULL },
4076 			},
4077 			{   "Leadtek Winfast DTV Dongle (STK7700P based)",
4078 				{ &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_STK7700P], &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_STK7700P_2] },
4079 				{ NULL },
4080 			},
4081 			{   "AVerMedia AVerTV DVB-T Express",
4082 				{ &dib0700_usb_id_table[AVERMEDIA_EXPRESS] },
4083 				{ NULL },
4084 			},
4085 			{   "Gigabyte U7000",
4086 				{ &dib0700_usb_id_table[GIGABYTE_U7000], NULL },
4087 				{ NULL },
4088 			}
4089 		},
4090 
4091 		.rc.core = {
4092 			.rc_interval      = DEFAULT_RC_INTERVAL,
4093 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4094 			.rc_query         = dib0700_rc_query_old_firmware,
4095 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4096 					    RC_PROTO_BIT_RC6_MCE |
4097 					    RC_PROTO_BIT_NEC,
4098 			.change_protocol  = dib0700_change_protocol,
4099 		},
4100 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4101 
4102 		.num_adapters = 2,
4103 		.adapter = {
4104 			{
4105 			DIB0700_NUM_FRONTENDS(1),
4106 			.fe = {{
4107 				.frontend_attach  = bristol_frontend_attach,
4108 				.tuner_attach     = bristol_tuner_attach,
4109 
4110 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4111 			}},
4112 			}, {
4113 			DIB0700_NUM_FRONTENDS(1),
4114 			.fe = {{
4115 				.frontend_attach  = bristol_frontend_attach,
4116 				.tuner_attach     = bristol_tuner_attach,
4117 
4118 				DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4119 			}},
4120 			}
4121 		},
4122 
4123 		.num_device_descs = 1,
4124 		.devices = {
4125 			{   "Hauppauge Nova-T 500 Dual DVB-T",
4126 				{ &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500], &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500_2], NULL },
4127 				{ NULL },
4128 			},
4129 		},
4130 
4131 		.rc.core = {
4132 			.rc_interval      = DEFAULT_RC_INTERVAL,
4133 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4134 			.rc_query         = dib0700_rc_query_old_firmware,
4135 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4136 					    RC_PROTO_BIT_RC6_MCE |
4137 					    RC_PROTO_BIT_NEC,
4138 			.change_protocol = dib0700_change_protocol,
4139 		},
4140 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4141 
4142 		.num_adapters = 2,
4143 		.adapter = {
4144 			{
4145 			DIB0700_NUM_FRONTENDS(1),
4146 			.fe = {{
4147 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4148 				.pid_filter_count = 32,
4149 				.pid_filter       = stk70x0p_pid_filter,
4150 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4151 				.frontend_attach  = stk7700d_frontend_attach,
4152 				.tuner_attach     = stk7700d_tuner_attach,
4153 
4154 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4155 			}},
4156 			}, {
4157 			DIB0700_NUM_FRONTENDS(1),
4158 			.fe = {{
4159 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4160 				.pid_filter_count = 32,
4161 				.pid_filter       = stk70x0p_pid_filter,
4162 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4163 				.frontend_attach  = stk7700d_frontend_attach,
4164 				.tuner_attach     = stk7700d_tuner_attach,
4165 
4166 				DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4167 			}},
4168 			}
4169 		},
4170 
4171 		.num_device_descs = 5,
4172 		.devices = {
4173 			{   "Pinnacle PCTV 2000e",
4174 				{ &dib0700_usb_id_table[PINNACLE_PCTV2000E], NULL },
4175 				{ NULL },
4176 			},
4177 			{   "Terratec Cinergy DT XS Diversity",
4178 				{ &dib0700_usb_id_table[TERRATEC_CINERGY_DT_XS_DIVERSITY], NULL },
4179 				{ NULL },
4180 			},
4181 			{   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
4182 				{ &dib0700_usb_id_table[HAUPPAUGE_NOVA_TD_STICK], NULL },
4183 				{ NULL },
4184 			},
4185 			{   "DiBcom STK7700D reference design",
4186 				{ &dib0700_usb_id_table[DIBCOM_STK7700D], NULL },
4187 				{ NULL },
4188 			},
4189 			{   "YUAN High-Tech DiBcom STK7700D",
4190 				{ &dib0700_usb_id_table[YUAN_STK7700D_2], NULL },
4191 				{ NULL },
4192 			},
4193 
4194 		},
4195 
4196 		.rc.core = {
4197 			.rc_interval      = DEFAULT_RC_INTERVAL,
4198 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4199 			.rc_query         = dib0700_rc_query_old_firmware,
4200 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4201 					    RC_PROTO_BIT_RC6_MCE |
4202 					    RC_PROTO_BIT_NEC,
4203 			.change_protocol = dib0700_change_protocol,
4204 		},
4205 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4206 
4207 		.num_adapters = 1,
4208 		.adapter = {
4209 			{
4210 			DIB0700_NUM_FRONTENDS(1),
4211 			.fe = {{
4212 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4213 				.pid_filter_count = 32,
4214 				.pid_filter       = stk70x0p_pid_filter,
4215 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4216 				.frontend_attach  = stk7700P2_frontend_attach,
4217 				.tuner_attach     = stk7700d_tuner_attach,
4218 
4219 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4220 			}},
4221 			},
4222 		},
4223 
4224 		.num_device_descs = 3,
4225 		.devices = {
4226 			{   "ASUS My Cinema U3000 Mini DVBT Tuner",
4227 				{ &dib0700_usb_id_table[ASUS_U3000], NULL },
4228 				{ NULL },
4229 			},
4230 			{   "Yuan EC372S",
4231 				{ &dib0700_usb_id_table[YUAN_EC372S], NULL },
4232 				{ NULL },
4233 			},
4234 			{   "Terratec Cinergy T Express",
4235 				{ &dib0700_usb_id_table[TERRATEC_CINERGY_T_EXPRESS], NULL },
4236 				{ NULL },
4237 			}
4238 		},
4239 
4240 		.rc.core = {
4241 			.rc_interval      = DEFAULT_RC_INTERVAL,
4242 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4243 			.module_name	  = "dib0700",
4244 			.rc_query         = dib0700_rc_query_old_firmware,
4245 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4246 					    RC_PROTO_BIT_RC6_MCE |
4247 					    RC_PROTO_BIT_NEC,
4248 			.change_protocol = dib0700_change_protocol,
4249 		},
4250 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4251 
4252 		.num_adapters = 1,
4253 		.adapter = {
4254 			{
4255 			DIB0700_NUM_FRONTENDS(1),
4256 			.fe = {{
4257 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4258 				.pid_filter_count = 32,
4259 				.pid_filter       = stk70x0p_pid_filter,
4260 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4261 				.frontend_attach  = stk7070p_frontend_attach,
4262 				.tuner_attach     = dib7070p_tuner_attach,
4263 
4264 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4265 			}},
4266 			},
4267 		},
4268 
4269 		.num_device_descs = 12,
4270 		.devices = {
4271 			{   "DiBcom STK7070P reference design",
4272 				{ &dib0700_usb_id_table[DIBCOM_STK7070P], NULL },
4273 				{ NULL },
4274 			},
4275 			{   "Pinnacle PCTV DVB-T Flash Stick",
4276 				{ &dib0700_usb_id_table[PINNACLE_PCTV_DVB_T_FLASH], NULL },
4277 				{ NULL },
4278 			},
4279 			{   "Artec T14BR DVB-T",
4280 				{ &dib0700_usb_id_table[ULTIMA_ARTEC_T14BR], NULL },
4281 				{ NULL },
4282 			},
4283 			{   "ASUS My Cinema U3100 Mini DVBT Tuner",
4284 				{ &dib0700_usb_id_table[ASUS_U3100], NULL },
4285 				{ NULL },
4286 			},
4287 			{   "Hauppauge Nova-T Stick",
4288 				{ &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_STICK_3], NULL },
4289 				{ NULL },
4290 			},
4291 			{   "Hauppauge Nova-T MyTV.t",
4292 				{ &dib0700_usb_id_table[HAUPPAUGE_MYTV_T], NULL },
4293 				{ NULL },
4294 			},
4295 			{   "Pinnacle PCTV 72e",
4296 				{ &dib0700_usb_id_table[PINNACLE_PCTV72E], NULL },
4297 				{ NULL },
4298 			},
4299 			{   "Pinnacle PCTV 73e",
4300 				{ &dib0700_usb_id_table[PINNACLE_PCTV73E], NULL },
4301 				{ NULL },
4302 			},
4303 			{   "Elgato EyeTV DTT",
4304 				{ &dib0700_usb_id_table[ELGATO_EYETV_DTT], NULL },
4305 				{ NULL },
4306 			},
4307 			{   "Yuan PD378S",
4308 				{ &dib0700_usb_id_table[YUAN_PD378S], NULL },
4309 				{ NULL },
4310 			},
4311 			{   "Elgato EyeTV Dtt Dlx PD378S",
4312 				{ &dib0700_usb_id_table[ELGATO_EYETV_DTT_Dlx], NULL },
4313 				{ NULL },
4314 			},
4315 			{   "Elgato EyeTV DTT rev. 2",
4316 				{ &dib0700_usb_id_table[ELGATO_EYETV_DTT_2], NULL },
4317 				{ NULL },
4318 			},
4319 		},
4320 
4321 		.rc.core = {
4322 			.rc_interval      = DEFAULT_RC_INTERVAL,
4323 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4324 			.module_name	  = "dib0700",
4325 			.rc_query         = dib0700_rc_query_old_firmware,
4326 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4327 					    RC_PROTO_BIT_RC6_MCE |
4328 					    RC_PROTO_BIT_NEC,
4329 			.change_protocol  = dib0700_change_protocol,
4330 		},
4331 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4332 
4333 		.num_adapters = 1,
4334 		.adapter = {
4335 			{
4336 			DIB0700_NUM_FRONTENDS(1),
4337 			.fe = {{
4338 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4339 				.pid_filter_count = 32,
4340 				.pid_filter       = stk70x0p_pid_filter,
4341 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4342 				.frontend_attach  = stk7070p_frontend_attach,
4343 				.tuner_attach     = dib7070p_tuner_attach,
4344 
4345 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4346 			}},
4347 			},
4348 		},
4349 
4350 		.num_device_descs = 3,
4351 		.devices = {
4352 			{   "Pinnacle PCTV 73A",
4353 				{ &dib0700_usb_id_table[PINNACLE_PCTV73A], NULL },
4354 				{ NULL },
4355 			},
4356 			{   "Pinnacle PCTV 73e SE",
4357 				{ &dib0700_usb_id_table[PCTV_PINNACLE_PCTV73ESE], &dib0700_usb_id_table[PINNACLE_PCTV73ESE], NULL },
4358 				{ NULL },
4359 			},
4360 			{   "Pinnacle PCTV 282e",
4361 				{ &dib0700_usb_id_table[PCTV_PINNACLE_PCTV282E], &dib0700_usb_id_table[PINNACLE_PCTV282E], NULL },
4362 				{ NULL },
4363 			},
4364 		},
4365 
4366 		.rc.core = {
4367 			.rc_interval      = DEFAULT_RC_INTERVAL,
4368 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4369 			.module_name	  = "dib0700",
4370 			.rc_query         = dib0700_rc_query_old_firmware,
4371 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4372 					    RC_PROTO_BIT_RC6_MCE |
4373 					    RC_PROTO_BIT_NEC,
4374 			.change_protocol  = dib0700_change_protocol,
4375 		},
4376 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4377 
4378 		.num_adapters = 2,
4379 		.adapter = {
4380 			{
4381 			DIB0700_NUM_FRONTENDS(1),
4382 			.fe = {{
4383 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4384 				.pid_filter_count = 32,
4385 				.pid_filter       = stk70x0p_pid_filter,
4386 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4387 				.frontend_attach  = novatd_frontend_attach,
4388 				.tuner_attach     = dib7070p_tuner_attach,
4389 
4390 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4391 			}},
4392 			}, {
4393 			DIB0700_NUM_FRONTENDS(1),
4394 			.fe = {{
4395 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4396 				.pid_filter_count = 32,
4397 				.pid_filter       = stk70x0p_pid_filter,
4398 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4399 				.frontend_attach  = novatd_frontend_attach,
4400 				.tuner_attach     = dib7070p_tuner_attach,
4401 
4402 				DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4403 			}},
4404 			}
4405 		},
4406 
4407 		.num_device_descs = 3,
4408 		.devices = {
4409 			{   "Hauppauge Nova-TD Stick (52009)",
4410 				{ &dib0700_usb_id_table[HAUPPAUGE_NOVA_TD_STICK_52009], NULL },
4411 				{ NULL },
4412 			},
4413 			{   "PCTV 2002e",
4414 				{ &dib0700_usb_id_table[PCTV_2002E], NULL },
4415 				{ NULL },
4416 			},
4417 			{   "PCTV 2002e SE",
4418 				{ &dib0700_usb_id_table[PCTV_2002E_SE], NULL },
4419 				{ NULL },
4420 			},
4421 		},
4422 
4423 		.rc.core = {
4424 			.rc_interval      = DEFAULT_RC_INTERVAL,
4425 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4426 			.module_name	  = "dib0700",
4427 			.rc_query         = dib0700_rc_query_old_firmware,
4428 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4429 					    RC_PROTO_BIT_RC6_MCE |
4430 					    RC_PROTO_BIT_NEC,
4431 			.change_protocol = dib0700_change_protocol,
4432 		},
4433 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4434 
4435 		.num_adapters = 2,
4436 		.adapter = {
4437 			{
4438 			DIB0700_NUM_FRONTENDS(1),
4439 			.fe = {{
4440 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4441 				.pid_filter_count = 32,
4442 				.pid_filter       = stk70x0p_pid_filter,
4443 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4444 				.frontend_attach  = stk7070pd_frontend_attach0,
4445 				.tuner_attach     = dib7070p_tuner_attach,
4446 
4447 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4448 			}},
4449 			}, {
4450 			DIB0700_NUM_FRONTENDS(1),
4451 			.fe = {{
4452 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4453 				.pid_filter_count = 32,
4454 				.pid_filter       = stk70x0p_pid_filter,
4455 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4456 				.frontend_attach  = stk7070pd_frontend_attach1,
4457 				.tuner_attach     = dib7070p_tuner_attach,
4458 
4459 				DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4460 			}},
4461 			}
4462 		},
4463 
4464 		.num_device_descs = 5,
4465 		.devices = {
4466 			{   "DiBcom STK7070PD reference design",
4467 				{ &dib0700_usb_id_table[DIBCOM_STK7070PD], NULL },
4468 				{ NULL },
4469 			},
4470 			{   "Pinnacle PCTV Dual DVB-T Diversity Stick",
4471 				{ &dib0700_usb_id_table[PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T], NULL },
4472 				{ NULL },
4473 			},
4474 			{   "Hauppauge Nova-TD-500 (84xxx)",
4475 				{ &dib0700_usb_id_table[HAUPPAUGE_NOVA_T_500_3], NULL },
4476 				{ NULL },
4477 			},
4478 			{  "Terratec Cinergy DT USB XS Diversity/ T5",
4479 				{ &dib0700_usb_id_table[TERRATEC_CINERGY_DT_XS_DIVERSITY_2],
4480 					&dib0700_usb_id_table[TERRATEC_T5], NULL},
4481 				{ NULL },
4482 			},
4483 			{  "Sony PlayTV",
4484 				{ &dib0700_usb_id_table[SONY_PLAYTV], NULL },
4485 				{ NULL },
4486 			},
4487 		},
4488 
4489 		.rc.core = {
4490 			.rc_interval      = DEFAULT_RC_INTERVAL,
4491 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4492 			.module_name	  = "dib0700",
4493 			.rc_query         = dib0700_rc_query_old_firmware,
4494 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4495 					    RC_PROTO_BIT_RC6_MCE |
4496 					    RC_PROTO_BIT_NEC,
4497 			.change_protocol = dib0700_change_protocol,
4498 		},
4499 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4500 
4501 		.num_adapters = 2,
4502 		.adapter = {
4503 			{
4504 			DIB0700_NUM_FRONTENDS(1),
4505 			.fe = {{
4506 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4507 				.pid_filter_count = 32,
4508 				.pid_filter       = stk70x0p_pid_filter,
4509 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4510 				.frontend_attach  = stk7070pd_frontend_attach0,
4511 				.tuner_attach     = dib7070p_tuner_attach,
4512 
4513 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4514 			}},
4515 			}, {
4516 			DIB0700_NUM_FRONTENDS(1),
4517 			.fe = {{
4518 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4519 				.pid_filter_count = 32,
4520 				.pid_filter       = stk70x0p_pid_filter,
4521 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4522 				.frontend_attach  = stk7070pd_frontend_attach1,
4523 				.tuner_attach     = dib7070p_tuner_attach,
4524 
4525 				DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4526 			}},
4527 			}
4528 		},
4529 
4530 		.num_device_descs = 1,
4531 		.devices = {
4532 			{   "Elgato EyeTV Diversity",
4533 				{ &dib0700_usb_id_table[ELGATO_EYETV_DIVERSITY], NULL },
4534 				{ NULL },
4535 			},
4536 		},
4537 
4538 		.rc.core = {
4539 			.rc_interval      = DEFAULT_RC_INTERVAL,
4540 			.rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4541 			.module_name	  = "dib0700",
4542 			.rc_query         = dib0700_rc_query_old_firmware,
4543 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4544 					    RC_PROTO_BIT_RC6_MCE |
4545 					    RC_PROTO_BIT_NEC,
4546 			.change_protocol  = dib0700_change_protocol,
4547 		},
4548 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4549 
4550 		.num_adapters = 1,
4551 		.adapter = {
4552 			{
4553 			DIB0700_NUM_FRONTENDS(1),
4554 			.fe = {{
4555 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4556 				.pid_filter_count = 32,
4557 				.pid_filter       = stk70x0p_pid_filter,
4558 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4559 				.frontend_attach  = stk7700ph_frontend_attach,
4560 				.tuner_attach     = stk7700ph_tuner_attach,
4561 
4562 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4563 			}},
4564 			},
4565 		},
4566 
4567 		.num_device_descs = 10,
4568 		.devices = {
4569 			{   "Terratec Cinergy HT USB XE",
4570 				{ &dib0700_usb_id_table[TERRATEC_CINERGY_HT_USB_XE], NULL },
4571 				{ NULL },
4572 			},
4573 			{   "Pinnacle Expresscard 320cx",
4574 				{ &dib0700_usb_id_table[PINNACLE_EXPRESSCARD_320CX], NULL },
4575 				{ NULL },
4576 			},
4577 			{   "Terratec Cinergy HT Express",
4578 				{ &dib0700_usb_id_table[TERRATEC_CINERGY_HT_EXPRESS], NULL },
4579 				{ NULL },
4580 			},
4581 			{   "Gigabyte U8000-RH",
4582 				{ &dib0700_usb_id_table[GIGABYTE_U8000], NULL },
4583 				{ NULL },
4584 			},
4585 			{   "YUAN High-Tech STK7700PH",
4586 				{ &dib0700_usb_id_table[YUAN_STK7700PH], NULL },
4587 				{ NULL },
4588 			},
4589 			{   "Asus My Cinema-U3000Hybrid",
4590 				{ &dib0700_usb_id_table[ASUS_U3000H], NULL },
4591 				{ NULL },
4592 			},
4593 			{   "YUAN High-Tech MC770",
4594 				{ &dib0700_usb_id_table[YUAN_MC770], NULL },
4595 				{ NULL },
4596 			},
4597 			{   "Leadtek WinFast DTV Dongle H",
4598 				{ &dib0700_usb_id_table[LEADTEK_WINFAST_DTV_DONGLE_H], NULL },
4599 				{ NULL },
4600 			},
4601 			{   "YUAN High-Tech STK7700D",
4602 				{ &dib0700_usb_id_table[YUAN_STK7700D], NULL },
4603 				{ NULL },
4604 			},
4605 			{   "Hama DVB=T Hybrid USB Stick",
4606 				{ &dib0700_usb_id_table[HAMA_DVBT_HYBRID], NULL },
4607 				{ NULL },
4608 			},
4609 		},
4610 
4611 		.rc.core = {
4612 			.rc_interval      = DEFAULT_RC_INTERVAL,
4613 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4614 			.module_name	  = "dib0700",
4615 			.rc_query         = dib0700_rc_query_old_firmware,
4616 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4617 					    RC_PROTO_BIT_RC6_MCE |
4618 					    RC_PROTO_BIT_NEC,
4619 			.change_protocol  = dib0700_change_protocol,
4620 		},
4621 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4622 		.num_adapters = 1,
4623 		.adapter = {
4624 			{
4625 			DIB0700_NUM_FRONTENDS(1),
4626 			.fe = {{
4627 				.frontend_attach  = s5h1411_frontend_attach,
4628 				.tuner_attach     = xc5000_tuner_attach,
4629 
4630 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4631 			}},
4632 			},
4633 		},
4634 
4635 		.num_device_descs = 2,
4636 		.devices = {
4637 			{   "Pinnacle PCTV HD Pro USB Stick",
4638 				{ &dib0700_usb_id_table[PINNACLE_PCTV801E], NULL },
4639 				{ NULL },
4640 			},
4641 			{   "Pinnacle PCTV HD USB Stick",
4642 				{ &dib0700_usb_id_table[PINNACLE_PCTV801E_SE], NULL },
4643 				{ NULL },
4644 			},
4645 		},
4646 
4647 		.rc.core = {
4648 			.rc_interval      = DEFAULT_RC_INTERVAL,
4649 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4650 			.module_name	  = "dib0700",
4651 			.rc_query         = dib0700_rc_query_old_firmware,
4652 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4653 					    RC_PROTO_BIT_RC6_MCE |
4654 					    RC_PROTO_BIT_NEC,
4655 			.change_protocol  = dib0700_change_protocol,
4656 		},
4657 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4658 		.num_adapters = 1,
4659 		.adapter = {
4660 			{
4661 			DIB0700_NUM_FRONTENDS(1),
4662 			.fe = {{
4663 				.frontend_attach  = lgdt3305_frontend_attach,
4664 				.tuner_attach     = mxl5007t_tuner_attach,
4665 
4666 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4667 			}},
4668 			},
4669 		},
4670 
4671 		.num_device_descs = 2,
4672 		.devices = {
4673 			{   "Hauppauge ATSC MiniCard (B200)",
4674 				{ &dib0700_usb_id_table[HAUPPAUGE_TIGER_ATSC], NULL },
4675 				{ NULL },
4676 			},
4677 			{   "Hauppauge ATSC MiniCard (B210)",
4678 				{ &dib0700_usb_id_table[HAUPPAUGE_TIGER_ATSC_B210], NULL },
4679 				{ NULL },
4680 			},
4681 		},
4682 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4683 
4684 		.num_adapters = 1,
4685 		.adapter = {
4686 			{
4687 			DIB0700_NUM_FRONTENDS(1),
4688 			.fe = {{
4689 				.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4690 				.pid_filter_count = 32,
4691 				.pid_filter       = stk70x0p_pid_filter,
4692 				.pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
4693 				.frontend_attach  = stk7770p_frontend_attach,
4694 				.tuner_attach     = dib7770p_tuner_attach,
4695 
4696 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4697 			}},
4698 			},
4699 		},
4700 
4701 		.num_device_descs = 4,
4702 		.devices = {
4703 			{   "DiBcom STK7770P reference design",
4704 				{ &dib0700_usb_id_table[DIBCOM_STK7770P], NULL },
4705 				{ NULL },
4706 			},
4707 			{   "Terratec Cinergy T USB XXS (HD)/ T3",
4708 				{ &dib0700_usb_id_table[TERRATEC_CINERGY_T_XXS],
4709 					&dib0700_usb_id_table[TERRATEC_T3],
4710 					&dib0700_usb_id_table[TERRATEC_CINERGY_T_XXS_2], NULL},
4711 				{ NULL },
4712 			},
4713 			{   "TechniSat AirStar TeleStick 2",
4714 				{ &dib0700_usb_id_table[TECHNISAT_AIRSTAR_TELESTICK_2], NULL },
4715 				{ NULL },
4716 			},
4717 			{   "Medion CTX1921 DVB-T USB",
4718 				{ &dib0700_usb_id_table[MEDION_CREATIX_CTX1921], 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 | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4740 				.pid_filter_count = 32,
4741 				.pid_filter = stk80xx_pid_filter,
4742 				.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4743 				.frontend_attach  = stk807x_frontend_attach,
4744 				.tuner_attach     = dib807x_tuner_attach,
4745 
4746 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4747 			}},
4748 			},
4749 		},
4750 
4751 		.num_device_descs = 3,
4752 		.devices = {
4753 			{   "DiBcom STK807xP reference design",
4754 				{ &dib0700_usb_id_table[DIBCOM_STK807XP], NULL },
4755 				{ NULL },
4756 			},
4757 			{   "Prolink Pixelview SBTVD",
4758 				{ &dib0700_usb_id_table[PIXELVIEW_SBTVD], NULL },
4759 				{ NULL },
4760 			},
4761 			{   "EvolutePC TVWay+",
4762 				{ &dib0700_usb_id_table[EVOLUTEPC_TVWAY_PLUS], NULL },
4763 				{ NULL },
4764 			},
4765 		},
4766 
4767 		.rc.core = {
4768 			.rc_interval      = DEFAULT_RC_INTERVAL,
4769 			.rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
4770 			.module_name	  = "dib0700",
4771 			.rc_query         = dib0700_rc_query_old_firmware,
4772 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4773 					    RC_PROTO_BIT_RC6_MCE |
4774 					    RC_PROTO_BIT_NEC,
4775 			.change_protocol  = dib0700_change_protocol,
4776 		},
4777 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4778 		.num_adapters = 2,
4779 		.adapter = {
4780 			{
4781 			DIB0700_NUM_FRONTENDS(1),
4782 			.fe = {{
4783 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4784 				.pid_filter_count = 32,
4785 				.pid_filter = stk80xx_pid_filter,
4786 				.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4787 				.frontend_attach  = stk807xpvr_frontend_attach0,
4788 				.tuner_attach     = dib807x_tuner_attach,
4789 
4790 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4791 			}},
4792 			},
4793 			{
4794 			DIB0700_NUM_FRONTENDS(1),
4795 			.fe = {{
4796 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4797 				.pid_filter_count = 32,
4798 				.pid_filter = stk80xx_pid_filter,
4799 				.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4800 				.frontend_attach  = stk807xpvr_frontend_attach1,
4801 				.tuner_attach     = dib807x_tuner_attach,
4802 
4803 				DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
4804 			}},
4805 			},
4806 		},
4807 
4808 		.num_device_descs = 1,
4809 		.devices = {
4810 			{   "DiBcom STK807xPVR reference design",
4811 				{ &dib0700_usb_id_table[DIBCOM_STK807XPVR], NULL },
4812 				{ NULL },
4813 			},
4814 		},
4815 
4816 		.rc.core = {
4817 			.rc_interval      = DEFAULT_RC_INTERVAL,
4818 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4819 			.module_name	  = "dib0700",
4820 			.rc_query         = dib0700_rc_query_old_firmware,
4821 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4822 					    RC_PROTO_BIT_RC6_MCE |
4823 					    RC_PROTO_BIT_NEC,
4824 			.change_protocol  = dib0700_change_protocol,
4825 		},
4826 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4827 		.num_adapters = 1,
4828 		.adapter = {
4829 			{
4830 			DIB0700_NUM_FRONTENDS(1),
4831 			.fe = {{
4832 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4833 					DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4834 				.pid_filter_count = 32,
4835 				.pid_filter = stk80xx_pid_filter,
4836 				.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4837 				.frontend_attach  = stk809x_frontend_attach,
4838 				.tuner_attach     = dib809x_tuner_attach,
4839 
4840 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4841 			}},
4842 			},
4843 		},
4844 
4845 		.num_device_descs = 1,
4846 		.devices = {
4847 			{   "DiBcom STK8096GP reference design",
4848 				{ &dib0700_usb_id_table[DIBCOM_STK8096GP], NULL },
4849 				{ NULL },
4850 			},
4851 		},
4852 
4853 		.rc.core = {
4854 			.rc_interval      = DEFAULT_RC_INTERVAL,
4855 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4856 			.module_name	  = "dib0700",
4857 			.rc_query         = dib0700_rc_query_old_firmware,
4858 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4859 					    RC_PROTO_BIT_RC6_MCE |
4860 					    RC_PROTO_BIT_NEC,
4861 			.change_protocol  = dib0700_change_protocol,
4862 		},
4863 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4864 		.num_adapters = 1,
4865 		.adapter = {
4866 			{
4867 			DIB0700_NUM_FRONTENDS(1),
4868 			.fe = {{
4869 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4870 					DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4871 				.pid_filter_count = 32,
4872 				.pid_filter = dib90x0_pid_filter,
4873 				.pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4874 				.frontend_attach  = stk9090m_frontend_attach,
4875 				.tuner_attach     = dib9090_tuner_attach,
4876 
4877 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4878 			}},
4879 			},
4880 		},
4881 
4882 		.num_device_descs = 1,
4883 		.devices = {
4884 			{   "DiBcom STK9090M reference design",
4885 				{ &dib0700_usb_id_table[DIBCOM_NIM9090M], NULL },
4886 				{ NULL },
4887 			},
4888 		},
4889 
4890 		.rc.core = {
4891 			.rc_interval      = DEFAULT_RC_INTERVAL,
4892 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4893 			.module_name	  = "dib0700",
4894 			.rc_query         = dib0700_rc_query_old_firmware,
4895 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4896 					    RC_PROTO_BIT_RC6_MCE |
4897 					    RC_PROTO_BIT_NEC,
4898 			.change_protocol  = dib0700_change_protocol,
4899 		},
4900 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4901 		.num_adapters = 1,
4902 		.adapter = {
4903 			{
4904 			DIB0700_NUM_FRONTENDS(1),
4905 			.fe = {{
4906 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4907 					DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4908 				.pid_filter_count = 32,
4909 				.pid_filter = stk80xx_pid_filter,
4910 				.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
4911 				.frontend_attach  = nim8096md_frontend_attach,
4912 				.tuner_attach     = nim8096md_tuner_attach,
4913 
4914 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4915 			}},
4916 			},
4917 		},
4918 
4919 		.num_device_descs = 1,
4920 		.devices = {
4921 			{   "DiBcom NIM8096MD reference design",
4922 				{ &dib0700_usb_id_table[DIBCOM_NIM8096MD], NULL },
4923 				{ NULL },
4924 			},
4925 		},
4926 
4927 		.rc.core = {
4928 			.rc_interval      = DEFAULT_RC_INTERVAL,
4929 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4930 			.module_name	  = "dib0700",
4931 			.rc_query         = dib0700_rc_query_old_firmware,
4932 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4933 					    RC_PROTO_BIT_RC6_MCE |
4934 					    RC_PROTO_BIT_NEC,
4935 			.change_protocol  = dib0700_change_protocol,
4936 		},
4937 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4938 		.num_adapters = 1,
4939 		.adapter = {
4940 			{
4941 			DIB0700_NUM_FRONTENDS(1),
4942 			.fe = {{
4943 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4944 					DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4945 				.pid_filter_count = 32,
4946 				.pid_filter = dib90x0_pid_filter,
4947 				.pid_filter_ctrl = dib90x0_pid_filter_ctrl,
4948 				.frontend_attach  = nim9090md_frontend_attach,
4949 				.tuner_attach     = nim9090md_tuner_attach,
4950 
4951 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4952 			}},
4953 			},
4954 		},
4955 
4956 		.num_device_descs = 1,
4957 		.devices = {
4958 			{   "DiBcom NIM9090MD reference design",
4959 				{ &dib0700_usb_id_table[DIBCOM_NIM9090MD], NULL },
4960 				{ NULL },
4961 			},
4962 		},
4963 
4964 		.rc.core = {
4965 			.rc_interval      = DEFAULT_RC_INTERVAL,
4966 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
4967 			.module_name	  = "dib0700",
4968 			.rc_query         = dib0700_rc_query_old_firmware,
4969 			.allowed_protos   = RC_PROTO_BIT_RC5 |
4970 					    RC_PROTO_BIT_RC6_MCE |
4971 					    RC_PROTO_BIT_NEC,
4972 			.change_protocol  = dib0700_change_protocol,
4973 		},
4974 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
4975 		.num_adapters = 1,
4976 		.adapter = {
4977 			{
4978 			DIB0700_NUM_FRONTENDS(1),
4979 			.fe = {{
4980 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
4981 					DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4982 				.pid_filter_count = 32,
4983 				.pid_filter = stk70x0p_pid_filter,
4984 				.pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
4985 				.frontend_attach  = nim7090_frontend_attach,
4986 				.tuner_attach     = nim7090_tuner_attach,
4987 
4988 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
4989 			}},
4990 			},
4991 		},
4992 
4993 		.num_device_descs = 1,
4994 		.devices = {
4995 			{   "DiBcom NIM7090 reference design",
4996 				{ &dib0700_usb_id_table[DIBCOM_NIM7090], NULL },
4997 				{ NULL },
4998 			},
4999 		},
5000 
5001 		.rc.core = {
5002 			.rc_interval      = DEFAULT_RC_INTERVAL,
5003 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5004 			.module_name	  = "dib0700",
5005 			.rc_query         = dib0700_rc_query_old_firmware,
5006 			.allowed_protos   = RC_PROTO_BIT_RC5 |
5007 					    RC_PROTO_BIT_RC6_MCE |
5008 					    RC_PROTO_BIT_NEC,
5009 			.change_protocol  = dib0700_change_protocol,
5010 		},
5011 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5012 		.num_adapters = 2,
5013 		.adapter = {
5014 			{
5015 			DIB0700_NUM_FRONTENDS(1),
5016 			.fe = {{
5017 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5018 					DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5019 				.pid_filter_count = 32,
5020 				.pid_filter = stk70x0p_pid_filter,
5021 				.pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5022 				.frontend_attach  = tfe7090pvr_frontend0_attach,
5023 				.tuner_attach     = tfe7090pvr_tuner0_attach,
5024 
5025 				DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5026 			}},
5027 			},
5028 			{
5029 			DIB0700_NUM_FRONTENDS(1),
5030 			.fe = {{
5031 				.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5032 					DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5033 				.pid_filter_count = 32,
5034 				.pid_filter = stk70x0p_pid_filter,
5035 				.pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5036 				.frontend_attach  = tfe7090pvr_frontend1_attach,
5037 				.tuner_attach     = tfe7090pvr_tuner1_attach,
5038 
5039 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5040 			}},
5041 			},
5042 		},
5043 
5044 		.num_device_descs = 1,
5045 		.devices = {
5046 			{   "DiBcom TFE7090PVR reference design",
5047 				{ &dib0700_usb_id_table[DIBCOM_TFE7090PVR], NULL },
5048 				{ NULL },
5049 			},
5050 		},
5051 
5052 		.rc.core = {
5053 			.rc_interval      = DEFAULT_RC_INTERVAL,
5054 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5055 			.module_name	  = "dib0700",
5056 			.rc_query         = dib0700_rc_query_old_firmware,
5057 			.allowed_protos   = RC_PROTO_BIT_RC5 |
5058 					    RC_PROTO_BIT_RC6_MCE |
5059 					    RC_PROTO_BIT_NEC,
5060 			.change_protocol  = dib0700_change_protocol,
5061 		},
5062 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5063 		.num_adapters = 1,
5064 		.adapter = {
5065 			{
5066 			DIB0700_NUM_FRONTENDS(1),
5067 			.fe = {{
5068 				.frontend_attach  = pctv340e_frontend_attach,
5069 				.tuner_attach     = xc4000_tuner_attach,
5070 
5071 				DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5072 			}},
5073 			},
5074 		},
5075 
5076 		.num_device_descs = 2,
5077 		.devices = {
5078 			{   "Pinnacle PCTV 340e HD Pro USB Stick",
5079 				{ &dib0700_usb_id_table[PINNACLE_PCTV340E], NULL },
5080 				{ NULL },
5081 			},
5082 			{   "Pinnacle PCTV Hybrid Stick Solo",
5083 				{ &dib0700_usb_id_table[PINNACLE_PCTV340E_SE], NULL },
5084 				{ NULL },
5085 			},
5086 		},
5087 		.rc.core = {
5088 			.rc_interval      = DEFAULT_RC_INTERVAL,
5089 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5090 			.module_name	  = "dib0700",
5091 			.rc_query         = dib0700_rc_query_old_firmware,
5092 			.allowed_protos   = RC_PROTO_BIT_RC5 |
5093 					    RC_PROTO_BIT_RC6_MCE |
5094 					    RC_PROTO_BIT_NEC,
5095 			.change_protocol  = dib0700_change_protocol,
5096 		},
5097 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5098 		.num_adapters = 1,
5099 		.adapter = {
5100 			{
5101 				DIB0700_NUM_FRONTENDS(1),
5102 				.fe = {{
5103 					.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5104 						DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5105 					.pid_filter_count = 32,
5106 					.pid_filter = stk70x0p_pid_filter,
5107 					.pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
5108 					.frontend_attach  = tfe7790p_frontend_attach,
5109 					.tuner_attach     = tfe7790p_tuner_attach,
5110 
5111 					DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5112 				} },
5113 			},
5114 		},
5115 
5116 		.num_device_descs = 1,
5117 		.devices = {
5118 			{   "DiBcom TFE7790P reference design",
5119 				{ &dib0700_usb_id_table[DIBCOM_TFE7790P], NULL },
5120 				{ NULL },
5121 			},
5122 		},
5123 
5124 		.rc.core = {
5125 			.rc_interval      = DEFAULT_RC_INTERVAL,
5126 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5127 			.module_name	  = "dib0700",
5128 			.rc_query         = dib0700_rc_query_old_firmware,
5129 			.allowed_protos   = RC_PROTO_BIT_RC5 |
5130 					    RC_PROTO_BIT_RC6_MCE |
5131 					    RC_PROTO_BIT_NEC,
5132 			.change_protocol  = dib0700_change_protocol,
5133 		},
5134 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5135 		.num_adapters = 1,
5136 		.adapter = {
5137 			{
5138 				DIB0700_NUM_FRONTENDS(1),
5139 				.fe = {{
5140 					.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5141 						DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5142 					.pid_filter_count = 32,
5143 					.pid_filter = stk80xx_pid_filter,
5144 					.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5145 					.frontend_attach  = tfe8096p_frontend_attach,
5146 					.tuner_attach     = tfe8096p_tuner_attach,
5147 
5148 					DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5149 
5150 				} },
5151 			},
5152 		},
5153 
5154 		.num_device_descs = 1,
5155 		.devices = {
5156 			{   "DiBcom TFE8096P reference design",
5157 				{ &dib0700_usb_id_table[DIBCOM_TFE8096P], NULL },
5158 				{ NULL },
5159 			},
5160 		},
5161 
5162 		.rc.core = {
5163 			.rc_interval      = DEFAULT_RC_INTERVAL,
5164 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5165 			.module_name	  = "dib0700",
5166 			.rc_query         = dib0700_rc_query_old_firmware,
5167 			.allowed_protos   = RC_PROTO_BIT_RC5 |
5168 					    RC_PROTO_BIT_RC6_MCE |
5169 					    RC_PROTO_BIT_NEC,
5170 			.change_protocol  = dib0700_change_protocol,
5171 		},
5172 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5173 		.num_adapters = 2,
5174 		.adapter = {
5175 			{
5176 				.num_frontends = 1,
5177 				.fe = {{
5178 					.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5179 						DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5180 					.pid_filter_count = 32,
5181 					.pid_filter = stk80xx_pid_filter,
5182 					.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5183 					.frontend_attach  = stk809x_frontend_attach,
5184 					.tuner_attach     = dib809x_tuner_attach,
5185 
5186 					DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
5187 				} },
5188 				.size_of_priv =
5189 					sizeof(struct dib0700_adapter_state),
5190 			}, {
5191 				.num_frontends = 1,
5192 				.fe = { {
5193 					.caps  = DVB_USB_ADAP_HAS_PID_FILTER |
5194 						DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
5195 					.pid_filter_count = 32,
5196 					.pid_filter = stk80xx_pid_filter,
5197 					.pid_filter_ctrl = stk80xx_pid_filter_ctrl,
5198 					.frontend_attach  = stk809x_frontend1_attach,
5199 					.tuner_attach     = dib809x_tuner_attach,
5200 
5201 					DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
5202 				} },
5203 				.size_of_priv =
5204 					sizeof(struct dib0700_adapter_state),
5205 			},
5206 		},
5207 		.num_device_descs = 1,
5208 		.devices = {
5209 			{   "DiBcom STK8096-PVR reference design",
5210 				{ &dib0700_usb_id_table[PCTV_DIBCOM_STK8096PVR],
5211 					&dib0700_usb_id_table[DIBCOM_STK8096PVR], NULL},
5212 				{ NULL },
5213 			},
5214 		},
5215 
5216 		.rc.core = {
5217 			.rc_interval      = DEFAULT_RC_INTERVAL,
5218 			.rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
5219 			.module_name  = "dib0700",
5220 			.rc_query         = dib0700_rc_query_old_firmware,
5221 			.allowed_protos   = RC_PROTO_BIT_RC5 |
5222 				RC_PROTO_BIT_RC6_MCE |
5223 				RC_PROTO_BIT_NEC,
5224 			.change_protocol  = dib0700_change_protocol,
5225 		},
5226 	}, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
5227 		.num_adapters = 1,
5228 		.adapter = {
5229 			{
5230 				DIB0700_NUM_FRONTENDS(1),
5231 				.fe = {{
5232 					.frontend_attach = xbox_one_attach,
5233 
5234 					DIB0700_DEFAULT_STREAMING_CONFIG(0x82),
5235 				} },
5236 			},
5237 		},
5238 		.num_device_descs = 1,
5239 		.devices = {
5240 			{ "Microsoft Xbox One Digital TV Tuner",
5241 				{ &dib0700_usb_id_table[MICROSOFT_XBOX_ONE_TUNER], NULL },
5242 				{ NULL },
5243 			},
5244 		},
5245 	},
5246 };
5247 
5248 int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
5249