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