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
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(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0); msleep(msecs: 10);
90	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1); msleep(msecs: 10);
91	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0); msleep(msecs: 10);
92	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1); msleep(msecs: 10);
93
94	if (force_lna_activation)
95	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
96	else
97	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 0);
98
99	if (dib3000mc_i2c_enumeration(i2c: &adap->dev->i2c_adap, no_of_demods: 2, DEFAULT_DIB3000P_I2C_ADDRESS, cfg: bristol_dib3000mc_config) != 0) {
100	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0); msleep(msecs: 10);
101	return -ENODEV;
102	}
103	}
104	st->mt2060_if1[adap->id] = 1220;
105	return (adap->fe_adap[0].fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
106	(10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
107	}
108
109	static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
110	{
111	struct i2c_msg msg[2] = {
112	{ .addr = 0x50, .flags = 0, .buf = &adrs, .len = 1 },
113	{ .addr = 0x50, .flags = I2C_M_RD, .buf = pval, .len = 1 },
114	};
115	if (i2c_transfer(adap, msgs: msg, num: 2) != 2) return -EREMOTEIO;
116	return 0;
117	}
118
119	static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
120	{
121	struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
122	struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(demod: adap->fe_adap[0].fe, gating: 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(adap: prim_i2c,adrs: 0x59 + adap->id,pval: &a)) if1=1220+a;
128	}
129	return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c,
130	&bristol_mt2060_config[adap->id], if1) == NULL ?
131	-ENODEV : 0;
132	}
133
134	/* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
135
136	/* MT226x */
137	static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
138	{
139	BAND_UHF,
140
141	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
142	* P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
143	(0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
144	| (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
145
146	1130,
147	21,
148
149	0,
150	118,
151
152	0,
153	3530,
154	1,
155	0,
156
157	65535,
158	33770,
159	65535,
160	23592,
161
162	0,
163	62,
164	255,
165	64,
166	64,
167	132,
168	192,
169	80,
170	80,
171
172	17,
173	27,
174	23,
175	51,
176
177	1,
178	}, {
179	BAND_VHF | BAND_LBAND,
180
181	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
182	* P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
183	(0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
184	| (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
185
186	2372,
187	21,
188
189	0,
190	118,
191
192	0,
193	3530,
194	1,
195	0,
196
197	65535,
198	0,
199	65535,
200	23592,
201
202	0,
203	128,
204	128,
205	128,
206	0,
207	128,
208	253,
209	81,
210	0,
211
212	17,
213	27,
214	23,
215	51,
216
217	1,
218	}
219	};
220
221	static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
222	.internal = 60000,
223	.sampling = 30000,
224	.pll_prediv = 1,
225	.pll_ratio = 8,
226	.pll_range = 3,
227	.pll_reset = 1,
228	.pll_bypass = 0,
229	.enable_refdiv = 0,
230	.bypclk_div = 0,
231	.IO_CLK_en_core = 1,
232	.ADClkSrc = 1,
233	.modulo = 2,
234	.sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
235	.ifreq = 0,
236	.timf = 20452225,
237	};
238
239	static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
240	{ .output_mpeg2_in_188_bytes = 1,
241	.hostbus_diversity = 1,
242	.tuner_is_baseband = 1,
243
244	.agc_config_count = 2,
245	.agc = stk7700d_7000p_mt2266_agc_config,
246	.bw = &stk7700d_mt2266_pll_config,
247
248	.gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
249	.gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
250	.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
251	},
252	{ .output_mpeg2_in_188_bytes = 1,
253	.hostbus_diversity = 1,
254	.tuner_is_baseband = 1,
255
256	.agc_config_count = 2,
257	.agc = stk7700d_7000p_mt2266_agc_config,
258	.bw = &stk7700d_mt2266_pll_config,
259
260	.gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
261	.gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
262	.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
263	}
264	};
265
266	static struct mt2266_config stk7700d_mt2266_config[2] = {
267	{ .i2c_address = 0x60
268	},
269	{ .i2c_address = 0x60
270	}
271	};
272
273	static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
274	{
275	struct dib0700_adapter_state *state = adap->priv;
276
277	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
278	return -ENODEV;
279
280	if (adap->id == 0) {
281	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
282	msleep(msecs: 10);
283	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
284	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
285	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
286	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
287	msleep(msecs: 10);
288	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
289	msleep(msecs: 10);
290	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
291	stk7700d_dib7000p_mt2266_config)
292	!= 0) {
293	err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__);
294	dvb_detach(state->dib7000p_ops.set_wbd_ref);
295	return -ENODEV;
296	}
297	}
298
299	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
300	0x80 + (adap->id << 1),
301	&stk7700d_dib7000p_mt2266_config[adap->id]);
302
303	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
304	}
305
306	static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
307	{
308	struct dib0700_adapter_state *state = adap->priv;
309
310	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
311	return -ENODEV;
312
313	if (adap->id == 0) {
314	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
315	msleep(msecs: 10);
316	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
317	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
318	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
319	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
320	msleep(msecs: 10);
321	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
322	msleep(msecs: 10);
323	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
324	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
325	stk7700d_dib7000p_mt2266_config)
326	!= 0) {
327	err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__);
328	dvb_detach(state->dib7000p_ops.set_wbd_ref);
329	return -ENODEV;
330	}
331	}
332
333	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
334	0x80 + (adap->id << 1),
335	&stk7700d_dib7000p_mt2266_config[adap->id]);
336
337	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
338	}
339
340	static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
341	{
342	struct i2c_adapter *tun_i2c;
343	struct dib0700_adapter_state *state = adap->priv;
344
345	tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
346	DIBX000_I2C_INTERFACE_TUNER, 1);
347	return dvb_attach(mt2266_attach, adap->fe_adap[0].fe, tun_i2c,
348	&stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
349	}
350
351	/* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
352	static struct dibx000_agc_config xc3028_agc_config = {
353	.band_caps = BAND_VHF | BAND_UHF,
354	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
355	* P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
356	* P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
357	.setup = (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
358	.inv_gain = 712,
359	.time_stabiliz = 21,
360	.alpha_level = 0,
361	.thlock = 118,
362	.wbd_inv = 0,
363	.wbd_ref = 2867,
364	.wbd_sel = 0,
365	.wbd_alpha = 2,
366	.agc1_max = 0,
367	.agc1_min = 0,
368	.agc2_max = 39718,
369	.agc2_min = 9930,
370	.agc1_pt1 = 0,
371	.agc1_pt2 = 0,
372	.agc1_pt3 = 0,
373	.agc1_slope1 = 0,
374	.agc1_slope2 = 0,
375	.agc2_pt1 = 0,
376	.agc2_pt2 = 128,
377	.agc2_slope1 = 29,
378	.agc2_slope2 = 29,
379	.alpha_mant = 17,
380	.alpha_exp = 27,
381	.beta_mant = 23,
382	.beta_exp = 51,
383	.perform_agc_softsplit = 1,
384	};
385
386	/* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
387	static struct dibx000_bandwidth_config xc3028_bw_config = {
388	.internal = 60000,
389	.sampling = 30000,
390	.pll_prediv = 1,
391	.pll_ratio = 8,
392	.pll_range = 3,
393	.pll_reset = 1,
394	.pll_bypass = 0,
395	.enable_refdiv = 0,
396	.bypclk_div = 0,
397	.IO_CLK_en_core = 1,
398	.ADClkSrc = 1,
399	.modulo = 0,
400	.sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
401	.ifreq = (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
402	.timf = 20452225,
403	.xtal_hz = 30000000,
404	};
405
406	static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
407	.output_mpeg2_in_188_bytes = 1,
408	.tuner_is_baseband = 1,
409
410	.agc_config_count = 1,
411	.agc = &xc3028_agc_config,
412	.bw = &xc3028_bw_config,
413
414	.gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
415	.gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
416	.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
417	};
418
419	static int stk7700ph_xc3028_callback(void *ptr, int component,
420	int command, int arg)
421	{
422	struct dvb_usb_adapter *adap = ptr;
423	struct dib0700_adapter_state *state = adap->priv;
424
425	switch (command) {
426	case XC2028_TUNER_RESET:
427	/* Send the tuner in then out of reset */
428	state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 0);
429	msleep(msecs: 10);
430	state->dib7000p_ops.set_gpio(adap->fe_adap[0].fe, 8, 0, 1);
431	break;
432	case XC2028_RESET_CLK:
433	case XC2028_I2C_FLUSH:
434	break;
435	default:
436	err("%s: unknown command %d, arg %d\n", __func__,
437	command, arg);
438	return -EINVAL;
439	}
440	return 0;
441	}
442
443	static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
444	.fname = XC2028_DEFAULT_FIRMWARE,
445	.max_len = 64,
446	.demod = XC3028_FE_DIBCOM52,
447	};
448
449	static struct xc2028_config stk7700ph_xc3028_config = {
450	.i2c_addr = 0x61,
451	.ctrl = &stk7700ph_xc3028_ctrl,
452	};
453
454	static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
455	{
456	struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
457	struct dib0700_adapter_state *state = adap->priv;
458
459	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
460	return -ENODEV;
461
462	if (desc->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
463	desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
464	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
465	else
466	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
467	msleep(msecs: 20);
468	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
469	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
470	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
471	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
472	msleep(msecs: 10);
473	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
474	msleep(msecs: 20);
475	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
476	msleep(msecs: 10);
477
478	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
479	&stk7700ph_dib7700_xc3028_config) != 0) {
480	err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
481	__func__);
482	dvb_detach(state->dib7000p_ops.set_wbd_ref);
483	return -ENODEV;
484	}
485
486	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
487	&stk7700ph_dib7700_xc3028_config);
488
489	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
490	}
491
492	static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
493	{
494	struct i2c_adapter *tun_i2c;
495	struct dib0700_adapter_state *state = adap->priv;
496
497	tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
498	DIBX000_I2C_INTERFACE_TUNER, 1);
499
500	stk7700ph_xc3028_config.i2c_adap = tun_i2c;
501
502	/* FIXME: generalize & move to common area */
503	adap->fe_adap[0].fe->callback = stk7700ph_xc3028_callback;
504
505	return dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &stk7700ph_xc3028_config)
506	== NULL ? -ENODEV : 0;
507	}
508
509	#define DEFAULT_RC_INTERVAL 50
510
511	/*
512	* This function is used only when firmware is < 1.20 version. Newer
513	* firmwares use bulk mode, with functions implemented at dib0700_core,
514	* at dib0700_rc_urb_completion()
515	*/
516	static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
517	{
518	enum rc_proto protocol;
519	u32 scancode;
520	u8 toggle;
521	int i;
522	struct dib0700_state *st = d->priv;
523
524	if (st->fw_version >= 0x10200) {
525	/* For 1.20 firmware , We need to keep the RC polling
526	callback so we can reuse the input device setup in
527	dvb-usb-remote.c. However, the actual work is being done
528	in the bulk URB completion handler. */
529	return 0;
530	}
531
532	st->buf[0] = REQUEST_POLL_RC;
533	st->buf[1] = 0;
534
535	i = dib0700_ctrl_rd(d, tx: st->buf, txlen: 2, rx: st->buf, rxlen: 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(dev: 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(dev: d->rc_dev, protocol, scancode, toggle);
573	return 0;
574	}
575
576	/* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
577	static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
578	BAND_UHF | BAND_VHF,
579
580	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
581	* P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
582	(0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
583	| (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
584
585	712,
586	41,
587
588	0,
589	118,
590
591	0,
592	4095,
593	0,
594	0,
595
596	42598,
597	17694,
598	45875,
599	2621,
600	0,
601	76,
602	139,
603	52,
604	59,
605	107,
606	172,
607	57,
608	70,
609
610	21,
611	25,
612	28,
613	48,
614
615	1,
616	{ 0,
617	107,
618	51800,
619	24700
620	},
621	};
622
623	static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
624	.band_caps = BAND_UHF | BAND_VHF,
625	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
626	* P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
627	.setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
628	.inv_gain = 712,
629	.time_stabiliz = 41,
630	.alpha_level = 0,
631	.thlock = 118,
632	.wbd_inv = 0,
633	.wbd_ref = 4095,
634	.wbd_sel = 0,
635	.wbd_alpha = 0,
636	.agc1_max = 42598,
637	.agc1_min = 16384,
638	.agc2_max = 42598,
639	.agc2_min = 0,
640	.agc1_pt1 = 0,
641	.agc1_pt2 = 137,
642	.agc1_pt3 = 255,
643	.agc1_slope1 = 0,
644	.agc1_slope2 = 255,
645	.agc2_pt1 = 0,
646	.agc2_pt2 = 0,
647	.agc2_slope1 = 0,
648	.agc2_slope2 = 41,
649	.alpha_mant = 15,
650	.alpha_exp = 25,
651	.beta_mant = 28,
652	.beta_exp = 48,
653	.perform_agc_softsplit = 0,
654	};
655
656	static struct dibx000_bandwidth_config stk7700p_pll_config = {
657	.internal = 60000,
658	.sampling = 30000,
659	.pll_prediv = 1,
660	.pll_ratio = 8,
661	.pll_range = 3,
662	.pll_reset = 1,
663	.pll_bypass = 0,
664	.enable_refdiv = 0,
665	.bypclk_div = 0,
666	.IO_CLK_en_core = 1,
667	.ADClkSrc = 1,
668	.modulo = 0,
669	.sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
670	.ifreq = 60258167,
671	.timf = 20452225,
672	.xtal_hz = 30000000,
673	};
674
675	static struct dib7000m_config stk7700p_dib7000m_config = {
676	.dvbt_mode = 1,
677	.output_mpeg2_in_188_bytes = 1,
678	.quartz_direct = 1,
679
680	.agc_config_count = 1,
681	.agc = &stk7700p_7000m_mt2060_agc_config,
682	.bw = &stk7700p_pll_config,
683
684	.gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
685	.gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
686	.gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
687	};
688
689	static struct dib7000p_config stk7700p_dib7000p_config = {
690	.output_mpeg2_in_188_bytes = 1,
691
692	.agc_config_count = 1,
693	.agc = &stk7700p_7000p_mt2060_agc_config,
694	.bw = &stk7700p_pll_config,
695
696	.gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
697	.gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
698	.gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
699	};
700
701	static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
702	{
703	struct dib0700_state *st = adap->dev->priv;
704	struct dib0700_adapter_state *state = adap->priv;
705
706	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
707	return -ENODEV;
708
709	/* unless there is no real power management in DVB - we leave the device on GPIO6 */
710
711	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
712	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0); msleep(msecs: 50);
713
714	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1); msleep(msecs: 10);
715	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
716
717	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0); msleep(msecs: 10);
718	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
719	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1); msleep(msecs: 100);
720
721	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
722
723	st->mt2060_if1[0] = 1220;
724
725	if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap)) {
726	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
727	st->is_dib7000pc = 1;
728	} else {
729	memset(&state->dib7000p_ops, 0, sizeof(state->dib7000p_ops));
730	adap->fe_adap[0].fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
731	}
732
733	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
734	}
735
736	static struct mt2060_config stk7700p_mt2060_config = {
737	0x60
738	};
739
740	static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
741	{
742	struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
743	struct dib0700_state *st = adap->dev->priv;
744	struct i2c_adapter *tun_i2c;
745	struct dib0700_adapter_state *state = adap->priv;
746	s8 a;
747	int if1=1220;
748
749	if (adap->dev->udev->descriptor.idVendor == cpu_to_le16(USB_VID_HAUPPAUGE) &&
750	adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
751	if (!eeprom_read(adap: prim_i2c,adrs: 0x58,pval: &a)) if1=1220+a;
752	}
753	if (st->is_dib7000pc)
754	tun_i2c = state->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
755	else
756	tun_i2c = dib7000m_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
757
758	return dvb_attach(mt2060_attach, adap->fe_adap[0].fe, tun_i2c, &stk7700p_mt2060_config,
759	if1) == NULL ? -ENODEV : 0;
760	}
761
762	/* DIB7070 generic */
763	static struct dibx000_agc_config dib7070_agc_config = {
764	.band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
765	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
766	* P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
767	.setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
768	.inv_gain = 600,
769	.time_stabiliz = 10,
770	.alpha_level = 0,
771	.thlock = 118,
772	.wbd_inv = 0,
773	.wbd_ref = 3530,
774	.wbd_sel = 1,
775	.wbd_alpha = 5,
776	.agc1_max = 65535,
777	.agc1_min = 0,
778	.agc2_max = 65535,
779	.agc2_min = 0,
780	.agc1_pt1 = 0,
781	.agc1_pt2 = 40,
782	.agc1_pt3 = 183,
783	.agc1_slope1 = 206,
784	.agc1_slope2 = 255,
785	.agc2_pt1 = 72,
786	.agc2_pt2 = 152,
787	.agc2_slope1 = 88,
788	.agc2_slope2 = 90,
789	.alpha_mant = 17,
790	.alpha_exp = 27,
791	.beta_mant = 23,
792	.beta_exp = 51,
793	.perform_agc_softsplit = 0,
794	};
795
796	static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
797	{
798	struct dvb_usb_adapter *adap = fe->dvb->priv;
799	struct dib0700_adapter_state *state = adap->priv;
800
801	deb_info("reset: %d", onoff);
802	return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
803	}
804
805	static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
806	{
807	struct dvb_usb_adapter *adap = fe->dvb->priv;
808	struct dib0700_adapter_state *state = adap->priv;
809
810	deb_info("sleep: %d", onoff);
811	return state->dib7000p_ops.set_gpio(fe, 9, 0, onoff);
812	}
813
814	static struct dib0070_config dib7070p_dib0070_config[2] = {
815	{
816	.i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
817	.reset = dib7070_tuner_reset,
818	.sleep = dib7070_tuner_sleep,
819	.clock_khz = 12000,
820	.clock_pad_drive = 4,
821	.charge_pump = 2,
822	}, {
823	.i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
824	.reset = dib7070_tuner_reset,
825	.sleep = dib7070_tuner_sleep,
826	.clock_khz = 12000,
827	.charge_pump = 2,
828	}
829	};
830
831	static struct dib0070_config dib7770p_dib0070_config = {
832	.i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
833	.reset = dib7070_tuner_reset,
834	.sleep = dib7070_tuner_sleep,
835	.clock_khz = 12000,
836	.clock_pad_drive = 0,
837	.flip_chip = 1,
838	.charge_pump = 2,
839	};
840
841	static int dib7070_set_param_override(struct dvb_frontend *fe)
842	{
843	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
844	struct dvb_usb_adapter *adap = fe->dvb->priv;
845	struct dib0700_adapter_state *state = adap->priv;
846
847	u16 offset;
848	u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
849	switch (band) {
850	case BAND_VHF: offset = 950; break;
851	case BAND_UHF:
852	default: offset = 550; break;
853	}
854	deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
855	state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
856	return state->set_param_save(fe);
857	}
858
859	static int dib7770_set_param_override(struct dvb_frontend *fe)
860	{
861	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
862	struct dvb_usb_adapter *adap = fe->dvb->priv;
863	struct dib0700_adapter_state *state = adap->priv;
864
865	u16 offset;
866	u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
867	switch (band) {
868	case BAND_VHF:
869	state->dib7000p_ops.set_gpio(fe, 0, 0, 1);
870	offset = 850;
871	break;
872	case BAND_UHF:
873	default:
874	state->dib7000p_ops.set_gpio(fe, 0, 0, 0);
875	offset = 250;
876	break;
877	}
878	deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
879	state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
880	return state->set_param_save(fe);
881	}
882
883	static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
884	{
885	struct dib0700_adapter_state *st = adap->priv;
886	struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
887	DIBX000_I2C_INTERFACE_TUNER, 1);
888
889	if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
890	&dib7770p_dib0070_config) == NULL)
891	return -ENODEV;
892
893	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
894	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7770_set_param_override;
895	return 0;
896	}
897
898	static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
899	{
900	struct dib0700_adapter_state *st = adap->priv;
901	struct i2c_adapter *tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
902
903	if (adap->id == 0) {
904	if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
905	return -ENODEV;
906	} else {
907	if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
908	return -ENODEV;
909	}
910
911	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
912	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
913	return 0;
914	}
915
916	static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
917	u16 pid, int onoff)
918	{
919	struct dib0700_adapter_state *state = adapter->priv;
920	struct dib0700_state *st = adapter->dev->priv;
921
922	if (st->is_dib7000pc)
923	return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
924	return dib7000m_pid_filter(adapter->fe_adap[0].fe, id: index, pid, onoff);
925	}
926
927	static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
928	{
929	struct dib0700_state *st = adapter->dev->priv;
930	struct dib0700_adapter_state *state = adapter->priv;
931	if (st->is_dib7000pc)
932	return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
933	return dib7000m_pid_filter_ctrl(fe: adapter->fe_adap[0].fe, onoff);
934	}
935
936	static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
937	{
938	struct dib0700_adapter_state *state = adapter->priv;
939	return state->dib7000p_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
940	}
941
942	static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
943	{
944	struct dib0700_adapter_state *state = adapter->priv;
945	return state->dib7000p_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
946	}
947
948	static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
949	.internal = 60000,
950	.sampling = 15000,
951	.pll_prediv = 1,
952	.pll_ratio = 20,
953	.pll_range = 3,
954	.pll_reset = 1,
955	.pll_bypass = 0,
956	.enable_refdiv = 0,
957	.bypclk_div = 0,
958	.IO_CLK_en_core = 1,
959	.ADClkSrc = 1,
960	.modulo = 2,
961	.sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
962	.ifreq = (0 << 25) | 0,
963	.timf = 20452225,
964	.xtal_hz = 12000000,
965	};
966
967	static struct dib7000p_config dib7070p_dib7000p_config = {
968	.output_mpeg2_in_188_bytes = 1,
969
970	.agc_config_count = 1,
971	.agc = &dib7070_agc_config,
972	.bw = &dib7070_bw_config_12_mhz,
973	.tuner_is_baseband = 1,
974	.spur_protect = 1,
975
976	.gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
977	.gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
978	.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
979
980	.hostbus_diversity = 1,
981	};
982
983	/* STK7070P */
984	static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
985	{
986	struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
987	struct dib0700_adapter_state *state = adap->priv;
988
989	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
990	return -ENODEV;
991
992	if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
993	p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
994	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
995	else
996	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
997	msleep(msecs: 10);
998	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
999	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
1000	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
1001	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
1002
1003	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
1004
1005	msleep(msecs: 10);
1006	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
1007	msleep(msecs: 10);
1008	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
1009
1010	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1011	&dib7070p_dib7000p_config) != 0) {
1012	err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
1013	__func__);
1014	dvb_detach(state->dib7000p_ops.set_wbd_ref);
1015	return -ENODEV;
1016	}
1017
1018	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1019	&dib7070p_dib7000p_config);
1020	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1021	}
1022
1023	/* STK7770P */
1024	static struct dib7000p_config dib7770p_dib7000p_config = {
1025	.output_mpeg2_in_188_bytes = 1,
1026
1027	.agc_config_count = 1,
1028	.agc = &dib7070_agc_config,
1029	.bw = &dib7070_bw_config_12_mhz,
1030	.tuner_is_baseband = 1,
1031	.spur_protect = 1,
1032
1033	.gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
1034	.gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
1035	.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1036
1037	.hostbus_diversity = 1,
1038	.enable_current_mirror = 1,
1039	.disable_sample_and_hold = 0,
1040	};
1041
1042	static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
1043	{
1044	struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
1045	struct dib0700_adapter_state *state = adap->priv;
1046
1047	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1048	return -ENODEV;
1049
1050	if (p->idVendor == cpu_to_le16(USB_VID_PINNACLE) &&
1051	p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
1052	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
1053	else
1054	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
1055	msleep(msecs: 10);
1056	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
1057	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
1058	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
1059	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
1060
1061	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
1062
1063	msleep(msecs: 10);
1064	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
1065	msleep(msecs: 10);
1066	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
1067
1068	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1069	&dib7770p_dib7000p_config) != 0) {
1070	err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n",
1071	__func__);
1072	dvb_detach(state->dib7000p_ops.set_wbd_ref);
1073	return -ENODEV;
1074	}
1075
1076	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1077	&dib7770p_dib7000p_config);
1078	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1079	}
1080
1081	/* DIB807x generic */
1082	static struct dibx000_agc_config dib807x_agc_config[2] = {
1083	{
1084	BAND_VHF,
1085	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1086	* P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1087	* P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
1088	* P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1089	* P_agc_write=0 */
1090	(0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
1091	(0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1092	(0 << 0), /* setup*/
1093
1094	600, /* inv_gain*/
1095	10, /* time_stabiliz*/
1096
1097	0, /* alpha_level*/
1098	118, /* thlock*/
1099
1100	0, /* wbd_inv*/
1101	3530, /* wbd_ref*/
1102	1, /* wbd_sel*/
1103	5, /* wbd_alpha*/
1104
1105	65535, /* agc1_max*/
1106	0, /* agc1_min*/
1107
1108	65535, /* agc2_max*/
1109	0, /* agc2_min*/
1110
1111	0, /* agc1_pt1*/
1112	40, /* agc1_pt2*/
1113	183, /* agc1_pt3*/
1114	206, /* agc1_slope1*/
1115	255, /* agc1_slope2*/
1116	72, /* agc2_pt1*/
1117	152, /* agc2_pt2*/
1118	88, /* agc2_slope1*/
1119	90, /* agc2_slope2*/
1120
1121	17, /* alpha_mant*/
1122	27, /* alpha_exp*/
1123	23, /* beta_mant*/
1124	51, /* beta_exp*/
1125
1126	0, /* perform_agc_softsplit*/
1127	}, {
1128	BAND_UHF,
1129	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
1130	* P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
1131	* P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1132	* P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
1133	* P_agc_write=0 */
1134	(0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
1135	(0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
1136	(0 << 0), /* setup */
1137
1138	600, /* inv_gain*/
1139	10, /* time_stabiliz*/
1140
1141	0, /* alpha_level*/
1142	118, /* thlock*/
1143
1144	0, /* wbd_inv*/
1145	3530, /* wbd_ref*/
1146	1, /* wbd_sel*/
1147	5, /* wbd_alpha*/
1148
1149	65535, /* agc1_max*/
1150	0, /* agc1_min*/
1151
1152	65535, /* agc2_max*/
1153	0, /* agc2_min*/
1154
1155	0, /* agc1_pt1*/
1156	40, /* agc1_pt2*/
1157	183, /* agc1_pt3*/
1158	206, /* agc1_slope1*/
1159	255, /* agc1_slope2*/
1160	72, /* agc2_pt1*/
1161	152, /* agc2_pt2*/
1162	88, /* agc2_slope1*/
1163	90, /* agc2_slope2*/
1164
1165	17, /* alpha_mant*/
1166	27, /* alpha_exp*/
1167	23, /* beta_mant*/
1168	51, /* beta_exp*/
1169
1170	0, /* perform_agc_softsplit*/
1171	}
1172	};
1173
1174	static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
1175	.internal = 60000,
1176	.sampling = 15000,
1177	.pll_prediv = 1,
1178	.pll_ratio = 20,
1179	.pll_range = 3,
1180	.pll_reset = 1,
1181	.pll_bypass = 0,
1182	.enable_refdiv = 0,
1183	.bypclk_div = 0,
1184	.IO_CLK_en_core = 1,
1185	.ADClkSrc = 1,
1186	.modulo = 2,
1187	.sad_cfg = (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
1188	.ifreq = (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
1189	.timf = 18179755,
1190	.xtal_hz = 12000000,
1191	};
1192
1193	static struct dib8000_config dib807x_dib8000_config[2] = {
1194	{
1195	.output_mpeg2_in_188_bytes = 1,
1196
1197	.agc_config_count = 2,
1198	.agc = dib807x_agc_config,
1199	.pll = &dib807x_bw_config_12_mhz,
1200	.tuner_is_baseband = 1,
1201
1202	.gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1203	.gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1204	.gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1205
1206	.hostbus_diversity = 1,
1207	.div_cfg = 1,
1208	.agc_control = &dib0070_ctrl_agc_filter,
1209	.output_mode = OUTMODE_MPEG2_FIFO,
1210	.drives = 0x2d98,
1211	}, {
1212	.output_mpeg2_in_188_bytes = 1,
1213
1214	.agc_config_count = 2,
1215	.agc = dib807x_agc_config,
1216	.pll = &dib807x_bw_config_12_mhz,
1217	.tuner_is_baseband = 1,
1218
1219	.gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1220	.gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1221	.gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1222
1223	.hostbus_diversity = 1,
1224	.agc_control = &dib0070_ctrl_agc_filter,
1225	.output_mode = OUTMODE_MPEG2_FIFO,
1226	.drives = 0x2d98,
1227	}
1228	};
1229
1230	static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
1231	{
1232	struct dvb_usb_adapter *adap = fe->dvb->priv;
1233	struct dib0700_adapter_state *state = adap->priv;
1234
1235	return state->dib8000_ops.set_gpio(fe, 5, 0, !onoff);
1236	}
1237
1238	static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
1239	{
1240	struct dvb_usb_adapter *adap = fe->dvb->priv;
1241	struct dib0700_adapter_state *state = adap->priv;
1242
1243	return state->dib8000_ops.set_gpio(fe, 0, 0, onoff);
1244	}
1245
1246	static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
1247	{ 240, 7},
1248	{ 0xffff, 6},
1249	};
1250
1251	static struct dib0070_config dib807x_dib0070_config[2] = {
1252	{
1253	.i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1254	.reset = dib80xx_tuner_reset,
1255	.sleep = dib80xx_tuner_sleep,
1256	.clock_khz = 12000,
1257	.clock_pad_drive = 4,
1258	.vga_filter = 1,
1259	.force_crystal_mode = 1,
1260	.enable_third_order_filter = 1,
1261	.charge_pump = 0,
1262	.wbd_gain = dib8070_wbd_gain_cfg,
1263	.osc_buffer_state = 0,
1264	.freq_offset_khz_uhf = -100,
1265	.freq_offset_khz_vhf = -100,
1266	}, {
1267	.i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1268	.reset = dib80xx_tuner_reset,
1269	.sleep = dib80xx_tuner_sleep,
1270	.clock_khz = 12000,
1271	.clock_pad_drive = 2,
1272	.vga_filter = 1,
1273	.force_crystal_mode = 1,
1274	.enable_third_order_filter = 1,
1275	.charge_pump = 0,
1276	.wbd_gain = dib8070_wbd_gain_cfg,
1277	.osc_buffer_state = 0,
1278	.freq_offset_khz_uhf = -25,
1279	.freq_offset_khz_vhf = -25,
1280	}
1281	};
1282
1283	static int dib807x_set_param_override(struct dvb_frontend *fe)
1284	{
1285	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1286	struct dvb_usb_adapter *adap = fe->dvb->priv;
1287	struct dib0700_adapter_state *state = adap->priv;
1288
1289	u16 offset = dib0070_wbd_offset(fe);
1290	u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1291	switch (band) {
1292	case BAND_VHF:
1293	offset += 750;
1294	break;
1295	case BAND_UHF: /* fall-thru wanted */
1296	default:
1297	offset += 250; break;
1298	}
1299	deb_info("WBD for DiB8000: %d\n", offset);
1300	state->dib8000_ops.set_wbd_ref(fe, offset);
1301
1302	return state->set_param_save(fe);
1303	}
1304
1305	static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
1306	{
1307	struct dib0700_adapter_state *st = adap->priv;
1308	struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe,
1309	DIBX000_I2C_INTERFACE_TUNER, 1);
1310
1311	if (adap->id == 0) {
1312	if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1313	&dib807x_dib0070_config[0]) == NULL)
1314	return -ENODEV;
1315	} else {
1316	if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1317	&dib807x_dib0070_config[1]) == NULL)
1318	return -ENODEV;
1319	}
1320
1321	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1322	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib807x_set_param_override;
1323	return 0;
1324	}
1325
1326	static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
1327	u16 pid, int onoff)
1328	{
1329	struct dib0700_adapter_state *state = adapter->priv;
1330
1331	return state->dib8000_ops.pid_filter(adapter->fe_adap[0].fe, index, pid, onoff);
1332	}
1333
1334	static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
1335	int onoff)
1336	{
1337	struct dib0700_adapter_state *state = adapter->priv;
1338
1339	return state->dib8000_ops.pid_filter_ctrl(adapter->fe_adap[0].fe, onoff);
1340	}
1341
1342	/* STK807x */
1343	static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
1344	{
1345	struct dib0700_adapter_state *state = adap->priv;
1346
1347	if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1348	return -ENODEV;
1349
1350	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
1351	msleep(msecs: 10);
1352	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
1353	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
1354	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
1355
1356	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
1357
1358	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
1359
1360	msleep(msecs: 10);
1361	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
1362	msleep(msecs: 10);
1363	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
1364
1365	state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1366	0x80, 0);
1367
1368	adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
1369	&dib807x_dib8000_config[0]);
1370
1371	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1372	}
1373
1374	/* STK807xPVR */
1375	static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
1376	{
1377	struct dib0700_adapter_state *state = adap->priv;
1378
1379	if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1380	return -ENODEV;
1381
1382	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
1383	msleep(msecs: 30);
1384	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
1385	msleep(msecs: 500);
1386	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
1387	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
1388	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
1389
1390	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
1391
1392	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
1393
1394	msleep(msecs: 10);
1395	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
1396	msleep(msecs: 10);
1397	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
1398
1399	/* initialize IC 0 */
1400	state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80, 0);
1401
1402	adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80,
1403	&dib807x_dib8000_config[0]);
1404
1405	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1406	}
1407
1408	static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
1409	{
1410	struct dib0700_adapter_state *state = adap->priv;
1411
1412	if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1413	return -ENODEV;
1414
1415	/* initialize IC 1 */
1416	state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82, 0);
1417
1418	adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82,
1419	&dib807x_dib8000_config[1]);
1420
1421	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1422	}
1423
1424	/* STK8096GP */
1425	static struct dibx000_agc_config dib8090_agc_config[2] = {
1426	{
1427	.band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1428	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1429	* P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1430	* P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1431	.setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1432	| (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1433
1434	.inv_gain = 787,
1435	.time_stabiliz = 10,
1436
1437	.alpha_level = 0,
1438	.thlock = 118,
1439
1440	.wbd_inv = 0,
1441	.wbd_ref = 3530,
1442	.wbd_sel = 1,
1443	.wbd_alpha = 5,
1444
1445	.agc1_max = 65535,
1446	.agc1_min = 0,
1447
1448	.agc2_max = 65535,
1449	.agc2_min = 0,
1450
1451	.agc1_pt1 = 0,
1452	.agc1_pt2 = 32,
1453	.agc1_pt3 = 114,
1454	.agc1_slope1 = 143,
1455	.agc1_slope2 = 144,
1456	.agc2_pt1 = 114,
1457	.agc2_pt2 = 227,
1458	.agc2_slope1 = 116,
1459	.agc2_slope2 = 117,
1460
1461	.alpha_mant = 28,
1462	.alpha_exp = 26,
1463	.beta_mant = 31,
1464	.beta_exp = 51,
1465
1466	.perform_agc_softsplit = 0,
1467	},
1468	{
1469	.band_caps = BAND_CBAND,
1470	/* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
1471	* P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1472	* P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
1473	.setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
1474	| (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1475
1476	.inv_gain = 787,
1477	.time_stabiliz = 10,
1478
1479	.alpha_level = 0,
1480	.thlock = 118,
1481
1482	.wbd_inv = 0,
1483	.wbd_ref = 3530,
1484	.wbd_sel = 1,
1485	.wbd_alpha = 5,
1486
1487	.agc1_max = 0,
1488	.agc1_min = 0,
1489
1490	.agc2_max = 65535,
1491	.agc2_min = 0,
1492
1493	.agc1_pt1 = 0,
1494	.agc1_pt2 = 32,
1495	.agc1_pt3 = 114,
1496	.agc1_slope1 = 143,
1497	.agc1_slope2 = 144,
1498	.agc2_pt1 = 114,
1499	.agc2_pt2 = 227,
1500	.agc2_slope1 = 116,
1501	.agc2_slope2 = 117,
1502
1503	.alpha_mant = 28,
1504	.alpha_exp = 26,
1505	.beta_mant = 31,
1506	.beta_exp = 51,
1507
1508	.perform_agc_softsplit = 0,
1509	}
1510	};
1511
1512	static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
1513	.internal = 54000,
1514	.sampling = 13500,
1515
1516	.pll_prediv = 1,
1517	.pll_ratio = 18,
1518	.pll_range = 3,
1519	.pll_reset = 1,
1520	.pll_bypass = 0,
1521
1522	.enable_refdiv = 0,
1523	.bypclk_div = 0,
1524	.IO_CLK_en_core = 1,
1525	.ADClkSrc = 1,
1526	.modulo = 2,
1527
1528	.sad_cfg = (3 << 14) | (1 << 12) | (599 << 0),
1529
1530	.ifreq = (0 << 25) | 0,
1531	.timf = 20199727,
1532
1533	.xtal_hz = 12000000,
1534	};
1535
1536	static int dib8090_get_adc_power(struct dvb_frontend *fe)
1537	{
1538	struct dvb_usb_adapter *adap = fe->dvb->priv;
1539	struct dib0700_adapter_state *state = adap->priv;
1540
1541	return state->dib8000_ops.get_adc_power(fe, 1);
1542	}
1543
1544	static void dib8090_agc_control(struct dvb_frontend *fe, u8 restart)
1545	{
1546	deb_info("AGC control callback: %i\n", restart);
1547	dib0090_dcc_freq(fe, fast: restart);
1548
1549	if (restart == 0) /* before AGC startup */
1550	dib0090_set_dc_servo(fe, DC_servo_cutoff: 1);
1551	}
1552
1553	static struct dib8000_config dib809x_dib8000_config[2] = {
1554	{
1555	.output_mpeg2_in_188_bytes = 1,
1556
1557	.agc_config_count = 2,
1558	.agc = dib8090_agc_config,
1559	.agc_control = dib8090_agc_control,
1560	.pll = &dib8090_pll_config_12mhz,
1561	.tuner_is_baseband = 1,
1562
1563	.gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1564	.gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1565	.gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1566
1567	.hostbus_diversity = 1,
1568	.div_cfg = 0x31,
1569	.output_mode = OUTMODE_MPEG2_FIFO,
1570	.drives = 0x2d98,
1571	.diversity_delay = 48,
1572	.refclksel = 3,
1573	}, {
1574	.output_mpeg2_in_188_bytes = 1,
1575
1576	.agc_config_count = 2,
1577	.agc = dib8090_agc_config,
1578	.agc_control = dib8090_agc_control,
1579	.pll = &dib8090_pll_config_12mhz,
1580	.tuner_is_baseband = 1,
1581
1582	.gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
1583	.gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
1584	.gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
1585
1586	.hostbus_diversity = 1,
1587	.div_cfg = 0x31,
1588	.output_mode = OUTMODE_DIVERSITY,
1589	.drives = 0x2d08,
1590	.diversity_delay = 1,
1591	.refclksel = 3,
1592	}
1593	};
1594
1595	static struct dib0090_wbd_slope dib8090_wbd_table[] = {
1596	/* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
1597	{ 120, 0, 500, 0, 500, 4 }, /* CBAND */
1598	{ 170, 0, 450, 0, 450, 4 }, /* CBAND */
1599	{ 380, 48, 373, 28, 259, 6 }, /* VHF */
1600	{ 860, 34, 700, 36, 616, 6 }, /* high UHF */
1601	{ 0xFFFF, 34, 700, 36, 616, 6 }, /* default */
1602	};
1603
1604	static struct dib0090_config dib809x_dib0090_config = {
1605	.io.pll_bypass = 1,
1606	.io.pll_range = 1,
1607	.io.pll_prediv = 1,
1608	.io.pll_loopdiv = 20,
1609	.io.adc_clock_ratio = 8,
1610	.io.pll_int_loop_filt = 0,
1611	.io.clock_khz = 12000,
1612	.reset = dib80xx_tuner_reset,
1613	.sleep = dib80xx_tuner_sleep,
1614	.clkouttobamse = 1,
1615	.analog_output = 1,
1616	.i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
1617	.use_pwm_agc = 1,
1618	.clkoutdrive = 1,
1619	.get_adc_power = dib8090_get_adc_power,
1620	.freq_offset_khz_uhf = -63,
1621	.freq_offset_khz_vhf = -143,
1622	.wbd = dib8090_wbd_table,
1623	.fref_clock_ratio = 6,
1624	};
1625
1626	static u8 dib8090_compute_pll_parameters(struct dvb_frontend *fe)
1627	{
1628	u8 optimal_pll_ratio = 20;
1629	u32 freq_adc, ratio, rest, max = 0;
1630	u8 pll_ratio;
1631
1632	for (pll_ratio = 17; pll_ratio <= 20; pll_ratio++) {
1633	freq_adc = 12 * pll_ratio * (1 << 8) / 16;
1634	ratio = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) / freq_adc;
1635	rest = ((fe->dtv_property_cache.frequency / 1000) * (1 << 8) / 1000) - ratio * freq_adc;
1636
1637	if (rest > freq_adc / 2)
1638	rest = freq_adc - rest;
1639	deb_info("PLL ratio=%i rest=%i\n", pll_ratio, rest);
1640	if ((rest > max) && (rest > 717)) {
1641	optimal_pll_ratio = pll_ratio;
1642	max = rest;
1643	}
1644	}
1645	deb_info("optimal PLL ratio=%i\n", optimal_pll_ratio);
1646
1647	return optimal_pll_ratio;
1648	}
1649
1650	static int dib8096_set_param_override(struct dvb_frontend *fe)
1651	{
1652	struct dvb_usb_adapter *adap = fe->dvb->priv;
1653	struct dib0700_adapter_state *state = adap->priv;
1654	u8 pll_ratio, band = BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000);
1655	u16 target, ltgain, rf_gain_limit;
1656	u32 timf;
1657	int ret = 0;
1658	enum frontend_tune_state tune_state = CT_SHUTDOWN;
1659
1660	switch (band) {
1661	default:
1662	deb_info("Warning : Rf frequency (%iHz) is not in the supported range, using VHF switch ", fe->dtv_property_cache.frequency);
1663	fallthrough;
1664	case BAND_VHF:
1665	state->dib8000_ops.set_gpio(fe, 3, 0, 1);
1666	break;
1667	case BAND_UHF:
1668	state->dib8000_ops.set_gpio(fe, 3, 0, 0);
1669	break;
1670	}
1671
1672	ret = state->set_param_save(fe);
1673	if (ret < 0)
1674	return ret;
1675
1676	if (fe->dtv_property_cache.bandwidth_hz != 6000000) {
1677	deb_info("only 6MHz bandwidth is supported\n");
1678	return -EINVAL;
1679	}
1680
1681	/* Update PLL if needed ratio */
1682	state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, 0);
1683
1684	/* Get optimize PLL ratio to remove spurious */
1685	pll_ratio = dib8090_compute_pll_parameters(fe);
1686	if (pll_ratio == 17)
1687	timf = 21387946;
1688	else if (pll_ratio == 18)
1689	timf = 20199727;
1690	else if (pll_ratio == 19)
1691	timf = 19136583;
1692	else
1693	timf = 18179756;
1694
1695	/* Update ratio */
1696	state->dib8000_ops.update_pll(fe, &dib8090_pll_config_12mhz, fe->dtv_property_cache.bandwidth_hz / 1000, pll_ratio);
1697
1698	state->dib8000_ops.ctrl_timf(fe, DEMOD_TIMF_SET, timf);
1699
1700	if (band != BAND_CBAND) {
1701	/* dib0090_get_wbd_target is returning any possible temperature compensated wbd-target */
1702	target = (dib0090_get_wbd_target(tuner: 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, tune_state: CT_AGC_START);
1709
1710	do {
1711	ret = dib0090_gain_control(fe);
1712	msleep(msecs: 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: &rf_gain_limit, rflt: &ltgain);
1718	if (rf_gain_limit < 2000) /* activate the external attenuator in case of very high input power */
1719	state->dib8000_ops.set_gpio(fe, 6, 0, 0);
1720	}
1721	} while (tune_state < CT_AGC_STOP);
1722
1723	deb_info("switching to PWM AGC\n");
1724	dib0090_pwm_gain_reset(fe);
1725	state->dib8000_ops.pwm_agc_reset(fe);
1726	state->dib8000_ops.set_tune_state(fe, CT_DEMOD_START);
1727	} else {
1728	/* for everything else than CBAND we are using standard AGC */
1729	deb_info("not tuning in CBAND - standard AGC startup\n");
1730	dib0090_pwm_gain_reset(fe);
1731	}
1732
1733	return 0;
1734	}
1735
1736	static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
1737	{
1738	struct dib0700_adapter_state *st = adap->priv;
1739	struct i2c_adapter *tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1740
1741	/* FIXME: if adap->id != 0, check if it is fe_adap[1] */
1742	if (!dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config))
1743	return -ENODEV;
1744
1745	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1746	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1747	return 0;
1748	}
1749
1750	static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
1751	{
1752	struct dib0700_adapter_state *state = adap->priv;
1753
1754	if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1755	return -ENODEV;
1756
1757	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
1758	msleep(msecs: 10);
1759	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
1760	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
1761	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
1762
1763	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
1764
1765	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
1766
1767	msleep(msecs: 10);
1768	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
1769	msleep(msecs: 10);
1770	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
1771
1772	state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80, 0);
1773
1774	adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
1775
1776	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1777	}
1778
1779	static int stk809x_frontend1_attach(struct dvb_usb_adapter *adap)
1780	{
1781	struct dib0700_adapter_state *state = adap->priv;
1782
1783	if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1784	return -ENODEV;
1785
1786	state->dib8000_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x82, 0);
1787
1788	adap->fe_adap[0].fe = state->dib8000_ops.init(&adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
1789
1790	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1791	}
1792
1793	static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
1794	{
1795	struct dib0700_adapter_state *st = adap->priv;
1796	struct i2c_adapter *tun_i2c;
1797	struct dvb_frontend *fe_slave = st->dib8000_ops.get_slave_frontend(adap->fe_adap[0].fe, 1);
1798
1799	if (fe_slave) {
1800	tun_i2c = st->dib8000_ops.get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
1801	if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
1802	return -ENODEV;
1803	fe_slave->dvb = adap->fe_adap[0].fe->dvb;
1804	fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
1805	}
1806	tun_i2c = st->dib8000_ops.get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_TUNER, 1);
1807	if (dvb_attach(dib0090_register, adap->fe_adap[0].fe, tun_i2c, &dib809x_dib0090_config) == NULL)
1808	return -ENODEV;
1809
1810	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1811	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib8096_set_param_override;
1812
1813	return 0;
1814	}
1815
1816	static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
1817	{
1818	struct dvb_frontend *fe_slave;
1819	struct dib0700_adapter_state *state = adap->priv;
1820
1821	if (!dvb_attach(dib8000_attach, &state->dib8000_ops))
1822	return -ENODEV;
1823
1824	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
1825	msleep(msecs: 20);
1826	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
1827	msleep(msecs: 1000);
1828	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
1829	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
1830	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
1831
1832	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
1833
1834	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
1835
1836	msleep(msecs: 20);
1837	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
1838	msleep(msecs: 20);
1839	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 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
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
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(tuner: fe) * 8 + 1) / 2;
2123	state->dib8000_ops.set_wbd_ref(fe, target);
2124
2125	if (dib8096p_get_best_sampling(fe, adc: &adc) == 0) {
2126	pll.pll_ratio = adc.pll_loopdiv;
2127	pll.pll_prediv = adc.pll_prediv;
2128
2129	dib0700_set_i2c_speed(d: adap->dev, scl_kHz: 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(d: adap->dev, scl_kHz: 1000);
2133	}
2134	return 0;
2135	}
2136
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(d: adap->dev, NULL, NULL, ramversion: &fw_version, NULL);
2147	if (fw_version >= 0x10200)
2148	st->fw_use_new_i2c_api = 1;
2149
2150	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
2151	msleep(msecs: 20);
2152	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
2153	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
2154	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
2155
2156	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
2157
2158	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
2159
2160	msleep(msecs: 20);
2161	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
2162	msleep(msecs: 20);
2163	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 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
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 */
2194	static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
2195	{
2196	return dib9000_fw_pid_filter(fe: adapter->fe_adap[0].fe, id: index, pid, onoff);
2197	}
2198
2199	static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
2200	{
2201	return dib9000_fw_pid_filter_ctrl(fe: adapter->fe_adap[0].fe, onoff);
2202	}
2203
2204	static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
2205	{
2206	return dib9000_set_gpio(fe, num: 5, dir: 0, val: !onoff);
2207	}
2208
2209	static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
2210	{
2211	return dib9000_set_gpio(fe, num: 0, dir: 0, val: onoff);
2212	}
2213
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_adap: i2c, speed: 250);
2225
2226	if (i2c_transfer(adap: i2c, msgs: msg, num: 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(adap: i2c, msgs: msg, num: 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(adap: i2c, msgs: &msg[0], num: 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
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(d: adap->dev, NULL, NULL, ramversion: &fw_version, NULL);
2384	if (fw_version >= 0x10200)
2385	st->fw_use_new_i2c_api = 1;
2386	dib0700_set_i2c_speed(d: adap->dev, scl_kHz: 340);
2387
2388	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
2389	msleep(msecs: 20);
2390	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
2391	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
2392	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
2393	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
2394
2395	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
2396
2397	msleep(msecs: 20);
2398	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
2399	msleep(msecs: 20);
2400	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
2401
2402	dib9000_i2c_enumeration(host: &adap->dev->i2c_adap, no_of_demods: 1, default_addr: 0x10, first_addr: 0x80);
2403
2404	if (request_firmware(fw: &state->frontend_firmware, name: "dib9090.fw", device: &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(fw: state->frontend_firmware);
2417	return -ENODEV;
2418	}
2419
2420	return 0;
2421	}
2422
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(fe: 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(fe: adap->fe_adap[0].fe, intf: DIBX000_I2C_INTERFACE_GPIO_1_2, gating: 0);
2440	if (!i2c)
2441	return -ENODEV;
2442	if (dib01x0_pmu_update(i2c, data: data_dib190, len: 10) != 0)
2443	return -ENODEV;
2444	dib0700_set_i2c_speed(d: adap->dev, scl_kHz: 1500);
2445	if (dib9000_firmware_post_pll_init(fe: adap->fe_adap[0].fe) < 0)
2446	return -ENODEV;
2447	release_firmware(fw: state->frontend_firmware);
2448	return 0;
2449	}
2450
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(d: adap->dev, NULL, NULL, ramversion: &fw_version, NULL);
2461	if (fw_version >= 0x10200)
2462	st->fw_use_new_i2c_api = 1;
2463	dib0700_set_i2c_speed(d: adap->dev, scl_kHz: 340);
2464
2465	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
2466	msleep(msecs: 20);
2467	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
2468	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
2469	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
2470	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
2471
2472	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
2473
2474	msleep(msecs: 20);
2475	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
2476	msleep(msecs: 20);
2477	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
2478
2479	if (request_firmware(fw: &state->frontend_firmware, name: "dib9090.fw", device: &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(host: &adap->dev->i2c_adap, no_of_demods: 1, default_addr: 0x20, first_addr: 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(fw: state->frontend_firmware);
2495	return -ENODEV;
2496	}
2497
2498	i2c = dib9000_get_i2c_master(fe: adap->fe_adap[0].fe, intf: DIBX000_I2C_INTERFACE_GPIO_3_4, gating: 0);
2499	dib9000_i2c_enumeration(host: i2c, no_of_demods: 1, default_addr: 0x12, first_addr: 0x82);
2500
2501	fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
2502	dib9000_set_slave_frontend(fe: adap->fe_adap[0].fe, fe_slave);
2503
2504	if (!fe_slave) {
2505	release_firmware(fw: state->frontend_firmware);
2506	return -ENODEV;
2507	}
2508
2509	return 0;
2510	}
2511
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(fe: 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(fe: adap->fe_adap[0].fe, intf: DIBX000_I2C_INTERFACE_GPIO_1_2, gating: 0);
2530	if (!i2c)
2531	return -ENODEV;
2532	if (dib01x0_pmu_update(i2c, data: data_dib190, len: 10) < 0)
2533	return -ENODEV;
2534
2535	dib0700_set_i2c_speed(d: adap->dev, scl_kHz: 1500);
2536	if (dib9000_firmware_post_pll_init(fe: adap->fe_adap[0].fe) < 0)
2537	return -ENODEV;
2538
2539	fe_slave = dib9000_get_slave_frontend(fe: adap->fe_adap[0].fe, slave_index: 1);
2540	if (fe_slave != NULL) {
2541	i2c = dib9000_get_component_bus_interface(fe: adap->fe_adap[0].fe);
2542	dib9000_set_i2c_adapter(fe: fe_slave, i2c);
2543
2544	i2c = dib9000_get_tuner_interface(fe: 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(fe: adap->fe_adap[0].fe, speed: 1500);
2549	if (dib9000_firmware_post_pll_init(fe: fe_slave) < 0)
2550	return -ENODEV;
2551	}
2552	release_firmware(fw: state->frontend_firmware);
2553
2554	return 0;
2555	}
2556
2557	/* NIM7090 */
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
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(tuner: fe) * 8 + 1) / 2;
2647	state->dib7000p_ops.set_wbd_ref(fe, target);
2648
2649	if (dib7090p_get_best_sampling(fe, adc: &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
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, DC_servo_cutoff: 1);
2664	return 0;
2665	}
2666
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
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
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(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3056	msleep(msecs: 20);
3057	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
3058	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
3059	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
3060	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3061
3062	msleep(msecs: 20);
3063	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3064	msleep(msecs: 20);
3065	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 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
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
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(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3108	msleep(msecs: 20);
3109	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
3110	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
3111	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
3112	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3113
3114	msleep(msecs: 20);
3115	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3116	msleep(msecs: 20);
3117	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 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(d: adap->dev, scl_kHz: 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
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(d: adap->dev, scl_kHz: 200);
3158
3159	return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
3160	}
3161
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
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
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(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3212	msleep(msecs: 20);
3213	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
3214	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
3215	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
3216	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3217	msleep(msecs: 20);
3218	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
3219	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3220	msleep(msecs: 20);
3221	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 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
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
3291	static void stk7070pd_init(struct dvb_usb_device *dev)
3292	{
3293	dib0700_set_gpio(d: dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3294	msleep(msecs: 10);
3295	dib0700_set_gpio(d: dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
3296	dib0700_set_gpio(d: dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
3297	dib0700_set_gpio(d: dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
3298	dib0700_set_gpio(d: dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3299
3300	dib0700_ctrl_clock(d: dev, clk_MHz: 72, clock_out_gp3: 1);
3301
3302	msleep(msecs: 10);
3303	dib0700_set_gpio(d: dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3304	}
3305
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(dev: adap->dev);
3314
3315	msleep(msecs: 10);
3316	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 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
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
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(d: dev, gpio: adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT,
3353	gpio_val: !!(*stat & FE_HAS_LOCK));
3354
3355	return ret;
3356	}
3357
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(d: dev, gpio: adap->id == 0 ? GPIO1 : GPIO0, GPIO_OUT, gpio_val: 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	*/
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(d: dev, gpio: GPIO0, GPIO_OUT, gpio_val: 0);
3390	dib0700_set_gpio(d: dev, gpio: GPIO1, GPIO_OUT, gpio_val: 0);
3391	dib0700_set_gpio(d: dev, gpio: GPIO2, GPIO_OUT, gpio_val: 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	*/
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(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 0);
3451	dib0700_set_gpio(d: adap->dev, gpio: GPIO3, GPIO_OUT, gpio_val: 0);
3452	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3453	msleep(msecs: 400);
3454	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3455	msleep(msecs: 60);
3456	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3457	msleep(msecs: 30);
3458	dib0700_set_gpio(d: adap->dev, gpio: GPIO0, GPIO_OUT, gpio_val: 1);
3459	dib0700_set_gpio(d: adap->dev, gpio: GPIO9, GPIO_OUT, gpio_val: 1);
3460	dib0700_set_gpio(d: adap->dev, gpio: GPIO4, GPIO_OUT, gpio_val: 1);
3461	dib0700_set_gpio(d: adap->dev, gpio: GPIO7, GPIO_OUT, gpio_val: 1);
3462	dib0700_set_gpio(d: adap->dev, gpio: GPIO2, GPIO_OUT, gpio_val: 0);
3463	msleep(msecs: 30);
3464
3465	/* Put the CX25843 to sleep for now since we're in digital mode */
3466	dib0700_set_gpio(d: adap->dev, gpio: GPIO2, GPIO_OUT, gpio_val: 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
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(d: adap->dev, gpio: GPIO1, GPIO_OUT, gpio_val: 0);
3482	msleep(msecs: 10);
3483	dib0700_set_gpio(d: adap->dev, gpio: GPIO1, GPIO_OUT, gpio_val: 1);
3484	msleep(msecs: 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
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
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(msecs: 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	*/
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(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
3611	msleep(msecs: 50);
3612	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3613	msleep(msecs: 100); /* Allow power supply to settle before probing */
3614
3615	/* cx25843 reset */
3616	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3617	msleep(msecs: 1); /* cx25843 datasheet say 350us required */
3618	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3619
3620	/* LNA off for now */
3621	dib0700_set_gpio(d: adap->dev, gpio: GPIO8, GPIO_OUT, gpio_val: 1);
3622
3623	/* Put the CX25843 to sleep for now since we're in digital mode */
3624	dib0700_set_gpio(d: adap->dev, gpio: GPIO2, GPIO_OUT, gpio_val: 1);
3625
3626	/* FIXME: not verified yet */
3627	dib0700_ctrl_clock(d: adap->dev, clk_MHz: 72, clock_out_gp3: 1);
3628
3629	msleep(msecs: 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
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	*/
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(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
3712	msleep(msecs: 30);
3713	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3714	msleep(msecs: 30);
3715
3716	/* demod reset */
3717	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3718	msleep(msecs: 30);
3719	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3720	msleep(msecs: 30);
3721	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3722	msleep(msecs: 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
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
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(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 0);
3752	msleep(msecs: 30);
3753	dib0700_set_gpio(d: adap->dev, gpio: GPIO6, GPIO_OUT, gpio_val: 1);
3754	msleep(msecs: 30);
3755
3756	/* demod reset */
3757	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3758	msleep(msecs: 30);
3759	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 0);
3760	msleep(msecs: 30);
3761	dib0700_set_gpio(d: adap->dev, gpio: GPIO10, GPIO_OUT, gpio_val: 1);
3762	msleep(msecs: 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(adap: &d->i2c_adap, info: &info);
3776	if (!i2c_client_has_driver(client: client_demod))
3777	goto fail_demod_device;
3778	if (!try_module_get(module: 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: &adap->dev->i2c_adap, info: &info);
3804	if (!i2c_client_has_driver(client: client_tuner))
3805	goto fail_tuner_device;
3806	if (!try_module_get(module: 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: client_tuner);
3814	fail_tuner_device:
3815	module_put(module: client_demod->dev.driver->owner);
3816	fail_demod_module:
3817	i2c_unregister_device(client: 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