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