1 /* DVB USB compliant linux driver for Conexant USB reference design.
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.
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
14 * TODO: Use the cx25840-driver for the analogue part
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)
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.
24 * see Documentation/dvb/README.dvb-usb for more information
26 #include <media/tuner.h>
27 #include <linux/vmalloc.h>
34 #include "mt352_priv.h"
36 #include "tuner-xc2028.h"
37 #include "tuner-simple.h"
44 static int dvb_usb_cxusb_debug;
45 module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
46 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
48 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
50 #define deb_info(args...) dprintk(dvb_usb_cxusb_debug, 0x03, args)
51 #define deb_i2c(args...) dprintk(dvb_usb_cxusb_debug, 0x02, args)
53 static int cxusb_ctrl_msg(struct dvb_usb_device *d,
54 u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
56 int wo = (rbuf == NULL || rlen == 0); /* write-only */
58 memset(sndbuf, 0, 1+wlen);
61 memcpy(&sndbuf[1], wbuf, wlen);
63 return dvb_usb_generic_write(d, sndbuf, 1+wlen);
65 return dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0);
69 static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
71 struct cxusb_state *st = d->priv;
74 if (st->gpio_write_state[GPIO_TUNER] == onoff)
79 cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
82 deb_info("gpio_write failed.\n");
84 st->gpio_write_state[GPIO_TUNER] = onoff;
87 static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask,
93 o[0] = 0xff & ~changemask; /* mask of bits to keep */
94 o[1] = newval & changemask; /* new values for bits */
96 rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, o, 2, &gpio_state, 1);
97 if (rc < 0 || (gpio_state & changemask) != (newval & changemask))
98 deb_info("bluebird_gpio_write failed.\n");
100 return rc < 0 ? rc : gpio_state;
103 static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low)
105 cxusb_bluebird_gpio_rw(d, pin, low ? 0 : pin);
107 cxusb_bluebird_gpio_rw(d, pin, low ? pin : 0);
110 static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
112 cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40);
115 static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
118 u8 o[2] = {addr, onoff};
122 rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
129 deb_info("gpio_write failed.\n");
135 static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
138 struct dvb_usb_device *d = i2c_get_adapdata(adap);
141 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
144 for (i = 0; i < num; i++) {
146 if (d->udev->descriptor.idVendor == USB_VID_MEDION)
147 switch (msg[i].addr) {
149 cxusb_gpio_tuner(d, 0);
152 cxusb_gpio_tuner(d, 1);
156 if (msg[i].flags & I2C_M_RD) {
158 u8 obuf[3], ibuf[1+msg[i].len];
160 obuf[1] = msg[i].len;
161 obuf[2] = msg[i].addr;
162 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
164 ibuf, 1+msg[i].len) < 0) {
165 warn("i2c read failed");
168 memcpy(msg[i].buf, &ibuf[1], msg[i].len);
169 } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) &&
170 msg[i].addr == msg[i+1].addr) {
171 /* write to then read from same address */
172 u8 obuf[3+msg[i].len], ibuf[1+msg[i+1].len];
173 obuf[0] = msg[i].len;
174 obuf[1] = msg[i+1].len;
175 obuf[2] = msg[i].addr;
176 memcpy(&obuf[3], msg[i].buf, msg[i].len);
178 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
180 ibuf, 1+msg[i+1].len) < 0)
184 deb_i2c("i2c read may have failed\n");
186 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
191 u8 obuf[2+msg[i].len], ibuf;
192 obuf[0] = msg[i].addr;
193 obuf[1] = msg[i].len;
194 memcpy(&obuf[2], msg[i].buf, msg[i].len);
196 if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
197 2+msg[i].len, &ibuf,1) < 0)
200 deb_i2c("i2c write may have failed\n");
204 mutex_unlock(&d->i2c_mutex);
205 return i == num ? num : -EREMOTEIO;
208 static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
213 static struct i2c_algorithm cxusb_i2c_algo = {
214 .master_xfer = cxusb_i2c_xfer,
215 .functionality = cxusb_i2c_func,
218 static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
222 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
224 return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0);
227 static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff)
231 return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, 0, NULL, 0);
232 if (d->state == DVB_USB_STATE_INIT &&
233 usb_set_interface(d->udev, 0, 0) < 0)
234 err("set interface failed");
235 do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) &&
236 !(ret = cxusb_ctrl_msg(d, 0x15, NULL, 0, NULL, 0)) &&
237 !(ret = cxusb_ctrl_msg(d, 0x17, NULL, 0, NULL, 0)) && 0);
239 /* FIXME: We don't know why, but we need to configure the
240 * lgdt3303 with the register settings below on resume */
243 0x0e, 0x2, 0x00, 0x7f,
244 0x0e, 0x2, 0x02, 0xfe,
245 0x0e, 0x2, 0x02, 0x01,
246 0x0e, 0x2, 0x00, 0x03,
247 0x0e, 0x2, 0x0d, 0x40,
248 0x0e, 0x2, 0x0e, 0x87,
249 0x0e, 0x2, 0x0f, 0x8e,
250 0x0e, 0x2, 0x10, 0x01,
251 0x0e, 0x2, 0x14, 0xd7,
252 0x0e, 0x2, 0x47, 0x88,
255 for (i = 0; i < sizeof(bufs)/sizeof(u8); i += 4/sizeof(u8)) {
256 ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE,
267 static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
271 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
276 static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff)
280 rc = cxusb_power_ctrl(d, onoff);
282 cxusb_nano2_led(d, 0);
287 static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device *d, int onoff)
291 ret = cxusb_power_ctrl(d, onoff);
296 cxusb_ctrl_msg(d, CMD_DIGITAL, NULL, 0, &b, 1);
301 static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
303 u8 buf[2] = { 0x03, 0x00 };
305 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
307 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
312 static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
315 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_ON, NULL, 0, NULL, 0);
317 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_OFF,
322 static void cxusb_d680_dmb_drain_message(struct dvb_usb_device *d)
324 int ep = d->props.generic_bulk_ctrl_endpoint;
325 const int timeout = 100;
326 const int junk_len = 32;
330 /* Discard remaining data in video pipe */
331 junk = kmalloc(junk_len, GFP_KERNEL);
335 if (usb_bulk_msg(d->udev,
336 usb_rcvbulkpipe(d->udev, ep),
337 junk, junk_len, &rd_count, timeout) < 0)
345 static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d)
347 struct usb_data_stream_properties *p = &d->props.adapter[0].stream;
348 const int timeout = 100;
349 const int junk_len = p->u.bulk.buffersize;
353 /* Discard remaining data in video pipe */
354 junk = kmalloc(junk_len, GFP_KERNEL);
358 if (usb_bulk_msg(d->udev,
359 usb_rcvbulkpipe(d->udev, p->endpoint),
360 junk, junk_len, &rd_count, timeout) < 0)
368 static int cxusb_d680_dmb_streaming_ctrl(
369 struct dvb_usb_adapter *adap, int onoff)
372 u8 buf[2] = { 0x03, 0x00 };
373 cxusb_d680_dmb_drain_video(adap->dev);
374 return cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON,
375 buf, sizeof(buf), NULL, 0);
377 int ret = cxusb_ctrl_msg(adap->dev,
378 CMD_STREAMING_OFF, NULL, 0, NULL, 0);
383 static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
385 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
389 cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
392 *state = REMOTE_NO_KEY_PRESSED;
394 for (i = 0; i < d->props.rc_key_map_size; i++) {
395 if (keymap[i].custom == ircode[2] &&
396 keymap[i].data == ircode[3]) {
397 *event = keymap[i].event;
398 *state = REMOTE_KEY_PRESSED;
407 static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
410 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
413 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
414 .buf = ircode, .len = 4 };
417 *state = REMOTE_NO_KEY_PRESSED;
419 if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
422 for (i = 0; i < d->props.rc_key_map_size; i++) {
423 if (keymap[i].custom == ircode[1] &&
424 keymap[i].data == ircode[2]) {
425 *event = keymap[i].event;
426 *state = REMOTE_KEY_PRESSED;
435 static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
438 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
443 *state = REMOTE_NO_KEY_PRESSED;
445 if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0)
448 for (i = 0; i < d->props.rc_key_map_size; i++) {
449 if (keymap[i].custom == ircode[0] &&
450 keymap[i].data == ircode[1]) {
451 *event = keymap[i].event;
452 *state = REMOTE_KEY_PRESSED;
461 static struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
462 { 0xfe, 0x02, KEY_TV },
463 { 0xfe, 0x0e, KEY_MP3 },
464 { 0xfe, 0x1a, KEY_DVD },
465 { 0xfe, 0x1e, KEY_FAVORITES },
466 { 0xfe, 0x16, KEY_SETUP },
467 { 0xfe, 0x46, KEY_POWER2 },
468 { 0xfe, 0x0a, KEY_EPG },
469 { 0xfe, 0x49, KEY_BACK },
470 { 0xfe, 0x4d, KEY_MENU },
471 { 0xfe, 0x51, KEY_UP },
472 { 0xfe, 0x5b, KEY_LEFT },
473 { 0xfe, 0x5f, KEY_RIGHT },
474 { 0xfe, 0x53, KEY_DOWN },
475 { 0xfe, 0x5e, KEY_OK },
476 { 0xfe, 0x59, KEY_INFO },
477 { 0xfe, 0x55, KEY_TAB },
478 { 0xfe, 0x0f, KEY_PREVIOUSSONG },/* Replay */
479 { 0xfe, 0x12, KEY_NEXTSONG }, /* Skip */
480 { 0xfe, 0x42, KEY_ENTER }, /* Windows/Start */
481 { 0xfe, 0x15, KEY_VOLUMEUP },
482 { 0xfe, 0x05, KEY_VOLUMEDOWN },
483 { 0xfe, 0x11, KEY_CHANNELUP },
484 { 0xfe, 0x09, KEY_CHANNELDOWN },
485 { 0xfe, 0x52, KEY_CAMERA },
486 { 0xfe, 0x5a, KEY_TUNER }, /* Live */
487 { 0xfe, 0x19, KEY_OPEN },
488 { 0xfe, 0x0b, KEY_1 },
489 { 0xfe, 0x17, KEY_2 },
490 { 0xfe, 0x1b, KEY_3 },
491 { 0xfe, 0x07, KEY_4 },
492 { 0xfe, 0x50, KEY_5 },
493 { 0xfe, 0x54, KEY_6 },
494 { 0xfe, 0x48, KEY_7 },
495 { 0xfe, 0x4c, KEY_8 },
496 { 0xfe, 0x58, KEY_9 },
497 { 0xfe, 0x13, KEY_ANGLE }, /* Aspect */
498 { 0xfe, 0x03, KEY_0 },
499 { 0xfe, 0x1f, KEY_ZOOM },
500 { 0xfe, 0x43, KEY_REWIND },
501 { 0xfe, 0x47, KEY_PLAYPAUSE },
502 { 0xfe, 0x4f, KEY_FASTFORWARD },
503 { 0xfe, 0x57, KEY_MUTE },
504 { 0xfe, 0x0d, KEY_STOP },
505 { 0xfe, 0x01, KEY_RECORD },
506 { 0xfe, 0x4e, KEY_POWER },
509 static struct dvb_usb_rc_key dvico_portable_rc_keys[] = {
510 { 0xfc, 0x02, KEY_SETUP }, /* Profile */
511 { 0xfc, 0x43, KEY_POWER2 },
512 { 0xfc, 0x06, KEY_EPG },
513 { 0xfc, 0x5a, KEY_BACK },
514 { 0xfc, 0x05, KEY_MENU },
515 { 0xfc, 0x47, KEY_INFO },
516 { 0xfc, 0x01, KEY_TAB },
517 { 0xfc, 0x42, KEY_PREVIOUSSONG },/* Replay */
518 { 0xfc, 0x49, KEY_VOLUMEUP },
519 { 0xfc, 0x09, KEY_VOLUMEDOWN },
520 { 0xfc, 0x54, KEY_CHANNELUP },
521 { 0xfc, 0x0b, KEY_CHANNELDOWN },
522 { 0xfc, 0x16, KEY_CAMERA },
523 { 0xfc, 0x40, KEY_TUNER }, /* ATV/DTV */
524 { 0xfc, 0x45, KEY_OPEN },
525 { 0xfc, 0x19, KEY_1 },
526 { 0xfc, 0x18, KEY_2 },
527 { 0xfc, 0x1b, KEY_3 },
528 { 0xfc, 0x1a, KEY_4 },
529 { 0xfc, 0x58, KEY_5 },
530 { 0xfc, 0x59, KEY_6 },
531 { 0xfc, 0x15, KEY_7 },
532 { 0xfc, 0x14, KEY_8 },
533 { 0xfc, 0x17, KEY_9 },
534 { 0xfc, 0x44, KEY_ANGLE }, /* Aspect */
535 { 0xfc, 0x55, KEY_0 },
536 { 0xfc, 0x07, KEY_ZOOM },
537 { 0xfc, 0x0a, KEY_REWIND },
538 { 0xfc, 0x08, KEY_PLAYPAUSE },
539 { 0xfc, 0x4b, KEY_FASTFORWARD },
540 { 0xfc, 0x5b, KEY_MUTE },
541 { 0xfc, 0x04, KEY_STOP },
542 { 0xfc, 0x56, KEY_RECORD },
543 { 0xfc, 0x57, KEY_POWER },
544 { 0xfc, 0x41, KEY_UNKNOWN }, /* INPUT */
545 { 0xfc, 0x00, KEY_UNKNOWN }, /* HD */
548 static struct dvb_usb_rc_key d680_dmb_rc_keys[] = {
549 { 0x00, 0x38, KEY_UNKNOWN }, /* TV/AV */
550 { 0x08, 0x0c, KEY_ZOOM },
551 { 0x08, 0x00, KEY_0 },
552 { 0x00, 0x01, KEY_1 },
553 { 0x08, 0x02, KEY_2 },
554 { 0x00, 0x03, KEY_3 },
555 { 0x08, 0x04, KEY_4 },
556 { 0x00, 0x05, KEY_5 },
557 { 0x08, 0x06, KEY_6 },
558 { 0x00, 0x07, KEY_7 },
559 { 0x08, 0x08, KEY_8 },
560 { 0x00, 0x09, KEY_9 },
561 { 0x00, 0x0a, KEY_MUTE },
562 { 0x08, 0x29, KEY_BACK },
563 { 0x00, 0x12, KEY_CHANNELUP },
564 { 0x08, 0x13, KEY_CHANNELDOWN },
565 { 0x00, 0x2b, KEY_VOLUMEUP },
566 { 0x08, 0x2c, KEY_VOLUMEDOWN },
567 { 0x00, 0x20, KEY_UP },
568 { 0x08, 0x21, KEY_DOWN },
569 { 0x00, 0x11, KEY_LEFT },
570 { 0x08, 0x10, KEY_RIGHT },
571 { 0x00, 0x0d, KEY_OK },
572 { 0x08, 0x1f, KEY_RECORD },
573 { 0x00, 0x17, KEY_PLAYPAUSE },
574 { 0x08, 0x16, KEY_PLAYPAUSE },
575 { 0x00, 0x0b, KEY_STOP },
576 { 0x08, 0x27, KEY_FASTFORWARD },
577 { 0x00, 0x26, KEY_REWIND },
578 { 0x08, 0x1e, KEY_UNKNOWN }, /* Time Shift */
579 { 0x00, 0x0e, KEY_UNKNOWN }, /* Snapshot */
580 { 0x08, 0x2d, KEY_UNKNOWN }, /* Mouse Cursor */
581 { 0x00, 0x0f, KEY_UNKNOWN }, /* Minimize/Maximize */
582 { 0x08, 0x14, KEY_UNKNOWN }, /* Shuffle */
583 { 0x00, 0x25, KEY_POWER },
586 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
588 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 };
589 static u8 reset [] = { RESET, 0x80 };
590 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
591 static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 };
592 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
593 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
595 mt352_write(fe, clock_config, sizeof(clock_config));
597 mt352_write(fe, reset, sizeof(reset));
598 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
600 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
601 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
602 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
607 static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
608 { /* used in both lgz201 and th7579 */
609 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 };
610 static u8 reset [] = { RESET, 0x80 };
611 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
612 static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 };
613 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
614 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
616 mt352_write(fe, clock_config, sizeof(clock_config));
618 mt352_write(fe, reset, sizeof(reset));
619 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
621 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
622 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
623 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
627 static struct cx22702_config cxusb_cx22702_config = {
628 .demod_address = 0x63,
629 .output_mode = CX22702_PARALLEL_OUTPUT,
632 static struct lgdt330x_config cxusb_lgdt3303_config = {
633 .demod_address = 0x0e,
634 .demod_chip = LGDT3303,
637 static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
638 .demod_address = 0x0e,
639 .demod_chip = LGDT3303,
640 .clock_polarity_flip = 2,
643 static struct mt352_config cxusb_dee1601_config = {
644 .demod_address = 0x0f,
645 .demod_init = cxusb_dee1601_demod_init,
648 static struct zl10353_config cxusb_zl10353_dee1601_config = {
649 .demod_address = 0x0f,
653 static struct mt352_config cxusb_mt352_config = {
654 /* used in both lgz201 and th7579 */
655 .demod_address = 0x0f,
656 .demod_init = cxusb_mt352_demod_init,
659 static struct zl10353_config cxusb_zl10353_xc3028_config = {
660 .demod_address = 0x0f,
666 static struct mt352_config cxusb_mt352_xc3028_config = {
667 .demod_address = 0x0f,
670 .demod_init = cxusb_mt352_demod_init,
673 /* FIXME: needs tweaking */
674 static struct mxl5005s_config aver_a868r_tuner = {
676 .if_freq = 6000000UL,
677 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
678 .agc_mode = MXL_SINGLE_AGC,
679 .tracking_filter = MXL_TF_C,
680 .rssi_enable = MXL_RSSI_ENABLE,
681 .cap_select = MXL_CAP_SEL_ENABLE,
682 .div_out = MXL_DIV_OUT_4,
683 .clock_out = MXL_CLOCK_OUT_DISABLE,
684 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
685 .top = MXL5005S_TOP_25P2,
686 .mod_mode = MXL_DIGITAL_MODE,
687 .if_mode = MXL_ZERO_IF,
688 .AgcMasterByte = 0x00,
691 /* FIXME: needs tweaking */
692 static struct mxl5005s_config d680_dmb_tuner = {
694 .if_freq = 36125000UL,
695 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
696 .agc_mode = MXL_SINGLE_AGC,
697 .tracking_filter = MXL_TF_C,
698 .rssi_enable = MXL_RSSI_ENABLE,
699 .cap_select = MXL_CAP_SEL_ENABLE,
700 .div_out = MXL_DIV_OUT_4,
701 .clock_out = MXL_CLOCK_OUT_DISABLE,
702 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
703 .top = MXL5005S_TOP_25P2,
704 .mod_mode = MXL_DIGITAL_MODE,
705 .if_mode = MXL_ZERO_IF,
706 .AgcMasterByte = 0x00,
709 /* Callbacks for DVB USB */
710 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
712 dvb_attach(simple_tuner_attach, adap->fe,
713 &adap->dev->i2c_adap, 0x61,
714 TUNER_PHILIPS_FMD1216ME_MK3);
718 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
720 dvb_attach(dvb_pll_attach, adap->fe, 0x61,
721 NULL, DVB_PLL_THOMSON_DTT7579);
725 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
727 dvb_attach(dvb_pll_attach, adap->fe, 0x61, NULL, DVB_PLL_LG_Z201);
731 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
733 dvb_attach(dvb_pll_attach, adap->fe, 0x60,
734 NULL, DVB_PLL_THOMSON_DTT7579);
738 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
740 dvb_attach(simple_tuner_attach, adap->fe,
741 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
745 static int dvico_bluebird_xc2028_callback(void *ptr, int command, int arg)
747 struct dvb_usb_adapter *adap = ptr;
748 struct dvb_usb_device *d = adap->dev;
751 case XC2028_TUNER_RESET:
752 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
753 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
755 case XC2028_RESET_CLK:
756 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
759 deb_info("%s: unknown command %d, arg %d\n", __func__,
767 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
769 struct dvb_frontend *fe;
770 struct xc2028_config cfg = {
771 .i2c_adap = &adap->dev->i2c_adap,
773 .callback = dvico_bluebird_xc2028_callback,
775 static struct xc2028_ctrl ctl = {
776 .fname = XC2028_DEFAULT_FIRMWARE,
778 .demod = XC3028_FE_ZARLINK456,
781 fe = dvb_attach(xc2028_attach, adap->fe, &cfg);
782 if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
785 fe->ops.tuner_ops.set_config(fe, &ctl);
790 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
792 dvb_attach(mxl5005s_attach, adap->fe,
793 &adap->dev->i2c_adap, &aver_a868r_tuner);
797 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
799 struct dvb_frontend *fe;
800 fe = dvb_attach(mxl5005s_attach, adap->fe,
801 &adap->dev->i2c_adap, &d680_dmb_tuner);
802 return (fe == NULL) ? -EIO : 0;
805 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
808 if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
809 err("set interface failed");
811 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
813 if ((adap->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
814 &adap->dev->i2c_adap)) != NULL)
820 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
822 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
823 err("set interface failed");
825 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
827 if ((adap->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config,
828 &adap->dev->i2c_adap)) != NULL)
834 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
836 adap->fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
837 &adap->dev->i2c_adap);
838 if (adap->fe != NULL)
844 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
846 /* used in both lgz201 and th7579 */
847 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
848 err("set interface failed");
850 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
852 if ((adap->fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
853 &adap->dev->i2c_adap)) != NULL)
859 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
861 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
862 err("set interface failed");
864 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
866 if (((adap->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
867 &adap->dev->i2c_adap)) != NULL) ||
868 ((adap->fe = dvb_attach(zl10353_attach,
869 &cxusb_zl10353_dee1601_config,
870 &adap->dev->i2c_adap)) != NULL))
876 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
880 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
881 .buf = ircode, .len = 4 };
883 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
884 err("set interface failed");
886 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
888 /* reset the tuner and demodulator */
889 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
890 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
891 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
893 if ((adap->fe = dvb_attach(zl10353_attach,
894 &cxusb_zl10353_xc3028_config,
895 &adap->dev->i2c_adap)) == NULL)
898 /* try to determine if there is no IR decoder on the I2C bus */
899 for (i = 0; adap->dev->props.rc_key_map != NULL && i < 5; i++) {
901 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
903 if (ircode[0] == 0 && ircode[1] == 0)
905 if (ircode[2] + ircode[3] != 0xff) {
907 adap->dev->props.rc_key_map = NULL;
908 info("No IR receiver detected on this device.");
916 static struct dibx000_agc_config dib7070_agc_config = {
917 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
920 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
921 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
922 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
924 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
925 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
951 .perform_agc_softsplit = 0,
954 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
967 /* refsel, sel, freq_15k */
968 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
969 .ifreq = (0 << 25) | 0,
974 static struct dib7000p_config cxusb_dualdig4_rev2_config = {
975 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
976 .output_mpeg2_in_188_bytes = 1,
978 .agc_config_count = 1,
979 .agc = &dib7070_agc_config,
980 .bw = &dib7070_bw_config_12_mhz,
981 .tuner_is_baseband = 1,
987 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
989 .hostbus_diversity = 1,
992 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
994 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
995 err("set interface failed");
997 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
999 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1001 dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1002 &cxusb_dualdig4_rev2_config);
1004 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1005 &cxusb_dualdig4_rev2_config);
1006 if (adap->fe == NULL)
1012 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1014 return dib7000p_set_gpio(fe, 8, 0, !onoff);
1017 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1022 static struct dib0070_config dib7070p_dib0070_config = {
1023 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1024 .reset = dib7070_tuner_reset,
1025 .sleep = dib7070_tuner_sleep,
1029 struct dib0700_adapter_state {
1030 int (*set_param_save) (struct dvb_frontend *,
1031 struct dvb_frontend_parameters *);
1034 static int dib7070_set_param_override(struct dvb_frontend *fe,
1035 struct dvb_frontend_parameters *fep)
1037 struct dvb_usb_adapter *adap = fe->dvb->priv;
1038 struct dib0700_adapter_state *state = adap->priv;
1041 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1043 case BAND_VHF: offset = 950; break;
1045 case BAND_UHF: offset = 550; break;
1048 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1050 return state->set_param_save(fe, fep);
1053 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1055 struct dib0700_adapter_state *st = adap->priv;
1056 struct i2c_adapter *tun_i2c =
1057 dib7000p_get_i2c_master(adap->fe,
1058 DIBX000_I2C_INTERFACE_TUNER, 1);
1060 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1061 &dib7070p_dib0070_config) == NULL)
1064 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1065 adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1069 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1071 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1072 err("set interface failed");
1074 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1076 /* reset the tuner and demodulator */
1077 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1078 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1079 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1081 if ((adap->fe = dvb_attach(zl10353_attach,
1082 &cxusb_zl10353_xc3028_config,
1083 &adap->dev->i2c_adap)) != NULL)
1086 if ((adap->fe = dvb_attach(mt352_attach,
1087 &cxusb_mt352_xc3028_config,
1088 &adap->dev->i2c_adap)) != NULL)
1094 static struct lgs8gl5_config lgs8gl5_cfg = {
1095 .demod_address = 0x19,
1098 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1100 struct dvb_usb_device *d = adap->dev;
1103 /* Select required USB configuration */
1104 if (usb_set_interface(d->udev, 0, 0) < 0)
1105 err("set interface failed");
1107 /* Unblock all USB pipes */
1108 usb_clear_halt(d->udev,
1109 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1110 usb_clear_halt(d->udev,
1111 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1112 usb_clear_halt(d->udev,
1113 usb_rcvbulkpipe(d->udev, d->props.adapter[0].stream.endpoint));
1115 /* Drain USB pipes to avoid hang after reboot */
1116 for (n = 0; n < 5; n++) {
1117 cxusb_d680_dmb_drain_message(d);
1118 cxusb_d680_dmb_drain_video(d);
1122 /* Reset the tuner */
1123 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1124 err("clear tuner gpio failed");
1128 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1129 err("set tuner gpio failed");
1134 /* Attach frontend */
1135 adap->fe = dvb_attach(lgs8gl5_attach, &lgs8gl5_cfg, &d->i2c_adap);
1136 if (adap->fe == NULL)
1143 * DViCO has shipped two devices with the same USB ID, but only one of them
1144 * needs a firmware download. Check the device class details to see if they
1145 * have non-default values to decide whether the device is actually cold or
1146 * not, and forget a match if it turns out we selected the wrong device.
1148 static int bluebird_fx2_identify_state(struct usb_device *udev,
1149 struct dvb_usb_device_properties *props,
1150 struct dvb_usb_device_description **desc,
1153 int wascold = *cold;
1155 *cold = udev->descriptor.bDeviceClass == 0xff &&
1156 udev->descriptor.bDeviceSubClass == 0xff &&
1157 udev->descriptor.bDeviceProtocol == 0xff;
1159 if (*cold && !wascold)
1166 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1167 * firmware file before download.
1170 static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1171 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1172 const struct firmware *fw)
1176 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1177 int idoff = dvico_firmware_id_offsets[pos];
1179 if (fw->size < idoff + 4)
1182 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1183 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1184 struct firmware new_fw;
1185 u8 *new_fw_data = vmalloc(fw->size);
1191 memcpy(new_fw_data, fw->data, fw->size);
1192 new_fw.size = fw->size;
1193 new_fw.data = new_fw_data;
1195 new_fw_data[idoff + 2] =
1196 le16_to_cpu(udev->descriptor.idProduct) + 1;
1197 new_fw_data[idoff + 3] =
1198 le16_to_cpu(udev->descriptor.idProduct) >> 8;
1200 ret = usb_cypress_load_firmware(udev, &new_fw,
1210 /* DVB USB Driver stuff */
1211 static struct dvb_usb_device_properties cxusb_medion_properties;
1212 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1213 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1214 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1215 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1216 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1217 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1218 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1219 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1220 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1221 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1223 static int cxusb_probe(struct usb_interface *intf,
1224 const struct usb_device_id *id)
1226 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1227 THIS_MODULE, NULL, adapter_nr) ||
1228 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1229 THIS_MODULE, NULL, adapter_nr) ||
1230 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1231 THIS_MODULE, NULL, adapter_nr) ||
1232 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1233 THIS_MODULE, NULL, adapter_nr) ||
1234 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1235 THIS_MODULE, NULL, adapter_nr) ||
1236 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1237 THIS_MODULE, NULL, adapter_nr) ||
1238 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1239 THIS_MODULE, NULL, adapter_nr) ||
1240 0 == dvb_usb_device_init(intf,
1241 &cxusb_bluebird_nano2_needsfirmware_properties,
1242 THIS_MODULE, NULL, adapter_nr) ||
1243 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1244 THIS_MODULE, NULL, adapter_nr) ||
1245 0 == dvb_usb_device_init(intf,
1246 &cxusb_bluebird_dualdig4_rev2_properties,
1247 THIS_MODULE, NULL, adapter_nr) ||
1248 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1249 THIS_MODULE, NULL, adapter_nr) ||
1256 static struct usb_device_id cxusb_table [] = {
1257 { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
1258 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
1259 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
1260 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
1261 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
1262 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
1263 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
1264 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
1265 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
1266 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
1267 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
1268 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
1269 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
1270 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
1271 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
1272 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
1273 { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
1274 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
1275 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
1276 {} /* Terminating entry */
1278 MODULE_DEVICE_TABLE (usb, cxusb_table);
1280 static struct dvb_usb_device_properties cxusb_medion_properties = {
1281 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1283 .usb_ctrl = CYPRESS_FX2,
1285 .size_of_priv = sizeof(struct cxusb_state),
1290 .streaming_ctrl = cxusb_streaming_ctrl,
1291 .frontend_attach = cxusb_cx22702_frontend_attach,
1292 .tuner_attach = cxusb_fmd1216me_tuner_attach,
1293 /* parameter for the MPEG2-data transfer */
1307 .power_ctrl = cxusb_power_ctrl,
1309 .i2c_algo = &cxusb_i2c_algo,
1311 .generic_bulk_ctrl_endpoint = 0x01,
1313 .num_device_descs = 1,
1315 { "Medion MD95700 (MDUSBTV-HYBRID)",
1317 { &cxusb_table[0], NULL },
1322 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1323 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1325 .usb_ctrl = DEVICE_SPECIFIC,
1326 .firmware = "dvb-usb-bluebird-01.fw",
1327 .download_firmware = bluebird_patch_dvico_firmware_download,
1328 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1329 use usb alt setting 7 for EP2 transfer (atsc) */
1331 .size_of_priv = sizeof(struct cxusb_state),
1336 .streaming_ctrl = cxusb_streaming_ctrl,
1337 .frontend_attach = cxusb_lgdt3303_frontend_attach,
1338 .tuner_attach = cxusb_lgh064f_tuner_attach,
1340 /* parameter for the MPEG2-data transfer */
1354 .power_ctrl = cxusb_bluebird_power_ctrl,
1356 .i2c_algo = &cxusb_i2c_algo,
1359 .rc_key_map = dvico_portable_rc_keys,
1360 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1361 .rc_query = cxusb_rc_query,
1363 .generic_bulk_ctrl_endpoint = 0x01,
1365 .num_device_descs = 1,
1367 { "DViCO FusionHDTV5 USB Gold",
1368 { &cxusb_table[1], NULL },
1369 { &cxusb_table[2], NULL },
1374 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1375 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1377 .usb_ctrl = DEVICE_SPECIFIC,
1378 .firmware = "dvb-usb-bluebird-01.fw",
1379 .download_firmware = bluebird_patch_dvico_firmware_download,
1380 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1381 use usb alt setting 7 for EP2 transfer (atsc) */
1383 .size_of_priv = sizeof(struct cxusb_state),
1388 .streaming_ctrl = cxusb_streaming_ctrl,
1389 .frontend_attach = cxusb_dee1601_frontend_attach,
1390 .tuner_attach = cxusb_dee1601_tuner_attach,
1391 /* parameter for the MPEG2-data transfer */
1405 .power_ctrl = cxusb_bluebird_power_ctrl,
1407 .i2c_algo = &cxusb_i2c_algo,
1410 .rc_key_map = dvico_mce_rc_keys,
1411 .rc_key_map_size = ARRAY_SIZE(dvico_mce_rc_keys),
1412 .rc_query = cxusb_rc_query,
1414 .generic_bulk_ctrl_endpoint = 0x01,
1416 .num_device_descs = 3,
1418 { "DViCO FusionHDTV DVB-T Dual USB",
1419 { &cxusb_table[3], NULL },
1420 { &cxusb_table[4], NULL },
1422 { "DigitalNow DVB-T Dual USB",
1423 { &cxusb_table[9], NULL },
1424 { &cxusb_table[10], NULL },
1426 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1427 { &cxusb_table[11], NULL },
1428 { &cxusb_table[12], NULL },
1433 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1434 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1436 .usb_ctrl = DEVICE_SPECIFIC,
1437 .firmware = "dvb-usb-bluebird-01.fw",
1438 .download_firmware = bluebird_patch_dvico_firmware_download,
1439 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1440 use usb alt setting 7 for EP2 transfer (atsc) */
1442 .size_of_priv = sizeof(struct cxusb_state),
1447 .streaming_ctrl = cxusb_streaming_ctrl,
1448 .frontend_attach = cxusb_mt352_frontend_attach,
1449 .tuner_attach = cxusb_lgz201_tuner_attach,
1451 /* parameter for the MPEG2-data transfer */
1464 .power_ctrl = cxusb_bluebird_power_ctrl,
1466 .i2c_algo = &cxusb_i2c_algo,
1469 .rc_key_map = dvico_portable_rc_keys,
1470 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1471 .rc_query = cxusb_rc_query,
1473 .generic_bulk_ctrl_endpoint = 0x01,
1474 .num_device_descs = 1,
1476 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1477 { &cxusb_table[5], NULL },
1478 { &cxusb_table[6], NULL },
1483 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1484 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1486 .usb_ctrl = DEVICE_SPECIFIC,
1487 .firmware = "dvb-usb-bluebird-01.fw",
1488 .download_firmware = bluebird_patch_dvico_firmware_download,
1489 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1490 use usb alt setting 7 for EP2 transfer (atsc) */
1492 .size_of_priv = sizeof(struct cxusb_state),
1497 .streaming_ctrl = cxusb_streaming_ctrl,
1498 .frontend_attach = cxusb_mt352_frontend_attach,
1499 .tuner_attach = cxusb_dtt7579_tuner_attach,
1501 /* parameter for the MPEG2-data transfer */
1514 .power_ctrl = cxusb_bluebird_power_ctrl,
1516 .i2c_algo = &cxusb_i2c_algo,
1519 .rc_key_map = dvico_portable_rc_keys,
1520 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1521 .rc_query = cxusb_rc_query,
1523 .generic_bulk_ctrl_endpoint = 0x01,
1525 .num_device_descs = 1,
1527 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1528 { &cxusb_table[7], NULL },
1529 { &cxusb_table[8], NULL },
1534 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1535 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1537 .usb_ctrl = CYPRESS_FX2,
1539 .size_of_priv = sizeof(struct cxusb_state),
1544 .streaming_ctrl = cxusb_streaming_ctrl,
1545 .frontend_attach = cxusb_dualdig4_frontend_attach,
1546 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1547 /* parameter for the MPEG2-data transfer */
1561 .power_ctrl = cxusb_power_ctrl,
1563 .i2c_algo = &cxusb_i2c_algo,
1565 .generic_bulk_ctrl_endpoint = 0x01,
1568 .rc_key_map = dvico_mce_rc_keys,
1569 .rc_key_map_size = ARRAY_SIZE(dvico_mce_rc_keys),
1570 .rc_query = cxusb_bluebird2_rc_query,
1572 .num_device_descs = 1,
1574 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1576 { &cxusb_table[13], NULL },
1581 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1582 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1584 .usb_ctrl = CYPRESS_FX2,
1585 .identify_state = bluebird_fx2_identify_state,
1587 .size_of_priv = sizeof(struct cxusb_state),
1592 .streaming_ctrl = cxusb_streaming_ctrl,
1593 .frontend_attach = cxusb_nano2_frontend_attach,
1594 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1595 /* parameter for the MPEG2-data transfer */
1609 .power_ctrl = cxusb_nano2_power_ctrl,
1611 .i2c_algo = &cxusb_i2c_algo,
1613 .generic_bulk_ctrl_endpoint = 0x01,
1616 .rc_key_map = dvico_portable_rc_keys,
1617 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1618 .rc_query = cxusb_bluebird2_rc_query,
1620 .num_device_descs = 1,
1622 { "DViCO FusionHDTV DVB-T NANO2",
1624 { &cxusb_table[14], NULL },
1629 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1630 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1632 .usb_ctrl = DEVICE_SPECIFIC,
1633 .firmware = "dvb-usb-bluebird-02.fw",
1634 .download_firmware = bluebird_patch_dvico_firmware_download,
1635 .identify_state = bluebird_fx2_identify_state,
1637 .size_of_priv = sizeof(struct cxusb_state),
1642 .streaming_ctrl = cxusb_streaming_ctrl,
1643 .frontend_attach = cxusb_nano2_frontend_attach,
1644 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1645 /* parameter for the MPEG2-data transfer */
1659 .power_ctrl = cxusb_nano2_power_ctrl,
1661 .i2c_algo = &cxusb_i2c_algo,
1663 .generic_bulk_ctrl_endpoint = 0x01,
1666 .rc_key_map = dvico_portable_rc_keys,
1667 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1668 .rc_query = cxusb_rc_query,
1670 .num_device_descs = 1,
1672 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1673 { &cxusb_table[14], NULL },
1674 { &cxusb_table[15], NULL },
1679 static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
1680 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1682 .usb_ctrl = CYPRESS_FX2,
1684 .size_of_priv = sizeof(struct cxusb_state),
1689 .streaming_ctrl = cxusb_aver_streaming_ctrl,
1690 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
1691 .tuner_attach = cxusb_mxl5003s_tuner_attach,
1692 /* parameter for the MPEG2-data transfer */
1706 .power_ctrl = cxusb_aver_power_ctrl,
1708 .i2c_algo = &cxusb_i2c_algo,
1710 .generic_bulk_ctrl_endpoint = 0x01,
1712 .num_device_descs = 1,
1714 { "AVerMedia AVerTVHD Volar (A868R)",
1716 { &cxusb_table[16], NULL },
1722 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
1723 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1725 .usb_ctrl = CYPRESS_FX2,
1727 .size_of_priv = sizeof(struct cxusb_state),
1732 .streaming_ctrl = cxusb_streaming_ctrl,
1733 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
1734 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
1735 .size_of_priv = sizeof(struct dib0700_adapter_state),
1736 /* parameter for the MPEG2-data transfer */
1750 .power_ctrl = cxusb_bluebird_power_ctrl,
1752 .i2c_algo = &cxusb_i2c_algo,
1754 .generic_bulk_ctrl_endpoint = 0x01,
1757 .rc_key_map = dvico_mce_rc_keys,
1758 .rc_key_map_size = ARRAY_SIZE(dvico_mce_rc_keys),
1759 .rc_query = cxusb_rc_query,
1761 .num_device_descs = 1,
1763 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
1765 { &cxusb_table[17], NULL },
1770 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
1771 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1773 .usb_ctrl = CYPRESS_FX2,
1775 .size_of_priv = sizeof(struct cxusb_state),
1780 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
1781 .frontend_attach = cxusb_d680_dmb_frontend_attach,
1782 .tuner_attach = cxusb_d680_dmb_tuner_attach,
1784 /* parameter for the MPEG2-data transfer */
1798 .power_ctrl = cxusb_d680_dmb_power_ctrl,
1800 .i2c_algo = &cxusb_i2c_algo,
1802 .generic_bulk_ctrl_endpoint = 0x01,
1805 .rc_key_map = d680_dmb_rc_keys,
1806 .rc_key_map_size = ARRAY_SIZE(d680_dmb_rc_keys),
1807 .rc_query = cxusb_d680_dmb_rc_query,
1809 .num_device_descs = 1,
1812 "Conexant DMB-TH Stick",
1814 { &cxusb_table[18], NULL },
1819 static struct usb_driver cxusb_driver = {
1820 .name = "dvb_usb_cxusb",
1821 .probe = cxusb_probe,
1822 .disconnect = dvb_usb_device_exit,
1823 .id_table = cxusb_table,
1827 static int __init cxusb_module_init(void)
1830 if ((result = usb_register(&cxusb_driver))) {
1831 err("usb_register failed. Error number %d",result);
1838 static void __exit cxusb_module_exit(void)
1840 /* deregister this driver from the USB subsystem */
1841 usb_deregister(&cxusb_driver);
1844 module_init (cxusb_module_init);
1845 module_exit (cxusb_module_exit);
1847 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
1848 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1849 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
1850 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
1851 MODULE_VERSION("1.0-alpha");
1852 MODULE_LICENSE("GPL");