1	// SPDX-License-Identifier: GPL-2.0-only
2	/* DVB USB compliant linux driver for Conexant USB reference design.
3	*
4	* The Conexant reference design I saw on their website was only for analogue
5	* capturing (using the cx25842). The box I took to write this driver (reverse
6	* engineered) is the one labeled Medion MD95700. In addition to the cx25842
7	* for analogue capturing it also has a cx22702 DVB-T demodulator on the main
8	* board. Besides it has a atiremote (X10) and a USB2.0 hub onboard.
9	*
10	* Maybe it is a little bit premature to call this driver cxusb, but I assume
11	* the USB protocol is identical or at least inherited from the reference
12	* design, so it can be reused for the "analogue-only" device (if it will
13	* appear at all).
14	*
15	*
16	* Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@posteo.de)
17	* Copyright (C) 2006 Michael Krufky (mkrufky@linuxtv.org)
18	* Copyright (C) 2006, 2007 Chris Pascoe (c.pascoe@itee.uq.edu.au)
19	* Copyright (C) 2011, 2017 Maciej S. Szmigiero (mail@maciej.szmigiero.name)
20	*
21	* see Documentation/driver-api/media/drivers/dvb-usb.rst for more information
22	*/
23	#include <media/tuner.h>
24	#include <linux/delay.h>
25	#include <linux/device.h>
26	#include <linux/kernel.h>
27	#include <linux/slab.h>
28	#include <linux/string.h>
29	#include <linux/vmalloc.h>
30
31	#include "cxusb.h"
32
33	#include "cx22702.h"
34	#include "lgdt330x.h"
35	#include "mt352.h"
36	#include "mt352_priv.h"
37	#include "zl10353.h"
38	#include "xc2028.h"
39	#include "tuner-simple.h"
40	#include "mxl5005s.h"
41	#include "max2165.h"
42	#include "dib7000p.h"
43	#include "dib0070.h"
44	#include "lgs8gxx.h"
45	#include "atbm8830.h"
46	#include "si2168.h"
47	#include "si2157.h"
48
49	/* debug */
50	int dvb_usb_cxusb_debug;
51	module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
52	MODULE_PARM_DESC(debug, "set debugging level (see cxusb.h)."
53	DVB_USB_DEBUG_STATUS);
54
55	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
56
57	enum cxusb_table_index {
58	MEDION_MD95700,
59	DVICO_BLUEBIRD_LG064F_COLD,
60	DVICO_BLUEBIRD_LG064F_WARM,
61	DVICO_BLUEBIRD_DUAL_1_COLD,
62	DVICO_BLUEBIRD_DUAL_1_WARM,
63	DVICO_BLUEBIRD_LGZ201_COLD,
64	DVICO_BLUEBIRD_LGZ201_WARM,
65	DVICO_BLUEBIRD_TH7579_COLD,
66	DVICO_BLUEBIRD_TH7579_WARM,
67	DIGITALNOW_BLUEBIRD_DUAL_1_COLD,
68	DIGITALNOW_BLUEBIRD_DUAL_1_WARM,
69	DVICO_BLUEBIRD_DUAL_2_COLD,
70	DVICO_BLUEBIRD_DUAL_2_WARM,
71	DVICO_BLUEBIRD_DUAL_4,
72	DVICO_BLUEBIRD_DVB_T_NANO_2,
73	DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM,
74	AVERMEDIA_VOLAR_A868R,
75	DVICO_BLUEBIRD_DUAL_4_REV_2,
76	CONEXANT_D680_DMB,
77	MYGICA_D689,
78	NR__cxusb_table_index
79	};
80
81	static struct usb_device_id cxusb_table[];
82
83	int cxusb_ctrl_msg(struct dvb_usb_device *d,
84	u8 cmd, const u8 *wbuf, int wlen, u8 *rbuf, int rlen)
85	{
86	struct cxusb_state *st = d->priv;
87	int ret;
88
89	if (1 + wlen > MAX_XFER_SIZE) {
90	warn("i2c wr: len=%d is too big!\n", wlen);
91	return -EOPNOTSUPP;
92	}
93
94	if (rlen > MAX_XFER_SIZE) {
95	warn("i2c rd: len=%d is too big!\n", rlen);
96	return -EOPNOTSUPP;
97	}
98
99	mutex_lock(&d->data_mutex);
100	st->data[0] = cmd;
101	memcpy(&st->data[1], wbuf, wlen);
102	ret = dvb_usb_generic_rw(d, st->data, 1 + wlen, st->data, rlen, 0);
103	if (!ret && rbuf && rlen)
104	memcpy(rbuf, st->data, rlen);
105
106	mutex_unlock(lock: &d->data_mutex);
107	return ret;
108	}
109
110	/* GPIO */
111	static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
112	{
113	struct cxusb_state *st = d->priv;
114	u8 o[2], i;
115
116	if (st->gpio_write_state[GPIO_TUNER] == onoff &&
117	!st->gpio_write_refresh[GPIO_TUNER])
118	return;
119
120	o[0] = GPIO_TUNER;
121	o[1] = onoff;
122	cxusb_ctrl_msg(d, CMD_GPIO_WRITE, wbuf: o, wlen: 2, rbuf: &i, rlen: 1);
123
124	if (i != 0x01)
125	dev_info(&d->udev->dev, "gpio_write failed.\n");
126
127	st->gpio_write_state[GPIO_TUNER] = onoff;
128	st->gpio_write_refresh[GPIO_TUNER] = false;
129	}
130
131	static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask,
132	u8 newval)
133	{
134	u8 o[2], gpio_state;
135	int rc;
136
137	o[0] = 0xff & ~changemask; /* mask of bits to keep */
138	o[1] = newval & changemask; /* new values for bits */
139
140	rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, wbuf: o, wlen: 2, rbuf: &gpio_state, rlen: 1);
141	if (rc < 0 || (gpio_state & changemask) != (newval & changemask))
142	dev_info(&d->udev->dev, "bluebird_gpio_write failed.\n");
143
144	return rc < 0 ? rc : gpio_state;
145	}
146
147	static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low)
148	{
149	cxusb_bluebird_gpio_rw(d, changemask: pin, newval: low ? 0 : pin);
150	msleep(msecs: 5);
151	cxusb_bluebird_gpio_rw(d, changemask: pin, newval: low ? pin : 0);
152	}
153
154	static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
155	{
156	cxusb_bluebird_gpio_rw(d, changemask: 0x40, newval: onoff ? 0 : 0x40);
157	}
158
159	static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
160	u8 addr, int onoff)
161	{
162	u8 o[2] = {addr, onoff};
163	u8 i;
164	int rc;
165
166	rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, wbuf: o, wlen: 2, rbuf: &i, rlen: 1);
167
168	if (rc < 0)
169	return rc;
170
171	if (i == 0x01)
172	return 0;
173
174	dev_info(&d->udev->dev, "gpio_write failed.\n");
175	return -EIO;
176	}
177
178	/* I2C */
179	static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
180	int num)
181	{
182	struct dvb_usb_device *d = i2c_get_adapdata(adap);
183	int ret;
184	int i;
185
186	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
187	return -EAGAIN;
188
189	for (i = 0; i < num; i++) {
190	if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_MEDION)
191	switch (msg[i].addr) {
192	case 0x63:
193	cxusb_gpio_tuner(d, onoff: 0);
194	break;
195	default:
196	cxusb_gpio_tuner(d, onoff: 1);
197	break;
198	}
199
200	if (msg[i].flags & I2C_M_RD) {
201	/* read only */
202	u8 obuf[3], ibuf[MAX_XFER_SIZE];
203
204	if (1 + msg[i].len > sizeof(ibuf)) {
205	warn("i2c rd: len=%d is too big!\n",
206	msg[i].len);
207	ret = -EOPNOTSUPP;
208	goto unlock;
209	}
210	obuf[0] = 0;
211	obuf[1] = msg[i].len;
212	obuf[2] = msg[i].addr;
213	if (cxusb_ctrl_msg(d, CMD_I2C_READ,
214	wbuf: obuf, wlen: 3,
215	rbuf: ibuf, rlen: 1 + msg[i].len) < 0) {
216	warn("i2c read failed");
217	break;
218	}
219	memcpy(msg[i].buf, &ibuf[1], msg[i].len);
220	} else if (i + 1 < num && (msg[i + 1].flags & I2C_M_RD) &&
221	msg[i].addr == msg[i + 1].addr) {
222	/* write to then read from same address */
223	u8 obuf[MAX_XFER_SIZE], ibuf[MAX_XFER_SIZE];
224
225	if (3 + msg[i].len > sizeof(obuf)) {
226	warn("i2c wr: len=%d is too big!\n",
227	msg[i].len);
228	ret = -EOPNOTSUPP;
229	goto unlock;
230	}
231	if (1 + msg[i + 1].len > sizeof(ibuf)) {
232	warn("i2c rd: len=%d is too big!\n",
233	msg[i + 1].len);
234	ret = -EOPNOTSUPP;
235	goto unlock;
236	}
237	obuf[0] = msg[i].len;
238	obuf[1] = msg[i + 1].len;
239	obuf[2] = msg[i].addr;
240	memcpy(&obuf[3], msg[i].buf, msg[i].len);
241
242	if (cxusb_ctrl_msg(d, CMD_I2C_READ,
243	wbuf: obuf, wlen: 3 + msg[i].len,
244	rbuf: ibuf, rlen: 1 + msg[i + 1].len) < 0)
245	break;
246
247	if (ibuf[0] != 0x08)
248	dev_info(&d->udev->dev, "i2c read may have failed\n");
249
250	memcpy(msg[i + 1].buf, &ibuf[1], msg[i + 1].len);
251
252	i++;
253	} else {
254	/* write only */
255	u8 obuf[MAX_XFER_SIZE], ibuf;
256
257	if (2 + msg[i].len > sizeof(obuf)) {
258	warn("i2c wr: len=%d is too big!\n",
259	msg[i].len);
260	ret = -EOPNOTSUPP;
261	goto unlock;
262	}
263	obuf[0] = msg[i].addr;
264	obuf[1] = msg[i].len;
265	memcpy(&obuf[2], msg[i].buf, msg[i].len);
266
267	if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, wbuf: obuf,
268	wlen: 2 + msg[i].len, rbuf: &ibuf, rlen: 1) < 0)
269	break;
270	if (ibuf != 0x08)
271	dev_info(&d->udev->dev, "i2c write may have failed\n");
272	}
273	}
274
275	if (i == num)
276	ret = num;
277	else
278	ret = -EREMOTEIO;
279
280	unlock:
281	mutex_unlock(lock: &d->i2c_mutex);
282	return ret;
283	}
284
285	static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
286	{
287	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
288	}
289
290	static struct i2c_algorithm cxusb_i2c_algo = {
291	.master_xfer = cxusb_i2c_xfer,
292	.functionality = cxusb_i2c_func,
293	};
294
295	static int _cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
296	{
297	u8 b = 0;
298
299	dev_info(&d->udev->dev, "setting power %s\n", onoff ? "ON" : "OFF");
300
301	if (onoff)
302	return cxusb_ctrl_msg(d, CMD_POWER_ON, wbuf: &b, wlen: 1, NULL, rlen: 0);
303	else
304	return cxusb_ctrl_msg(d, CMD_POWER_OFF, wbuf: &b, wlen: 1, NULL, rlen: 0);
305	}
306
307	static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
308	{
309	bool is_medion = d->props.devices[0].warm_ids[0] == &cxusb_table[MEDION_MD95700];
310	int ret;
311
312	if (is_medion && !onoff) {
313	struct cxusb_medion_dev *cxdev = d->priv;
314
315	mutex_lock(&cxdev->open_lock);
316
317	if (cxdev->open_type == CXUSB_OPEN_ANALOG) {
318	dev_info(&d->udev->dev, "preventing DVB core from setting power OFF while we are in analog mode\n");
319	ret = -EBUSY;
320	goto ret_unlock;
321	}
322	}
323
324	ret = _cxusb_power_ctrl(d, onoff);
325
326	ret_unlock:
327	if (is_medion && !onoff) {
328	struct cxusb_medion_dev *cxdev = d->priv;
329
330	mutex_unlock(lock: &cxdev->open_lock);
331	}
332
333	return ret;
334	}
335
336	static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff)
337	{
338	int ret;
339
340	if (!onoff)
341	return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, wlen: 0, NULL, rlen: 0);
342	if (d->state == DVB_USB_STATE_INIT &&
343	usb_set_interface(dev: d->udev, ifnum: 0, alternate: 0) < 0)
344	err("set interface failed");
345	do {
346	/* Nothing */
347	} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, wlen: 0, NULL, rlen: 0)) &&
348	!(ret = cxusb_ctrl_msg(d, cmd: 0x15, NULL, wlen: 0, NULL, rlen: 0)) &&
349	!(ret = cxusb_ctrl_msg(d, cmd: 0x17, NULL, wlen: 0, NULL, rlen: 0)) && 0);
350
351	if (!ret) {
352	/*
353	* FIXME: We don't know why, but we need to configure the
354	* lgdt3303 with the register settings below on resume
355	*/
356	int i;
357	u8 buf;
358	static const u8 bufs[] = {
359	0x0e, 0x2, 0x00, 0x7f,
360	0x0e, 0x2, 0x02, 0xfe,
361	0x0e, 0x2, 0x02, 0x01,
362	0x0e, 0x2, 0x00, 0x03,
363	0x0e, 0x2, 0x0d, 0x40,
364	0x0e, 0x2, 0x0e, 0x87,
365	0x0e, 0x2, 0x0f, 0x8e,
366	0x0e, 0x2, 0x10, 0x01,
367	0x0e, 0x2, 0x14, 0xd7,
368	0x0e, 0x2, 0x47, 0x88,
369	};
370	msleep(msecs: 20);
371	for (i = 0; i < ARRAY_SIZE(bufs); i += 4 / sizeof(u8)) {
372	ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE,
373	wbuf: bufs + i, wlen: 4, rbuf: &buf, rlen: 1);
374	if (ret)
375	break;
376	if (buf != 0x8)
377	return -EREMOTEIO;
378	}
379	}
380	return ret;
381	}
382
383	static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
384	{
385	u8 b = 0;
386
387	if (onoff)
388	return cxusb_ctrl_msg(d, CMD_POWER_ON, wbuf: &b, wlen: 1, NULL, rlen: 0);
389	else
390	return 0;
391	}
392
393	static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff)
394	{
395	int rc = 0;
396
397	rc = cxusb_power_ctrl(d, onoff);
398	if (!onoff)
399	cxusb_nano2_led(d, onoff: 0);
400
401	return rc;
402	}
403
404	static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device *d, int onoff)
405	{
406	int ret;
407	u8 b;
408
409	ret = cxusb_power_ctrl(d, onoff);
410	if (!onoff)
411	return ret;
412
413	msleep(msecs: 128);
414	cxusb_ctrl_msg(d, CMD_DIGITAL, NULL, wlen: 0, rbuf: &b, rlen: 1);
415	msleep(msecs: 100);
416	return ret;
417	}
418
419	static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
420	{
421	struct dvb_usb_device *dvbdev = adap->dev;
422	bool is_medion = dvbdev->props.devices[0].warm_ids[0] ==
423	&cxusb_table[MEDION_MD95700];
424	u8 buf[2] = { 0x03, 0x00 };
425
426	if (is_medion && onoff) {
427	int ret;
428
429	ret = cxusb_medion_get(dvbdev, open_type: CXUSB_OPEN_DIGITAL);
430	if (ret != 0)
431	return ret;
432	}
433
434	if (onoff)
435	cxusb_ctrl_msg(d: dvbdev, CMD_STREAMING_ON, wbuf: buf, wlen: 2, NULL, rlen: 0);
436	else
437	cxusb_ctrl_msg(d: dvbdev, CMD_STREAMING_OFF, NULL, wlen: 0, NULL, rlen: 0);
438
439	if (is_medion && !onoff)
440	cxusb_medion_put(dvbdev);
441
442	return 0;
443	}
444
445	static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
446	{
447	if (onoff)
448	cxusb_ctrl_msg(d: adap->dev, CMD_AVER_STREAM_ON, NULL, wlen: 0, NULL, rlen: 0);
449	else
450	cxusb_ctrl_msg(d: adap->dev, CMD_AVER_STREAM_OFF,
451	NULL, wlen: 0, NULL, rlen: 0);
452	return 0;
453	}
454
455	static void cxusb_d680_dmb_drain_message(struct dvb_usb_device *d)
456	{
457	int ep = d->props.generic_bulk_ctrl_endpoint;
458	const int timeout = 100;
459	const int junk_len = 32;
460	u8 *junk;
461	int rd_count;
462
463	/* Discard remaining data in video pipe */
464	junk = kmalloc(size: junk_len, GFP_KERNEL);
465	if (!junk)
466	return;
467	while (1) {
468	if (usb_bulk_msg(usb_dev: d->udev,
469	usb_rcvbulkpipe(d->udev, ep),
470	data: junk, len: junk_len, actual_length: &rd_count, timeout) < 0)
471	break;
472	if (!rd_count)
473	break;
474	}
475	kfree(objp: junk);
476	}
477
478	static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d)
479	{
480	struct usb_data_stream_properties *p = &d->props.adapter[0].fe[0].stream;
481	const int timeout = 100;
482	const int junk_len = p->u.bulk.buffersize;
483	u8 *junk;
484	int rd_count;
485
486	/* Discard remaining data in video pipe */
487	junk = kmalloc(size: junk_len, GFP_KERNEL);
488	if (!junk)
489	return;
490	while (1) {
491	if (usb_bulk_msg(usb_dev: d->udev,
492	usb_rcvbulkpipe(d->udev, p->endpoint),
493	data: junk, len: junk_len, actual_length: &rd_count, timeout) < 0)
494	break;
495	if (!rd_count)
496	break;
497	}
498	kfree(objp: junk);
499	}
500
501	static int cxusb_d680_dmb_streaming_ctrl(struct dvb_usb_adapter *adap,
502	int onoff)
503	{
504	if (onoff) {
505	u8 buf[2] = { 0x03, 0x00 };
506
507	cxusb_d680_dmb_drain_video(d: adap->dev);
508	return cxusb_ctrl_msg(d: adap->dev, CMD_STREAMING_ON,
509	wbuf: buf, wlen: sizeof(buf), NULL, rlen: 0);
510	} else {
511	int ret = cxusb_ctrl_msg(d: adap->dev,
512	CMD_STREAMING_OFF, NULL, wlen: 0, NULL, rlen: 0);
513	return ret;
514	}
515	}
516
517	static int cxusb_rc_query(struct dvb_usb_device *d)
518	{
519	u8 ircode[4];
520
521	if (cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, wlen: 0, rbuf: ircode, rlen: 4) < 0)
522	return 0;
523
524	if (ircode[2] || ircode[3])
525	rc_keydown(dev: d->rc_dev, protocol: RC_PROTO_NEC,
526	RC_SCANCODE_NEC(~ircode[2] & 0xff, ircode[3]), toggle: 0);
527	return 0;
528	}
529
530	static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d)
531	{
532	u8 ircode[4];
533	struct i2c_msg msg = {
534	.addr = 0x6b,
535	.flags = I2C_M_RD,
536	.buf = ircode,
537	.len = 4
538	};
539
540	if (cxusb_i2c_xfer(adap: &d->i2c_adap, msg: &msg, num: 1) != 1)
541	return 0;
542
543	if (ircode[1] || ircode[2])
544	rc_keydown(dev: d->rc_dev, protocol: RC_PROTO_NEC,
545	RC_SCANCODE_NEC(~ircode[1] & 0xff, ircode[2]), toggle: 0);
546	return 0;
547	}
548
549	static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d)
550	{
551	u8 ircode[2];
552
553	if (cxusb_ctrl_msg(d, cmd: 0x10, NULL, wlen: 0, rbuf: ircode, rlen: 2) < 0)
554	return 0;
555
556	if (ircode[0] || ircode[1])
557	rc_keydown(dev: d->rc_dev, protocol: RC_PROTO_UNKNOWN,
558	RC_SCANCODE_RC5(ircode[0], ircode[1]), toggle: 0);
559	return 0;
560	}
561
562	static int cxusb_dee1601_demod_init(struct dvb_frontend *fe)
563	{
564	static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x28 };
565	static u8 reset[] = { RESET, 0x80 };
566	static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
567	static u8 agc_cfg[] = { AGC_TARGET, 0x28, 0x20 };
568	static u8 gpp_ctl_cfg[] = { GPP_CTL, 0x33 };
569	static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
570
571	mt352_write(fe, buf: clock_config, len: sizeof(clock_config));
572	udelay(200);
573	mt352_write(fe, buf: reset, len: sizeof(reset));
574	mt352_write(fe, buf: adc_ctl_1_cfg, len: sizeof(adc_ctl_1_cfg));
575
576	mt352_write(fe, buf: agc_cfg, len: sizeof(agc_cfg));
577	mt352_write(fe, buf: gpp_ctl_cfg, len: sizeof(gpp_ctl_cfg));
578	mt352_write(fe, buf: capt_range_cfg, len: sizeof(capt_range_cfg));
579
580	return 0;
581	}
582
583	static int cxusb_mt352_demod_init(struct dvb_frontend *fe)
584	{
585	/* used in both lgz201 and th7579 */
586	static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x29 };
587	static u8 reset[] = { RESET, 0x80 };
588	static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
589	static u8 agc_cfg[] = { AGC_TARGET, 0x24, 0x20 };
590	static u8 gpp_ctl_cfg[] = { GPP_CTL, 0x33 };
591	static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
592
593	mt352_write(fe, buf: clock_config, len: sizeof(clock_config));
594	udelay(200);
595	mt352_write(fe, buf: reset, len: sizeof(reset));
596	mt352_write(fe, buf: adc_ctl_1_cfg, len: sizeof(adc_ctl_1_cfg));
597
598	mt352_write(fe, buf: agc_cfg, len: sizeof(agc_cfg));
599	mt352_write(fe, buf: gpp_ctl_cfg, len: sizeof(gpp_ctl_cfg));
600	mt352_write(fe, buf: capt_range_cfg, len: sizeof(capt_range_cfg));
601	return 0;
602	}
603
604	static struct cx22702_config cxusb_cx22702_config = {
605	.demod_address = 0x63,
606	.output_mode = CX22702_PARALLEL_OUTPUT,
607	};
608
609	static struct lgdt330x_config cxusb_lgdt3303_config = {
610	.demod_chip = LGDT3303,
611	};
612
613	static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
614	.demod_chip = LGDT3303,
615	.clock_polarity_flip = 2,
616	};
617
618	static struct mt352_config cxusb_dee1601_config = {
619	.demod_address = 0x0f,
620	.demod_init = cxusb_dee1601_demod_init,
621	};
622
623	static struct zl10353_config cxusb_zl10353_dee1601_config = {
624	.demod_address = 0x0f,
625	.parallel_ts = 1,
626	};
627
628	static struct mt352_config cxusb_mt352_config = {
629	/* used in both lgz201 and th7579 */
630	.demod_address = 0x0f,
631	.demod_init = cxusb_mt352_demod_init,
632	};
633
634	static struct zl10353_config cxusb_zl10353_xc3028_config = {
635	.demod_address = 0x0f,
636	.if2 = 45600,
637	.no_tuner = 1,
638	.parallel_ts = 1,
639	};
640
641	static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
642	.demod_address = 0x0f,
643	.if2 = 45600,
644	.no_tuner = 1,
645	.parallel_ts = 1,
646	.disable_i2c_gate_ctrl = 1,
647	};
648
649	static struct mt352_config cxusb_mt352_xc3028_config = {
650	.demod_address = 0x0f,
651	.if2 = 4560,
652	.no_tuner = 1,
653	.demod_init = cxusb_mt352_demod_init,
654	};
655
656	/* FIXME: needs tweaking */
657	static struct mxl5005s_config aver_a868r_tuner = {
658	.i2c_address = 0x63,
659	.if_freq = 6000000UL,
660	.xtal_freq = CRYSTAL_FREQ_16000000HZ,
661	.agc_mode = MXL_SINGLE_AGC,
662	.tracking_filter = MXL_TF_C,
663	.rssi_enable = MXL_RSSI_ENABLE,
664	.cap_select = MXL_CAP_SEL_ENABLE,
665	.div_out = MXL_DIV_OUT_4,
666	.clock_out = MXL_CLOCK_OUT_DISABLE,
667	.output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
668	.top = MXL5005S_TOP_25P2,
669	.mod_mode = MXL_DIGITAL_MODE,
670	.if_mode = MXL_ZERO_IF,
671	.AgcMasterByte = 0x00,
672	};
673
674	/* FIXME: needs tweaking */
675	static struct mxl5005s_config d680_dmb_tuner = {
676	.i2c_address = 0x63,
677	.if_freq = 36125000UL,
678	.xtal_freq = CRYSTAL_FREQ_16000000HZ,
679	.agc_mode = MXL_SINGLE_AGC,
680	.tracking_filter = MXL_TF_C,
681	.rssi_enable = MXL_RSSI_ENABLE,
682	.cap_select = MXL_CAP_SEL_ENABLE,
683	.div_out = MXL_DIV_OUT_4,
684	.clock_out = MXL_CLOCK_OUT_DISABLE,
685	.output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
686	.top = MXL5005S_TOP_25P2,
687	.mod_mode = MXL_DIGITAL_MODE,
688	.if_mode = MXL_ZERO_IF,
689	.AgcMasterByte = 0x00,
690	};
691
692	static struct max2165_config mygica_d689_max2165_cfg = {
693	.i2c_address = 0x60,
694	.osc_clk = 20
695	};
696
697	/* Callbacks for DVB USB */
698	static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
699	{
700	struct dvb_usb_device *dvbdev = adap->dev;
701	bool is_medion = dvbdev->props.devices[0].warm_ids[0] ==
702	&cxusb_table[MEDION_MD95700];
703
704	dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
705	&dvbdev->i2c_adap, 0x61,
706	TUNER_PHILIPS_FMD1216ME_MK3);
707
708	if (is_medion && adap->fe_adap[0].fe)
709	/*
710	* make sure that DVB core won't put to sleep (reset, really)
711	* tuner when we might be open in analog mode
712	*/
713	adap->fe_adap[0].fe->ops.tuner_ops.sleep = NULL;
714
715	return 0;
716	}
717
718	static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
719	{
720	dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
721	NULL, DVB_PLL_THOMSON_DTT7579);
722	return 0;
723	}
724
725	static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
726	{
727	dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
728	NULL, DVB_PLL_LG_Z201);
729	return 0;
730	}
731
732	static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
733	{
734	dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
735	NULL, DVB_PLL_THOMSON_DTT7579);
736	return 0;
737	}
738
739	static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
740	{
741	dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
742	&adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
743	return 0;
744	}
745
746	static int dvico_bluebird_xc2028_callback(void *ptr, int component,
747	int command, int arg)
748	{
749	struct dvb_usb_adapter *adap = ptr;
750	struct dvb_usb_device *d = adap->dev;
751
752	switch (command) {
753	case XC2028_TUNER_RESET:
754	dev_info(&d->udev->dev, "XC2028_TUNER_RESET %d\n", arg);
755	cxusb_bluebird_gpio_pulse(d, pin: 0x01, low: 1);
756	break;
757	case XC2028_RESET_CLK:
758	dev_info(&d->udev->dev, "XC2028_RESET_CLK %d\n", arg);
759	break;
760	case XC2028_I2C_FLUSH:
761	break;
762	default:
763	dev_info(&d->udev->dev, "unknown command %d, arg %d\n",
764	command, arg);
765	return -EINVAL;
766	}
767
768	return 0;
769	}
770
771	static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
772	{
773	struct dvb_frontend *fe;
774	struct xc2028_config cfg = {
775	.i2c_adap = &adap->dev->i2c_adap,
776	.i2c_addr = 0x61,
777	};
778	static struct xc2028_ctrl ctl = {
779	.fname = XC2028_DEFAULT_FIRMWARE,
780	.max_len = 64,
781	.demod = XC3028_FE_ZARLINK456,
782	};
783
784	/* FIXME: generalize & move to common area */
785	adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback;
786
787	fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg);
788	if (!fe || !fe->ops.tuner_ops.set_config)
789	return -EIO;
790
791	fe->ops.tuner_ops.set_config(fe, &ctl);
792
793	return 0;
794	}
795
796	static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
797	{
798	dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
799	&adap->dev->i2c_adap, &aver_a868r_tuner);
800	return 0;
801	}
802
803	static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
804	{
805	struct dvb_frontend *fe;
806
807	fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
808	&adap->dev->i2c_adap, &d680_dmb_tuner);
809	return (!fe) ? -EIO : 0;
810	}
811
812	static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
813	{
814	struct dvb_frontend *fe;
815
816	fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe,
817	&adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
818	return (!fe) ? -EIO : 0;
819	}
820
821	static int cxusb_medion_fe_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
822	{
823	struct dvb_usb_adapter *adap = fe->dvb->priv;
824	struct dvb_usb_device *dvbdev = adap->dev;
825
826	if (acquire)
827	return cxusb_medion_get(dvbdev, open_type: CXUSB_OPEN_DIGITAL);
828
829	cxusb_medion_put(dvbdev);
830
831	return 0;
832	}
833
834	static int cxusb_medion_set_mode(struct dvb_usb_device *dvbdev, bool digital)
835	{
836	struct cxusb_state *st = dvbdev->priv;
837	int ret;
838	u8 b;
839	unsigned int i;
840
841	/*
842	* switching mode while doing an I2C transaction often causes
843	* the device to crash
844	*/
845	mutex_lock(&dvbdev->i2c_mutex);
846
847	if (digital) {
848	ret = usb_set_interface(dev: dvbdev->udev, ifnum: 0, alternate: 6);
849	if (ret != 0) {
850	dev_err(&dvbdev->udev->dev,
851	"digital interface selection failed (%d)\n",
852	ret);
853	goto ret_unlock;
854	}
855	} else {
856	ret = usb_set_interface(dev: dvbdev->udev, ifnum: 0, alternate: 1);
857	if (ret != 0) {
858	dev_err(&dvbdev->udev->dev,
859	"analog interface selection failed (%d)\n",
860	ret);
861	goto ret_unlock;
862	}
863	}
864
865	/* pipes need to be cleared after setting interface */
866	ret = usb_clear_halt(dev: dvbdev->udev, usb_rcvbulkpipe(dvbdev->udev, 1));
867	if (ret != 0)
868	dev_warn(&dvbdev->udev->dev,
869	"clear halt on IN pipe failed (%d)\n",
870	ret);
871
872	ret = usb_clear_halt(dev: dvbdev->udev, usb_sndbulkpipe(dvbdev->udev, 1));
873	if (ret != 0)
874	dev_warn(&dvbdev->udev->dev,
875	"clear halt on OUT pipe failed (%d)\n",
876	ret);
877
878	ret = cxusb_ctrl_msg(d: dvbdev, cmd: digital ? CMD_DIGITAL : CMD_ANALOG,
879	NULL, wlen: 0, rbuf: &b, rlen: 1);
880	if (ret != 0) {
881	dev_err(&dvbdev->udev->dev, "mode switch failed (%d)\n",
882	ret);
883	goto ret_unlock;
884	}
885
886	/* mode switch seems to reset GPIO states */
887	for (i = 0; i < ARRAY_SIZE(st->gpio_write_refresh); i++)
888	st->gpio_write_refresh[i] = true;
889
890	ret_unlock:
891	mutex_unlock(lock: &dvbdev->i2c_mutex);
892
893	return ret;
894	}
895
896	static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
897	{
898	struct dvb_usb_device *dvbdev = adap->dev;
899	bool is_medion = dvbdev->props.devices[0].warm_ids[0] ==
900	&cxusb_table[MEDION_MD95700];
901
902	if (is_medion) {
903	int ret;
904
905	ret = cxusb_medion_set_mode(dvbdev, digital: true);
906	if (ret)
907	return ret;
908	}
909
910	adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
911	&dvbdev->i2c_adap);
912	if (!adap->fe_adap[0].fe)
913	return -EIO;
914
915	if (is_medion)
916	adap->fe_adap[0].fe->ops.ts_bus_ctrl =
917	cxusb_medion_fe_ts_bus_ctrl;
918
919	return 0;
920	}
921
922	static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
923	{
924	if (usb_set_interface(dev: adap->dev->udev, ifnum: 0, alternate: 7) < 0)
925	err("set interface failed");
926
927	cxusb_ctrl_msg(d: adap->dev, CMD_DIGITAL, NULL, wlen: 0, NULL, rlen: 0);
928
929	adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
930	&cxusb_lgdt3303_config,
931	0x0e,
932	&adap->dev->i2c_adap);
933	if (adap->fe_adap[0].fe)
934	return 0;
935
936	return -EIO;
937	}
938
939	static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
940	{
941	adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
942	&cxusb_aver_lgdt3303_config,
943	0x0e,
944	&adap->dev->i2c_adap);
945	if (adap->fe_adap[0].fe)
946	return 0;
947
948	return -EIO;
949	}
950
951	static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
952	{
953	/* used in both lgz201 and th7579 */
954	if (usb_set_interface(dev: adap->dev->udev, ifnum: 0, alternate: 0) < 0)
955	err("set interface failed");
956
957	cxusb_ctrl_msg(d: adap->dev, CMD_DIGITAL, NULL, wlen: 0, NULL, rlen: 0);
958
959	adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
960	&adap->dev->i2c_adap);
961	if (adap->fe_adap[0].fe)
962	return 0;
963
964	return -EIO;
965	}
966
967	static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
968	{
969	if (usb_set_interface(dev: adap->dev->udev, ifnum: 0, alternate: 0) < 0)
970	err("set interface failed");
971
972	cxusb_ctrl_msg(d: adap->dev, CMD_DIGITAL, NULL, wlen: 0, NULL, rlen: 0);
973
974	adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
975	&adap->dev->i2c_adap);
976	if (adap->fe_adap[0].fe)
977	return 0;
978
979	adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
980	&cxusb_zl10353_dee1601_config,
981	&adap->dev->i2c_adap);
982	if (adap->fe_adap[0].fe)
983	return 0;
984
985	return -EIO;
986	}
987
988	static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
989	{
990	u8 ircode[4];
991	int i;
992	struct i2c_msg msg = {
993	.addr = 0x6b,
994	.flags = I2C_M_RD,
995	.buf = ircode,
996	.len = 4
997	};
998
999	if (usb_set_interface(dev: adap->dev->udev, ifnum: 0, alternate: 1) < 0)
1000	err("set interface failed");
1001
1002	cxusb_ctrl_msg(d: adap->dev, CMD_DIGITAL, NULL, wlen: 0, NULL, rlen: 0);
1003
1004	/* reset the tuner and demodulator */
1005	cxusb_bluebird_gpio_rw(d: adap->dev, changemask: 0x04, newval: 0);
1006	cxusb_bluebird_gpio_pulse(d: adap->dev, pin: 0x01, low: 1);
1007	cxusb_bluebird_gpio_pulse(d: adap->dev, pin: 0x02, low: 1);
1008
1009	adap->fe_adap[0].fe =
1010	dvb_attach(zl10353_attach,
1011	&cxusb_zl10353_xc3028_config_no_i2c_gate,
1012	&adap->dev->i2c_adap);
1013	if (!adap->fe_adap[0].fe)
1014	return -EIO;
1015
1016	/* try to determine if there is no IR decoder on the I2C bus */
1017	for (i = 0; adap->dev->props.rc.core.rc_codes && i < 5; i++) {
1018	msleep(msecs: 20);
1019	if (cxusb_i2c_xfer(adap: &adap->dev->i2c_adap, msg: &msg, num: 1) != 1)
1020	goto no_IR;
1021	if (ircode[0] == 0 && ircode[1] == 0)
1022	continue;
1023	if (ircode[2] + ircode[3] != 0xff) {
1024	no_IR:
1025	adap->dev->props.rc.core.rc_codes = NULL;
1026	info("No IR receiver detected on this device.");
1027	break;
1028	}
1029	}
1030
1031	return 0;
1032	}
1033
1034	static struct dibx000_agc_config dib7070_agc_config = {
1035	.band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1036
1037	/*
1038	* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
1039	* P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1040	* P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
1041	*/
1042	.setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
1043	(0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1044	.inv_gain = 600,
1045	.time_stabiliz = 10,
1046	.alpha_level = 0,
1047	.thlock = 118,
1048	.wbd_inv = 0,
1049	.wbd_ref = 3530,
1050	.wbd_sel = 1,
1051	.wbd_alpha = 5,
1052	.agc1_max = 65535,
1053	.agc1_min = 0,
1054	.agc2_max = 65535,
1055	.agc2_min = 0,
1056	.agc1_pt1 = 0,
1057	.agc1_pt2 = 40,
1058	.agc1_pt3 = 183,
1059	.agc1_slope1 = 206,
1060	.agc1_slope2 = 255,
1061	.agc2_pt1 = 72,
1062	.agc2_pt2 = 152,
1063	.agc2_slope1 = 88,
1064	.agc2_slope2 = 90,
1065	.alpha_mant = 17,
1066	.alpha_exp = 27,
1067	.beta_mant = 23,
1068	.beta_exp = 51,
1069	.perform_agc_softsplit = 0,
1070	};
1071
1072	static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1073	.internal = 60000,
1074	.sampling = 15000,
1075	.pll_prediv = 1,
1076	.pll_ratio = 20,
1077	.pll_range = 3,
1078	.pll_reset = 1,
1079	.pll_bypass = 0,
1080	.enable_refdiv = 0,
1081	.bypclk_div = 0,
1082	.IO_CLK_en_core = 1,
1083	.ADClkSrc = 1,
1084	.modulo = 2,
1085	/* refsel, sel, freq_15k */
1086	.sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1087	.ifreq = (0 << 25) | 0,
1088	.timf = 20452225,
1089	.xtal_hz = 12000000,
1090	};
1091
1092	static struct dib7000p_config cxusb_dualdig4_rev2_config = {
1093	.output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
1094	.output_mpeg2_in_188_bytes = 1,
1095
1096	.agc_config_count = 1,
1097	.agc = &dib7070_agc_config,
1098	.bw = &dib7070_bw_config_12_mhz,
1099	.tuner_is_baseband = 1,
1100	.spur_protect = 1,
1101
1102	.gpio_dir = 0xfcef,
1103	.gpio_val = 0x0110,
1104
1105	.gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1106
1107	.hostbus_diversity = 1,
1108	};
1109
1110	struct dib0700_adapter_state {
1111	int (*set_param_save)(struct dvb_frontend *fe);
1112	struct dib7000p_ops dib7000p_ops;
1113	};
1114
1115	static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1116	{
1117	struct dib0700_adapter_state *state = adap->priv;
1118
1119	if (usb_set_interface(dev: adap->dev->udev, ifnum: 0, alternate: 1) < 0)
1120	err("set interface failed");
1121
1122	cxusb_ctrl_msg(d: adap->dev, CMD_DIGITAL, NULL, wlen: 0, NULL, rlen: 0);
1123
1124	cxusb_bluebird_gpio_pulse(d: adap->dev, pin: 0x02, low: 1);
1125
1126	if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1127	return -ENODEV;
1128
1129	if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1130	&cxusb_dualdig4_rev2_config) < 0) {
1131	pr_warn("Unable to enumerate dib7000p\n");
1132	return -ENODEV;
1133	}
1134
1135	adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
1136	0x80,
1137	&cxusb_dualdig4_rev2_config);
1138	if (!adap->fe_adap[0].fe)
1139	return -EIO;
1140
1141	return 0;
1142	}
1143
1144	static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1145	{
1146	struct dvb_usb_adapter *adap = fe->dvb->priv;
1147	struct dib0700_adapter_state *state = adap->priv;
1148
1149	return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
1150	}
1151
1152	static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1153	{
1154	return 0;
1155	}
1156
1157	static struct dib0070_config dib7070p_dib0070_config = {
1158	.i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1159	.reset = dib7070_tuner_reset,
1160	.sleep = dib7070_tuner_sleep,
1161	.clock_khz = 12000,
1162	};
1163
1164	static int dib7070_set_param_override(struct dvb_frontend *fe)
1165	{
1166	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1167	struct dvb_usb_adapter *adap = fe->dvb->priv;
1168	struct dib0700_adapter_state *state = adap->priv;
1169
1170	u16 offset;
1171	u8 band = BAND_OF_FREQUENCY(p->frequency / 1000);
1172
1173	switch (band) {
1174	case BAND_VHF:
1175	offset = 950;
1176	break;
1177	default:
1178	case BAND_UHF:
1179	offset = 550;
1180	break;
1181	}
1182
1183	state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1184
1185	return state->set_param_save(fe);
1186	}
1187
1188	static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1189	{
1190	struct dib0700_adapter_state *st = adap->priv;
1191	struct i2c_adapter *tun_i2c;
1192
1193	/*
1194	* No need to call dvb7000p_attach here, as it was called
1195	* already, as frontend_attach method is called first, and
1196	* tuner_attach is only called on success.
1197	*/
1198	tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
1199	DIBX000_I2C_INTERFACE_TUNER, 1);
1200
1201	if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1202	&dib7070p_dib0070_config) == NULL)
1203	return -ENODEV;
1204
1205	st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1206	adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1207	return 0;
1208	}
1209
1210	static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1211	{
1212	if (usb_set_interface(dev: adap->dev->udev, ifnum: 0, alternate: 1) < 0)
1213	err("set interface failed");
1214
1215	cxusb_ctrl_msg(d: adap->dev, CMD_DIGITAL, NULL, wlen: 0, NULL, rlen: 0);
1216
1217	/* reset the tuner and demodulator */
1218	cxusb_bluebird_gpio_rw(d: adap->dev, changemask: 0x04, newval: 0);
1219	cxusb_bluebird_gpio_pulse(d: adap->dev, pin: 0x01, low: 1);
1220	cxusb_bluebird_gpio_pulse(d: adap->dev, pin: 0x02, low: 1);
1221
1222	adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
1223	&cxusb_zl10353_xc3028_config,
1224	&adap->dev->i2c_adap);
1225	if (adap->fe_adap[0].fe)
1226	return 0;
1227
1228	adap->fe_adap[0].fe = dvb_attach(mt352_attach,
1229	&cxusb_mt352_xc3028_config,
1230	&adap->dev->i2c_adap);
1231	if (adap->fe_adap[0].fe)
1232	return 0;
1233
1234	return -EIO;
1235	}
1236
1237	static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1238	.prod = LGS8GXX_PROD_LGS8GL5,
1239	.demod_address = 0x19,
1240	.serial_ts = 0,
1241	.ts_clk_pol = 0,
1242	.ts_clk_gated = 1,
1243	.if_clk_freq = 30400, /* 30.4 MHz */
1244	.if_freq = 5725, /* 5.725 MHz */
1245	.if_neg_center = 0,
1246	.ext_adc = 0,
1247	.adc_signed = 0,
1248	.if_neg_edge = 0,
1249	};
1250
1251	static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1252	{
1253	struct dvb_usb_device *d = adap->dev;
1254	int n;
1255
1256	/* Select required USB configuration */
1257	if (usb_set_interface(dev: d->udev, ifnum: 0, alternate: 0) < 0)
1258	err("set interface failed");
1259
1260	/* Unblock all USB pipes */
1261	usb_clear_halt(dev: d->udev,
1262	usb_sndbulkpipe(d->udev,
1263	d->props.generic_bulk_ctrl_endpoint));
1264	usb_clear_halt(dev: d->udev,
1265	usb_rcvbulkpipe(d->udev,
1266	d->props.generic_bulk_ctrl_endpoint));
1267	usb_clear_halt(dev: d->udev,
1268	usb_rcvbulkpipe(d->udev,
1269	d->props.adapter[0].fe[0].stream.endpoint));
1270
1271	/* Drain USB pipes to avoid hang after reboot */
1272	for (n = 0; n < 5; n++) {
1273	cxusb_d680_dmb_drain_message(d);
1274	cxusb_d680_dmb_drain_video(d);
1275	msleep(msecs: 200);
1276	}
1277
1278	/* Reset the tuner */
1279	if (cxusb_d680_dmb_gpio_tuner(d, addr: 0x07, onoff: 0) < 0) {
1280	err("clear tuner gpio failed");
1281	return -EIO;
1282	}
1283	msleep(msecs: 100);
1284	if (cxusb_d680_dmb_gpio_tuner(d, addr: 0x07, onoff: 1) < 0) {
1285	err("set tuner gpio failed");
1286	return -EIO;
1287	}
1288	msleep(msecs: 100);
1289
1290	/* Attach frontend */
1291	adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach,
1292	&d680_lgs8gl5_cfg, &d->i2c_adap);
1293	if (!adap->fe_adap[0].fe)
1294	return -EIO;
1295
1296	return 0;
1297	}
1298
1299	static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1300	.prod = ATBM8830_PROD_8830,
1301	.demod_address = 0x40,
1302	.serial_ts = 0,
1303	.ts_sampling_edge = 1,
1304	.ts_clk_gated = 0,
1305	.osc_clk_freq = 30400, /* in kHz */
1306	.if_freq = 0, /* zero IF */
1307	.zif_swap_iq = 1,
1308	.agc_min = 0x2E,
1309	.agc_max = 0x90,
1310	.agc_hold_loop = 0,
1311	};
1312
1313	static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1314	{
1315	struct dvb_usb_device *d = adap->dev;
1316
1317	/* Select required USB configuration */
1318	if (usb_set_interface(dev: d->udev, ifnum: 0, alternate: 0) < 0)
1319	err("set interface failed");
1320
1321	/* Unblock all USB pipes */
1322	usb_clear_halt(dev: d->udev,
1323	usb_sndbulkpipe(d->udev,
1324	d->props.generic_bulk_ctrl_endpoint));
1325	usb_clear_halt(dev: d->udev,
1326	usb_rcvbulkpipe(d->udev,
1327	d->props.generic_bulk_ctrl_endpoint));
1328	usb_clear_halt(dev: d->udev,
1329	usb_rcvbulkpipe(d->udev,
1330	d->props.adapter[0].fe[0].stream.endpoint));
1331
1332	/* Reset the tuner */
1333	if (cxusb_d680_dmb_gpio_tuner(d, addr: 0x07, onoff: 0) < 0) {
1334	err("clear tuner gpio failed");
1335	return -EIO;
1336	}
1337	msleep(msecs: 100);
1338	if (cxusb_d680_dmb_gpio_tuner(d, addr: 0x07, onoff: 1) < 0) {
1339	err("set tuner gpio failed");
1340	return -EIO;
1341	}
1342	msleep(msecs: 100);
1343
1344	/* Attach frontend */
1345	adap->fe_adap[0].fe = dvb_attach(atbm8830_attach,
1346	&mygica_d689_atbm8830_cfg,
1347	&d->i2c_adap);
1348	if (!adap->fe_adap[0].fe)
1349	return -EIO;
1350
1351	return 0;
1352	}
1353
1354	/*
1355	* DViCO has shipped two devices with the same USB ID, but only one of them
1356	* needs a firmware download. Check the device class details to see if they
1357	* have non-default values to decide whether the device is actually cold or
1358	* not, and forget a match if it turns out we selected the wrong device.
1359	*/
1360	static int bluebird_fx2_identify_state(struct usb_device *udev,
1361	const struct dvb_usb_device_properties *props,
1362	const struct dvb_usb_device_description **desc,
1363	int *cold)
1364	{
1365	int wascold = *cold;
1366
1367	*cold = udev->descriptor.bDeviceClass == 0xff &&
1368	udev->descriptor.bDeviceSubClass == 0xff &&
1369	udev->descriptor.bDeviceProtocol == 0xff;
1370
1371	if (*cold && !wascold)
1372	*desc = NULL;
1373
1374	return 0;
1375	}
1376
1377	/*
1378	* DViCO bluebird firmware needs the "warm" product ID to be patched into the
1379	* firmware file before download.
1380	*/
1381
1382	static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1383	static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1384	const struct firmware *fw)
1385	{
1386	int pos;
1387
1388	for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1389	int idoff = dvico_firmware_id_offsets[pos];
1390
1391	if (fw->size < idoff + 4)
1392	continue;
1393
1394	if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1395	fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1396	struct firmware new_fw;
1397	u8 *new_fw_data = vmalloc(size: fw->size);
1398	int ret;
1399
1400	if (!new_fw_data)
1401	return -ENOMEM;
1402
1403	memcpy(new_fw_data, fw->data, fw->size);
1404	new_fw.size = fw->size;
1405	new_fw.data = new_fw_data;
1406
1407	new_fw_data[idoff + 2] =
1408	le16_to_cpu(udev->descriptor.idProduct) + 1;
1409	new_fw_data[idoff + 3] =
1410	le16_to_cpu(udev->descriptor.idProduct) >> 8;
1411
1412	ret = usb_cypress_load_firmware(udev, fw: &new_fw,
1413	CYPRESS_FX2);
1414	vfree(addr: new_fw_data);
1415	return ret;
1416	}
1417	}
1418
1419	return -EINVAL;
1420	}
1421
1422	int cxusb_medion_get(struct dvb_usb_device *dvbdev,
1423	enum cxusb_open_type open_type)
1424	{
1425	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1426	int ret = 0;
1427
1428	mutex_lock(&cxdev->open_lock);
1429
1430	if (WARN_ON((cxdev->open_type == CXUSB_OPEN_INIT ||
1431	cxdev->open_type == CXUSB_OPEN_NONE) &&
1432	cxdev->open_ctr != 0)) {
1433	ret = -EINVAL;
1434	goto ret_unlock;
1435	}
1436
1437	if (cxdev->open_type == CXUSB_OPEN_INIT) {
1438	ret = -EAGAIN;
1439	goto ret_unlock;
1440	}
1441
1442	if (cxdev->open_ctr == 0) {
1443	if (cxdev->open_type != open_type) {
1444	dev_info(&dvbdev->udev->dev, "will acquire and switch to %s\n",
1445	open_type == CXUSB_OPEN_ANALOG ?
1446	"analog" : "digital");
1447
1448	if (open_type == CXUSB_OPEN_ANALOG) {
1449	ret = _cxusb_power_ctrl(d: dvbdev, onoff: 1);
1450	if (ret != 0)
1451	dev_warn(&dvbdev->udev->dev,
1452	"powerup for analog switch failed (%d)\n",
1453	ret);
1454
1455	ret = cxusb_medion_set_mode(dvbdev, digital: false);
1456	if (ret != 0)
1457	goto ret_unlock;
1458
1459	ret = cxusb_medion_analog_init(dvbdev);
1460	if (ret != 0)
1461	goto ret_unlock;
1462	} else { /* digital */
1463	ret = _cxusb_power_ctrl(d: dvbdev, onoff: 1);
1464	if (ret != 0)
1465	dev_warn(&dvbdev->udev->dev,
1466	"powerup for digital switch failed (%d)\n",
1467	ret);
1468
1469	ret = cxusb_medion_set_mode(dvbdev, digital: true);
1470	if (ret != 0)
1471	goto ret_unlock;
1472	}
1473
1474	cxdev->open_type = open_type;
1475	} else {
1476	dev_info(&dvbdev->udev->dev, "reacquired idle %s\n",
1477	open_type == CXUSB_OPEN_ANALOG ?
1478	"analog" : "digital");
1479	}
1480
1481	cxdev->open_ctr = 1;
1482	} else if (cxdev->open_type == open_type) {
1483	cxdev->open_ctr++;
1484	dev_info(&dvbdev->udev->dev, "acquired %s\n",
1485	open_type == CXUSB_OPEN_ANALOG ? "analog" : "digital");
1486	} else {
1487	ret = -EBUSY;
1488	}
1489
1490	ret_unlock:
1491	mutex_unlock(lock: &cxdev->open_lock);
1492
1493	return ret;
1494	}
1495
1496	void cxusb_medion_put(struct dvb_usb_device *dvbdev)
1497	{
1498	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1499
1500	mutex_lock(&cxdev->open_lock);
1501
1502	if (cxdev->open_type == CXUSB_OPEN_INIT) {
1503	WARN_ON(cxdev->open_ctr != 0);
1504	cxdev->open_type = CXUSB_OPEN_NONE;
1505	goto unlock;
1506	}
1507
1508	if (!WARN_ON(cxdev->open_ctr < 1)) {
1509	cxdev->open_ctr--;
1510
1511	dev_info(&dvbdev->udev->dev, "release %s\n",
1512	cxdev->open_type == CXUSB_OPEN_ANALOG ?
1513	"analog" : "digital");
1514	}
1515
1516	unlock:
1517	mutex_unlock(lock: &cxdev->open_lock);
1518	}
1519
1520	/* DVB USB Driver stuff */
1521	static struct dvb_usb_device_properties cxusb_medion_properties;
1522	static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1523	static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1524	static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1525	static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1526	static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1527	static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1528	static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1529	static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1530	static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1531	static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1532	static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
1533
1534	static int cxusb_medion_priv_init(struct dvb_usb_device *dvbdev)
1535	{
1536	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1537
1538	cxdev->dvbdev = dvbdev;
1539	cxdev->open_type = CXUSB_OPEN_INIT;
1540	mutex_init(&cxdev->open_lock);
1541
1542	return 0;
1543	}
1544
1545	static void cxusb_medion_priv_destroy(struct dvb_usb_device *dvbdev)
1546	{
1547	struct cxusb_medion_dev *cxdev = dvbdev->priv;
1548
1549	mutex_destroy(lock: &cxdev->open_lock);
1550	}
1551
1552	static bool cxusb_medion_check_altsetting(struct usb_host_interface *as)
1553	{
1554	unsigned int ctr;
1555
1556	for (ctr = 0; ctr < as->desc.bNumEndpoints; ctr++) {
1557	if ((as->endpoint[ctr].desc.bEndpointAddress &
1558	USB_ENDPOINT_NUMBER_MASK) != 2)
1559	continue;
1560
1561	if (as->endpoint[ctr].desc.bEndpointAddress & USB_DIR_IN &&
1562	((as->endpoint[ctr].desc.bmAttributes &
1563	USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC))
1564	return true;
1565
1566	break;
1567	}
1568
1569	return false;
1570	}
1571
1572	static bool cxusb_medion_check_intf(struct usb_interface *intf)
1573	{
1574	unsigned int ctr;
1575
1576	if (intf->num_altsetting < 2) {
1577	dev_err(intf->usb_dev, "no alternate interface");
1578
1579	return false;
1580	}
1581
1582	for (ctr = 0; ctr < intf->num_altsetting; ctr++) {
1583	if (intf->altsetting[ctr].desc.bAlternateSetting != 1)
1584	continue;
1585
1586	if (cxusb_medion_check_altsetting(as: &intf->altsetting[ctr]))
1587	return true;
1588
1589	break;
1590	}
1591
1592	dev_err(intf->usb_dev, "no iso interface");
1593
1594	return false;
1595	}
1596
1597	static int cxusb_probe(struct usb_interface *intf,
1598	const struct usb_device_id *id)
1599	{
1600	struct dvb_usb_device *dvbdev;
1601	int ret;
1602
1603	/* Medion 95700 */
1604	if (!dvb_usb_device_init(intf, &cxusb_medion_properties,
1605	THIS_MODULE, &dvbdev, adapter_nums: adapter_nr)) {
1606	if (!cxusb_medion_check_intf(intf)) {
1607	ret = -ENODEV;
1608	goto ret_uninit;
1609	}
1610
1611	_cxusb_power_ctrl(d: dvbdev, onoff: 1);
1612	ret = cxusb_medion_set_mode(dvbdev, digital: false);
1613	if (ret)
1614	goto ret_uninit;
1615
1616	ret = cxusb_medion_register_analog(dvbdev);
1617
1618	cxusb_medion_set_mode(dvbdev, digital: true);
1619	_cxusb_power_ctrl(d: dvbdev, onoff: 0);
1620
1621	if (ret != 0)
1622	goto ret_uninit;
1623
1624	/* release device from INIT mode to normal operation */
1625	cxusb_medion_put(dvbdev);
1626
1627	return 0;
1628	} else if (!dvb_usb_device_init(intf,
1629	&cxusb_bluebird_lgh064f_properties,
1630	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1631	!dvb_usb_device_init(intf,
1632	&cxusb_bluebird_dee1601_properties,
1633	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1634	!dvb_usb_device_init(intf,
1635	&cxusb_bluebird_lgz201_properties,
1636	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1637	!dvb_usb_device_init(intf,
1638	&cxusb_bluebird_dtt7579_properties,
1639	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1640	!dvb_usb_device_init(intf,
1641	&cxusb_bluebird_dualdig4_properties,
1642	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1643	!dvb_usb_device_init(intf,
1644	&cxusb_bluebird_nano2_properties,
1645	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1646	!dvb_usb_device_init(intf,
1647	&cxusb_bluebird_nano2_needsfirmware_properties,
1648	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1649	!dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1650	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1651	!dvb_usb_device_init(intf,
1652	&cxusb_bluebird_dualdig4_rev2_properties,
1653	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1654	!dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1655	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1656	!dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1657	THIS_MODULE, NULL, adapter_nums: adapter_nr) ||
1658	0)
1659	return 0;
1660
1661	return -EINVAL;
1662
1663	ret_uninit:
1664	dvb_usb_device_exit(intf);
1665
1666	return ret;
1667	}
1668
1669	static void cxusb_disconnect(struct usb_interface *intf)
1670	{
1671	struct dvb_usb_device *d = usb_get_intfdata(intf);
1672	struct cxusb_state *st = d->priv;
1673	struct i2c_client *client;
1674
1675	if (d->props.devices[0].warm_ids[0] == &cxusb_table[MEDION_MD95700])
1676	cxusb_medion_unregister_analog(dvbdev: d);
1677
1678	/* remove I2C client for tuner */
1679	client = st->i2c_client_tuner;
1680	if (client) {
1681	module_put(module: client->dev.driver->owner);
1682	i2c_unregister_device(client);
1683	}
1684
1685	/* remove I2C client for demodulator */
1686	client = st->i2c_client_demod;
1687	if (client) {
1688	module_put(module: client->dev.driver->owner);
1689	i2c_unregister_device(client);
1690	}
1691
1692	dvb_usb_device_exit(intf);
1693	}
1694
1695	static struct usb_device_id cxusb_table[] = {
1696	DVB_USB_DEV(MEDION, MEDION_MD95700),
1697	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LG064F_COLD),
1698	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LG064F_WARM),
1699	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_1_COLD),
1700	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_1_WARM),
1701	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LGZ201_COLD),
1702	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LGZ201_WARM),
1703	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_TH7579_COLD),
1704	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_TH7579_WARM),
1705	DVB_USB_DEV(DVICO, DIGITALNOW_BLUEBIRD_DUAL_1_COLD),
1706	DVB_USB_DEV(DVICO, DIGITALNOW_BLUEBIRD_DUAL_1_WARM),
1707	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_2_COLD),
1708	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_2_WARM),
1709	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_4),
1710	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DVB_T_NANO_2),
1711	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM),
1712	DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR_A868R),
1713	DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_4_REV_2),
1714	DVB_USB_DEV(CONEXANT, CONEXANT_D680_DMB),
1715	DVB_USB_DEV(CONEXANT, MYGICA_D689),
1716	{ }
1717	};
1718
1719	MODULE_DEVICE_TABLE(usb, cxusb_table);
1720
1721	static struct dvb_usb_device_properties cxusb_medion_properties = {
1722	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
1723
1724	.usb_ctrl = CYPRESS_FX2,
1725
1726	.size_of_priv = sizeof(struct cxusb_medion_dev),
1727	.priv_init = cxusb_medion_priv_init,
1728	.priv_destroy = cxusb_medion_priv_destroy,
1729
1730	.num_adapters = 1,
1731	.adapter = {
1732	{
1733	.num_frontends = 1,
1734	.fe = {{
1735	.streaming_ctrl = cxusb_streaming_ctrl,
1736	.frontend_attach = cxusb_cx22702_frontend_attach,
1737	.tuner_attach = cxusb_fmd1216me_tuner_attach,
1738	/* parameter for the MPEG2-data transfer */
1739	.stream = {
1740	.type = USB_BULK,
1741	.count = 5,
1742	.endpoint = 0x02,
1743	.u = {
1744	.bulk = {
1745	.buffersize = 8192,
1746	}
1747	}
1748	},
1749	} },
1750	},
1751	},
1752	.power_ctrl = cxusb_power_ctrl,
1753
1754	.i2c_algo = &cxusb_i2c_algo,
1755
1756	.generic_bulk_ctrl_endpoint = 0x01,
1757
1758	.num_device_descs = 1,
1759	.devices = {
1760	{
1761	"Medion MD95700 (MDUSBTV-HYBRID)",
1762	{ NULL },
1763	{ &cxusb_table[MEDION_MD95700], NULL },
1764	},
1765	}
1766	};
1767
1768	static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1769	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
1770
1771	.usb_ctrl = DEVICE_SPECIFIC,
1772	.firmware = "dvb-usb-bluebird-01.fw",
1773	.download_firmware = bluebird_patch_dvico_firmware_download,
1774	/*
1775	* use usb alt setting 0 for EP4 transfer (dvb-t),
1776	* use usb alt setting 7 for EP2 transfer (atsc)
1777	*/
1778
1779	.size_of_priv = sizeof(struct cxusb_state),
1780
1781	.num_adapters = 1,
1782	.adapter = {
1783	{
1784	.num_frontends = 1,
1785	.fe = {{
1786	.streaming_ctrl = cxusb_streaming_ctrl,
1787	.frontend_attach = cxusb_lgdt3303_frontend_attach,
1788	.tuner_attach = cxusb_lgh064f_tuner_attach,
1789
1790	/* parameter for the MPEG2-data transfer */
1791	.stream = {
1792	.type = USB_BULK,
1793	.count = 5,
1794	.endpoint = 0x02,
1795	.u = {
1796	.bulk = {
1797	.buffersize = 8192,
1798	}
1799	}
1800	},
1801	} },
1802	},
1803	},
1804
1805	.power_ctrl = cxusb_bluebird_power_ctrl,
1806
1807	.i2c_algo = &cxusb_i2c_algo,
1808
1809	.rc.core = {
1810	.rc_interval = 100,
1811	.rc_codes = RC_MAP_DVICO_PORTABLE,
1812	.module_name = KBUILD_MODNAME,
1813	.rc_query = cxusb_rc_query,
1814	.allowed_protos = RC_PROTO_BIT_NEC,
1815	},
1816
1817	.generic_bulk_ctrl_endpoint = 0x01,
1818
1819	.num_device_descs = 1,
1820	.devices = {
1821	{ "DViCO FusionHDTV5 USB Gold",
1822	{ &cxusb_table[DVICO_BLUEBIRD_LG064F_COLD], NULL },
1823	{ &cxusb_table[DVICO_BLUEBIRD_LG064F_WARM], NULL },
1824	},
1825	}
1826	};
1827
1828	static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1829	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
1830
1831	.usb_ctrl = DEVICE_SPECIFIC,
1832	.firmware = "dvb-usb-bluebird-01.fw",
1833	.download_firmware = bluebird_patch_dvico_firmware_download,
1834	/*
1835	* use usb alt setting 0 for EP4 transfer (dvb-t),
1836	* use usb alt setting 7 for EP2 transfer (atsc)
1837	*/
1838
1839	.size_of_priv = sizeof(struct cxusb_state),
1840
1841	.num_adapters = 1,
1842	.adapter = {
1843	{
1844	.num_frontends = 1,
1845	.fe = {{
1846	.streaming_ctrl = cxusb_streaming_ctrl,
1847	.frontend_attach = cxusb_dee1601_frontend_attach,
1848	.tuner_attach = cxusb_dee1601_tuner_attach,
1849	/* parameter for the MPEG2-data transfer */
1850	.stream = {
1851	.type = USB_BULK,
1852	.count = 5,
1853	.endpoint = 0x04,
1854	.u = {
1855	.bulk = {
1856	.buffersize = 8192,
1857	}
1858	}
1859	},
1860	} },
1861	},
1862	},
1863
1864	.power_ctrl = cxusb_bluebird_power_ctrl,
1865
1866	.i2c_algo = &cxusb_i2c_algo,
1867
1868	.rc.core = {
1869	.rc_interval = 100,
1870	.rc_codes = RC_MAP_DVICO_MCE,
1871	.module_name = KBUILD_MODNAME,
1872	.rc_query = cxusb_rc_query,
1873	.allowed_protos = RC_PROTO_BIT_NEC,
1874	},
1875
1876	.generic_bulk_ctrl_endpoint = 0x01,
1877
1878	.num_device_descs = 3,
1879	.devices = {
1880	{ "DViCO FusionHDTV DVB-T Dual USB",
1881	{ &cxusb_table[DVICO_BLUEBIRD_DUAL_1_COLD], NULL },
1882	{ &cxusb_table[DVICO_BLUEBIRD_DUAL_1_WARM], NULL },
1883	},
1884	{ "DigitalNow DVB-T Dual USB",
1885	{ &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_COLD], NULL },
1886	{ &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_WARM], NULL },
1887	},
1888	{ "DViCO FusionHDTV DVB-T Dual Digital 2",
1889	{ &cxusb_table[DVICO_BLUEBIRD_DUAL_2_COLD], NULL },
1890	{ &cxusb_table[DVICO_BLUEBIRD_DUAL_2_WARM], NULL },
1891	},
1892	}
1893	};
1894
1895	static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1896	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
1897
1898	.usb_ctrl = DEVICE_SPECIFIC,
1899	.firmware = "dvb-usb-bluebird-01.fw",
1900	.download_firmware = bluebird_patch_dvico_firmware_download,
1901	/*
1902	* use usb alt setting 0 for EP4 transfer (dvb-t),
1903	* use usb alt setting 7 for EP2 transfer (atsc)
1904	*/
1905
1906	.size_of_priv = sizeof(struct cxusb_state),
1907
1908	.num_adapters = 1,
1909	.adapter = {
1910	{
1911	.num_frontends = 1,
1912	.fe = {{
1913	.streaming_ctrl = cxusb_streaming_ctrl,
1914	.frontend_attach = cxusb_mt352_frontend_attach,
1915	.tuner_attach = cxusb_lgz201_tuner_attach,
1916
1917	/* parameter for the MPEG2-data transfer */
1918	.stream = {
1919	.type = USB_BULK,
1920	.count = 5,
1921	.endpoint = 0x04,
1922	.u = {
1923	.bulk = {
1924	.buffersize = 8192,
1925	}
1926	}
1927	},
1928	} },
1929	},
1930	},
1931	.power_ctrl = cxusb_bluebird_power_ctrl,
1932
1933	.i2c_algo = &cxusb_i2c_algo,
1934
1935	.rc.core = {
1936	.rc_interval = 100,
1937	.rc_codes = RC_MAP_DVICO_PORTABLE,
1938	.module_name = KBUILD_MODNAME,
1939	.rc_query = cxusb_rc_query,
1940	.allowed_protos = RC_PROTO_BIT_NEC,
1941	},
1942
1943	.generic_bulk_ctrl_endpoint = 0x01,
1944	.num_device_descs = 1,
1945	.devices = {
1946	{ "DViCO FusionHDTV DVB-T USB (LGZ201)",
1947	{ &cxusb_table[DVICO_BLUEBIRD_LGZ201_COLD], NULL },
1948	{ &cxusb_table[DVICO_BLUEBIRD_LGZ201_WARM], NULL },
1949	},
1950	}
1951	};
1952
1953	static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1954	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
1955
1956	.usb_ctrl = DEVICE_SPECIFIC,
1957	.firmware = "dvb-usb-bluebird-01.fw",
1958	.download_firmware = bluebird_patch_dvico_firmware_download,
1959
1960	/*
1961	* use usb alt setting 0 for EP4 transfer (dvb-t),
1962	* use usb alt setting 7 for EP2 transfer (atsc)
1963	*/
1964
1965	.size_of_priv = sizeof(struct cxusb_state),
1966
1967	.num_adapters = 1,
1968	.adapter = {
1969	{
1970	.num_frontends = 1,
1971	.fe = {{
1972	.streaming_ctrl = cxusb_streaming_ctrl,
1973	.frontend_attach = cxusb_mt352_frontend_attach,
1974	.tuner_attach = cxusb_dtt7579_tuner_attach,
1975
1976	/* parameter for the MPEG2-data transfer */
1977	.stream = {
1978	.type = USB_BULK,
1979	.count = 5,
1980	.endpoint = 0x04,
1981	.u = {
1982	.bulk = {
1983	.buffersize = 8192,
1984	}
1985	}
1986	},
1987	} },
1988	},
1989	},
1990	.power_ctrl = cxusb_bluebird_power_ctrl,
1991
1992	.i2c_algo = &cxusb_i2c_algo,
1993
1994	.rc.core = {
1995	.rc_interval = 100,
1996	.rc_codes = RC_MAP_DVICO_PORTABLE,
1997	.module_name = KBUILD_MODNAME,
1998	.rc_query = cxusb_rc_query,
1999	.allowed_protos = RC_PROTO_BIT_NEC,
2000	},
2001
2002	.generic_bulk_ctrl_endpoint = 0x01,
2003
2004	.num_device_descs = 1,
2005	.devices = {
2006	{ "DViCO FusionHDTV DVB-T USB (TH7579)",
2007	{ &cxusb_table[DVICO_BLUEBIRD_TH7579_COLD], NULL },
2008	{ &cxusb_table[DVICO_BLUEBIRD_TH7579_WARM], NULL },
2009	},
2010	}
2011	};
2012
2013	static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
2014	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
2015
2016	.usb_ctrl = CYPRESS_FX2,
2017
2018	.size_of_priv = sizeof(struct cxusb_state),
2019
2020	.num_adapters = 1,
2021	.adapter = {
2022	{
2023	.num_frontends = 1,
2024	.fe = {{
2025	.streaming_ctrl = cxusb_streaming_ctrl,
2026	.frontend_attach = cxusb_dualdig4_frontend_attach,
2027	.tuner_attach = cxusb_dvico_xc3028_tuner_attach,
2028	/* parameter for the MPEG2-data transfer */
2029	.stream = {
2030	.type = USB_BULK,
2031	.count = 5,
2032	.endpoint = 0x02,
2033	.u = {
2034	.bulk = {
2035	.buffersize = 8192,
2036	}
2037	}
2038	},
2039	} },
2040	},
2041	},
2042
2043	.power_ctrl = cxusb_power_ctrl,
2044
2045	.i2c_algo = &cxusb_i2c_algo,
2046
2047	.generic_bulk_ctrl_endpoint = 0x01,
2048
2049	.rc.core = {
2050	.rc_interval = 100,
2051	.rc_codes = RC_MAP_DVICO_MCE,
2052	.module_name = KBUILD_MODNAME,
2053	.rc_query = cxusb_bluebird2_rc_query,
2054	.allowed_protos = RC_PROTO_BIT_NEC,
2055	},
2056
2057	.num_device_descs = 1,
2058	.devices = {
2059	{ "DViCO FusionHDTV DVB-T Dual Digital 4",
2060	{ NULL },
2061	{ &cxusb_table[DVICO_BLUEBIRD_DUAL_4], NULL },
2062	},
2063	}
2064	};
2065
2066	static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
2067	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
2068
2069	.usb_ctrl = CYPRESS_FX2,
2070	.identify_state = bluebird_fx2_identify_state,
2071
2072	.size_of_priv = sizeof(struct cxusb_state),
2073
2074	.num_adapters = 1,
2075	.adapter = {
2076	{
2077	.num_frontends = 1,
2078	.fe = {{
2079	.streaming_ctrl = cxusb_streaming_ctrl,
2080	.frontend_attach = cxusb_nano2_frontend_attach,
2081	.tuner_attach = cxusb_dvico_xc3028_tuner_attach,
2082	/* parameter for the MPEG2-data transfer */
2083	.stream = {
2084	.type = USB_BULK,
2085	.count = 5,
2086	.endpoint = 0x02,
2087	.u = {
2088	.bulk = {
2089	.buffersize = 8192,
2090	}
2091	}
2092	},
2093	} },
2094	},
2095	},
2096
2097	.power_ctrl = cxusb_nano2_power_ctrl,
2098
2099	.i2c_algo = &cxusb_i2c_algo,
2100
2101	.generic_bulk_ctrl_endpoint = 0x01,
2102
2103	.rc.core = {
2104	.rc_interval = 100,
2105	.rc_codes = RC_MAP_DVICO_PORTABLE,
2106	.module_name = KBUILD_MODNAME,
2107	.rc_query = cxusb_bluebird2_rc_query,
2108	.allowed_protos = RC_PROTO_BIT_NEC,
2109	},
2110
2111	.num_device_descs = 1,
2112	.devices = {
2113	{ "DViCO FusionHDTV DVB-T NANO2",
2114	{ NULL },
2115	{ &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
2116	},
2117	}
2118	};
2119
2120	static struct dvb_usb_device_properties
2121	cxusb_bluebird_nano2_needsfirmware_properties = {
2122	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
2123
2124	.usb_ctrl = DEVICE_SPECIFIC,
2125	.firmware = "dvb-usb-bluebird-02.fw",
2126	.download_firmware = bluebird_patch_dvico_firmware_download,
2127	.identify_state = bluebird_fx2_identify_state,
2128
2129	.size_of_priv = sizeof(struct cxusb_state),
2130
2131	.num_adapters = 1,
2132	.adapter = {
2133	{
2134	.num_frontends = 1,
2135	.fe = {{
2136	.streaming_ctrl = cxusb_streaming_ctrl,
2137	.frontend_attach = cxusb_nano2_frontend_attach,
2138	.tuner_attach = cxusb_dvico_xc3028_tuner_attach,
2139	/* parameter for the MPEG2-data transfer */
2140	.stream = {
2141	.type = USB_BULK,
2142	.count = 5,
2143	.endpoint = 0x02,
2144	.u = {
2145	.bulk = {
2146	.buffersize = 8192,
2147	}
2148	}
2149	},
2150	} },
2151	},
2152	},
2153
2154	.power_ctrl = cxusb_nano2_power_ctrl,
2155
2156	.i2c_algo = &cxusb_i2c_algo,
2157
2158	.generic_bulk_ctrl_endpoint = 0x01,
2159
2160	.rc.core = {
2161	.rc_interval = 100,
2162	.rc_codes = RC_MAP_DVICO_PORTABLE,
2163	.module_name = KBUILD_MODNAME,
2164	.rc_query = cxusb_rc_query,
2165	.allowed_protos = RC_PROTO_BIT_NEC,
2166	},
2167
2168	.num_device_descs = 1,
2169	.devices = { {
2170	"DViCO FusionHDTV DVB-T NANO2 w/o firmware",
2171	{ &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
2172	{ &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM],
2173	NULL },
2174	},
2175	}
2176	};
2177
2178	static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
2179	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
2180
2181	.usb_ctrl = CYPRESS_FX2,
2182
2183	.size_of_priv = sizeof(struct cxusb_state),
2184
2185	.num_adapters = 1,
2186	.adapter = {
2187	{
2188	.num_frontends = 1,
2189	.fe = {{
2190	.streaming_ctrl = cxusb_aver_streaming_ctrl,
2191	.frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
2192	.tuner_attach = cxusb_mxl5003s_tuner_attach,
2193	/* parameter for the MPEG2-data transfer */
2194	.stream = {
2195	.type = USB_BULK,
2196	.count = 5,
2197	.endpoint = 0x04,
2198	.u = {
2199	.bulk = {
2200	.buffersize = 8192,
2201	}
2202	}
2203	},
2204	} },
2205	},
2206	},
2207	.power_ctrl = cxusb_aver_power_ctrl,
2208
2209	.i2c_algo = &cxusb_i2c_algo,
2210
2211	.generic_bulk_ctrl_endpoint = 0x01,
2212
2213	.num_device_descs = 1,
2214	.devices = {
2215	{ "AVerMedia AVerTVHD Volar (A868R)",
2216	{ NULL },
2217	{ &cxusb_table[AVERMEDIA_VOLAR_A868R], NULL },
2218	},
2219	}
2220	};
2221
2222	static
2223	struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
2224	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
2225
2226	.usb_ctrl = CYPRESS_FX2,
2227
2228	.size_of_priv = sizeof(struct cxusb_state),
2229
2230	.num_adapters = 1,
2231	.adapter = {
2232	{
2233	.size_of_priv = sizeof(struct dib0700_adapter_state),
2234	.num_frontends = 1,
2235	.fe = {{
2236	.streaming_ctrl = cxusb_streaming_ctrl,
2237	.frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
2238	.tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
2239	/* parameter for the MPEG2-data transfer */
2240	.stream = {
2241	.type = USB_BULK,
2242	.count = 7,
2243	.endpoint = 0x02,
2244	.u = {
2245	.bulk = {
2246	.buffersize = 4096,
2247	}
2248	}
2249	},
2250	} },
2251	},
2252	},
2253
2254	.power_ctrl = cxusb_bluebird_power_ctrl,
2255
2256	.i2c_algo = &cxusb_i2c_algo,
2257
2258	.generic_bulk_ctrl_endpoint = 0x01,
2259
2260	.rc.core = {
2261	.rc_interval = 100,
2262	.rc_codes = RC_MAP_DVICO_MCE,
2263	.module_name = KBUILD_MODNAME,
2264	.rc_query = cxusb_rc_query,
2265	.allowed_protos = RC_PROTO_BIT_NEC,
2266	},
2267
2268	.num_device_descs = 1,
2269	.devices = {
2270	{ "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
2271	{ NULL },
2272	{ &cxusb_table[DVICO_BLUEBIRD_DUAL_4_REV_2], NULL },
2273	},
2274	}
2275	};
2276
2277	static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
2278	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
2279
2280	.usb_ctrl = CYPRESS_FX2,
2281
2282	.size_of_priv = sizeof(struct cxusb_state),
2283
2284	.num_adapters = 1,
2285	.adapter = {
2286	{
2287	.num_frontends = 1,
2288	.fe = {{
2289	.streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2290	.frontend_attach = cxusb_d680_dmb_frontend_attach,
2291	.tuner_attach = cxusb_d680_dmb_tuner_attach,
2292
2293	/* parameter for the MPEG2-data transfer */
2294	.stream = {
2295	.type = USB_BULK,
2296	.count = 5,
2297	.endpoint = 0x02,
2298	.u = {
2299	.bulk = {
2300	.buffersize = 8192,
2301	}
2302	}
2303	},
2304	} },
2305	},
2306	},
2307
2308	.power_ctrl = cxusb_d680_dmb_power_ctrl,
2309
2310	.i2c_algo = &cxusb_i2c_algo,
2311
2312	.generic_bulk_ctrl_endpoint = 0x01,
2313
2314	.rc.core = {
2315	.rc_interval = 100,
2316	.rc_codes = RC_MAP_TOTAL_MEDIA_IN_HAND_02,
2317	.module_name = KBUILD_MODNAME,
2318	.rc_query = cxusb_d680_dmb_rc_query,
2319	.allowed_protos = RC_PROTO_BIT_UNKNOWN,
2320	},
2321
2322	.num_device_descs = 1,
2323	.devices = {
2324	{
2325	"Conexant DMB-TH Stick",
2326	{ NULL },
2327	{ &cxusb_table[CONEXANT_D680_DMB], NULL },
2328	},
2329	}
2330	};
2331
2332	static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
2333	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
2334
2335	.usb_ctrl = CYPRESS_FX2,
2336
2337	.size_of_priv = sizeof(struct cxusb_state),
2338
2339	.num_adapters = 1,
2340	.adapter = {
2341	{
2342	.num_frontends = 1,
2343	.fe = {{
2344	.streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2345	.frontend_attach = cxusb_mygica_d689_frontend_attach,
2346	.tuner_attach = cxusb_mygica_d689_tuner_attach,
2347
2348	/* parameter for the MPEG2-data transfer */
2349	.stream = {
2350	.type = USB_BULK,
2351	.count = 5,
2352	.endpoint = 0x02,
2353	.u = {
2354	.bulk = {
2355	.buffersize = 8192,
2356	}
2357	}
2358	},
2359	} },
2360	},
2361	},
2362
2363	.power_ctrl = cxusb_d680_dmb_power_ctrl,
2364
2365	.i2c_algo = &cxusb_i2c_algo,
2366
2367	.generic_bulk_ctrl_endpoint = 0x01,
2368
2369	.rc.core = {
2370	.rc_interval = 100,
2371	.rc_codes = RC_MAP_D680_DMB,
2372	.module_name = KBUILD_MODNAME,
2373	.rc_query = cxusb_d680_dmb_rc_query,
2374	.allowed_protos = RC_PROTO_BIT_UNKNOWN,
2375	},
2376
2377	.num_device_descs = 1,
2378	.devices = {
2379	{
2380	"Mygica D689 DMB-TH",
2381	{ NULL },
2382	{ &cxusb_table[MYGICA_D689], NULL },
2383	},
2384	}
2385	};
2386
2387	static struct usb_driver cxusb_driver = {
2388	.name = "dvb_usb_cxusb",
2389	.probe = cxusb_probe,
2390	.disconnect = cxusb_disconnect,
2391	.id_table = cxusb_table,
2392	};
2393
2394	module_usb_driver(cxusb_driver);
2395
2396	MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2397	MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
2398	MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
2399	MODULE_AUTHOR("Maciej S. Szmigiero <mail@maciej.szmigiero.name>");
2400	MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2401	MODULE_LICENSE("GPL");
2402