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