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>
28 #include <linux/slab.h>
35 #include "mt352_priv.h"
37 #include "tuner-xc2028.h"
38 #include "tuner-simple.h"
48 /* Max transfer size done by I2C transfer functions */
49 #define MAX_XFER_SIZE 80
52 static int dvb_usb_cxusb_debug;
53 module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
54 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
56 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
58 #define deb_info(args...) dprintk(dvb_usb_cxusb_debug, 0x03, args)
59 #define deb_i2c(args...) dprintk(dvb_usb_cxusb_debug, 0x02, args)
61 static int cxusb_ctrl_msg(struct dvb_usb_device *d,
62 u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
64 int wo = (rbuf == NULL || rlen == 0); /* write-only */
65 u8 sndbuf[MAX_XFER_SIZE];
67 if (1 + wlen > sizeof(sndbuf)) {
68 warn("i2c wr: len=%d is too big!\n",
73 memset(sndbuf, 0, 1+wlen);
76 memcpy(&sndbuf[1], wbuf, wlen);
78 return dvb_usb_generic_write(d, sndbuf, 1+wlen);
80 return dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0);
84 static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
86 struct cxusb_state *st = d->priv;
89 if (st->gpio_write_state[GPIO_TUNER] == onoff)
94 cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
97 deb_info("gpio_write failed.\n");
99 st->gpio_write_state[GPIO_TUNER] = onoff;
102 static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask,
108 o[0] = 0xff & ~changemask; /* mask of bits to keep */
109 o[1] = newval & changemask; /* new values for bits */
111 rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, o, 2, &gpio_state, 1);
112 if (rc < 0 || (gpio_state & changemask) != (newval & changemask))
113 deb_info("bluebird_gpio_write failed.\n");
115 return rc < 0 ? rc : gpio_state;
118 static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low)
120 cxusb_bluebird_gpio_rw(d, pin, low ? 0 : pin);
122 cxusb_bluebird_gpio_rw(d, pin, low ? pin : 0);
125 static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
127 cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40);
130 static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
133 u8 o[2] = {addr, onoff};
137 rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
144 deb_info("gpio_write failed.\n");
150 static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
153 struct dvb_usb_device *d = i2c_get_adapdata(adap);
157 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
160 for (i = 0; i < num; i++) {
162 if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_MEDION)
163 switch (msg[i].addr) {
165 cxusb_gpio_tuner(d, 0);
168 cxusb_gpio_tuner(d, 1);
172 if (msg[i].flags & I2C_M_RD) {
174 u8 obuf[3], ibuf[MAX_XFER_SIZE];
176 if (1 + msg[i].len > sizeof(ibuf)) {
177 warn("i2c rd: len=%d is too big!\n",
183 obuf[1] = msg[i].len;
184 obuf[2] = msg[i].addr;
185 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
187 ibuf, 1+msg[i].len) < 0) {
188 warn("i2c read failed");
191 memcpy(msg[i].buf, &ibuf[1], msg[i].len);
192 } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) &&
193 msg[i].addr == msg[i+1].addr) {
194 /* write to then read from same address */
195 u8 obuf[MAX_XFER_SIZE], ibuf[MAX_XFER_SIZE];
197 if (3 + msg[i].len > sizeof(obuf)) {
198 warn("i2c wr: len=%d is too big!\n",
203 if (1 + msg[i + 1].len > sizeof(ibuf)) {
204 warn("i2c rd: len=%d is too big!\n",
209 obuf[0] = msg[i].len;
210 obuf[1] = msg[i+1].len;
211 obuf[2] = msg[i].addr;
212 memcpy(&obuf[3], msg[i].buf, msg[i].len);
214 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
216 ibuf, 1+msg[i+1].len) < 0)
220 deb_i2c("i2c read may have failed\n");
222 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
227 u8 obuf[MAX_XFER_SIZE], ibuf;
229 if (2 + msg[i].len > sizeof(obuf)) {
230 warn("i2c wr: len=%d is too big!\n",
235 obuf[0] = msg[i].addr;
236 obuf[1] = msg[i].len;
237 memcpy(&obuf[2], msg[i].buf, msg[i].len);
239 if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
240 2+msg[i].len, &ibuf,1) < 0)
243 deb_i2c("i2c write may have failed\n");
253 mutex_unlock(&d->i2c_mutex);
257 static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
262 static struct i2c_algorithm cxusb_i2c_algo = {
263 .master_xfer = cxusb_i2c_xfer,
264 .functionality = cxusb_i2c_func,
267 static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
271 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
273 return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0);
276 static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff)
280 return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, 0, NULL, 0);
281 if (d->state == DVB_USB_STATE_INIT &&
282 usb_set_interface(d->udev, 0, 0) < 0)
283 err("set interface failed");
284 do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) &&
285 !(ret = cxusb_ctrl_msg(d, 0x15, NULL, 0, NULL, 0)) &&
286 !(ret = cxusb_ctrl_msg(d, 0x17, NULL, 0, NULL, 0)) && 0);
288 /* FIXME: We don't know why, but we need to configure the
289 * lgdt3303 with the register settings below on resume */
292 0x0e, 0x2, 0x00, 0x7f,
293 0x0e, 0x2, 0x02, 0xfe,
294 0x0e, 0x2, 0x02, 0x01,
295 0x0e, 0x2, 0x00, 0x03,
296 0x0e, 0x2, 0x0d, 0x40,
297 0x0e, 0x2, 0x0e, 0x87,
298 0x0e, 0x2, 0x0f, 0x8e,
299 0x0e, 0x2, 0x10, 0x01,
300 0x0e, 0x2, 0x14, 0xd7,
301 0x0e, 0x2, 0x47, 0x88,
304 for (i = 0; i < sizeof(bufs)/sizeof(u8); i += 4/sizeof(u8)) {
305 ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE,
316 static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
320 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
325 static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff)
329 rc = cxusb_power_ctrl(d, onoff);
331 cxusb_nano2_led(d, 0);
336 static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device *d, int onoff)
340 ret = cxusb_power_ctrl(d, onoff);
345 cxusb_ctrl_msg(d, CMD_DIGITAL, NULL, 0, &b, 1);
350 static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
352 u8 buf[2] = { 0x03, 0x00 };
354 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
356 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
361 static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
364 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_ON, NULL, 0, NULL, 0);
366 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_OFF,
371 static void cxusb_d680_dmb_drain_message(struct dvb_usb_device *d)
373 int ep = d->props.generic_bulk_ctrl_endpoint;
374 const int timeout = 100;
375 const int junk_len = 32;
379 /* Discard remaining data in video pipe */
380 junk = kmalloc(junk_len, GFP_KERNEL);
384 if (usb_bulk_msg(d->udev,
385 usb_rcvbulkpipe(d->udev, ep),
386 junk, junk_len, &rd_count, timeout) < 0)
394 static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d)
396 struct usb_data_stream_properties *p = &d->props.adapter[0].fe[0].stream;
397 const int timeout = 100;
398 const int junk_len = p->u.bulk.buffersize;
402 /* Discard remaining data in video pipe */
403 junk = kmalloc(junk_len, GFP_KERNEL);
407 if (usb_bulk_msg(d->udev,
408 usb_rcvbulkpipe(d->udev, p->endpoint),
409 junk, junk_len, &rd_count, timeout) < 0)
417 static int cxusb_d680_dmb_streaming_ctrl(
418 struct dvb_usb_adapter *adap, int onoff)
421 u8 buf[2] = { 0x03, 0x00 };
422 cxusb_d680_dmb_drain_video(adap->dev);
423 return cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON,
424 buf, sizeof(buf), NULL, 0);
426 int ret = cxusb_ctrl_msg(adap->dev,
427 CMD_STREAMING_OFF, NULL, 0, NULL, 0);
432 static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
434 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
438 cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
441 *state = REMOTE_NO_KEY_PRESSED;
443 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
444 if (rc5_custom(&keymap[i]) == ircode[2] &&
445 rc5_data(&keymap[i]) == ircode[3]) {
446 *event = keymap[i].keycode;
447 *state = REMOTE_KEY_PRESSED;
456 static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
459 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
462 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
463 .buf = ircode, .len = 4 };
466 *state = REMOTE_NO_KEY_PRESSED;
468 if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
471 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
472 if (rc5_custom(&keymap[i]) == ircode[1] &&
473 rc5_data(&keymap[i]) == ircode[2]) {
474 *event = keymap[i].keycode;
475 *state = REMOTE_KEY_PRESSED;
484 static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
487 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
492 *state = REMOTE_NO_KEY_PRESSED;
494 if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0)
497 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
498 if (rc5_custom(&keymap[i]) == ircode[0] &&
499 rc5_data(&keymap[i]) == ircode[1]) {
500 *event = keymap[i].keycode;
501 *state = REMOTE_KEY_PRESSED;
510 static struct rc_map_table rc_map_dvico_mce_table[] = {
514 { 0xfe1e, KEY_FAVORITES },
515 { 0xfe16, KEY_SETUP },
516 { 0xfe46, KEY_POWER2 },
518 { 0xfe49, KEY_BACK },
519 { 0xfe4d, KEY_MENU },
521 { 0xfe5b, KEY_LEFT },
522 { 0xfe5f, KEY_RIGHT },
523 { 0xfe53, KEY_DOWN },
525 { 0xfe59, KEY_INFO },
527 { 0xfe0f, KEY_PREVIOUSSONG },/* Replay */
528 { 0xfe12, KEY_NEXTSONG }, /* Skip */
529 { 0xfe42, KEY_ENTER }, /* Windows/Start */
530 { 0xfe15, KEY_VOLUMEUP },
531 { 0xfe05, KEY_VOLUMEDOWN },
532 { 0xfe11, KEY_CHANNELUP },
533 { 0xfe09, KEY_CHANNELDOWN },
534 { 0xfe52, KEY_CAMERA },
535 { 0xfe5a, KEY_TUNER }, /* Live */
536 { 0xfe19, KEY_OPEN },
546 { 0xfe13, KEY_ANGLE }, /* Aspect */
548 { 0xfe1f, KEY_ZOOM },
549 { 0xfe43, KEY_REWIND },
550 { 0xfe47, KEY_PLAYPAUSE },
551 { 0xfe4f, KEY_FASTFORWARD },
552 { 0xfe57, KEY_MUTE },
553 { 0xfe0d, KEY_STOP },
554 { 0xfe01, KEY_RECORD },
555 { 0xfe4e, KEY_POWER },
558 static struct rc_map_table rc_map_dvico_portable_table[] = {
559 { 0xfc02, KEY_SETUP }, /* Profile */
560 { 0xfc43, KEY_POWER2 },
562 { 0xfc5a, KEY_BACK },
563 { 0xfc05, KEY_MENU },
564 { 0xfc47, KEY_INFO },
566 { 0xfc42, KEY_PREVIOUSSONG },/* Replay */
567 { 0xfc49, KEY_VOLUMEUP },
568 { 0xfc09, KEY_VOLUMEDOWN },
569 { 0xfc54, KEY_CHANNELUP },
570 { 0xfc0b, KEY_CHANNELDOWN },
571 { 0xfc16, KEY_CAMERA },
572 { 0xfc40, KEY_TUNER }, /* ATV/DTV */
573 { 0xfc45, KEY_OPEN },
583 { 0xfc44, KEY_ANGLE }, /* Aspect */
585 { 0xfc07, KEY_ZOOM },
586 { 0xfc0a, KEY_REWIND },
587 { 0xfc08, KEY_PLAYPAUSE },
588 { 0xfc4b, KEY_FASTFORWARD },
589 { 0xfc5b, KEY_MUTE },
590 { 0xfc04, KEY_STOP },
591 { 0xfc56, KEY_RECORD },
592 { 0xfc57, KEY_POWER },
593 { 0xfc41, KEY_UNKNOWN }, /* INPUT */
594 { 0xfc00, KEY_UNKNOWN }, /* HD */
597 static struct rc_map_table rc_map_d680_dmb_table[] = {
598 { 0x0038, KEY_UNKNOWN }, /* TV/AV */
599 { 0x080c, KEY_ZOOM },
610 { 0x000a, KEY_MUTE },
611 { 0x0829, KEY_BACK },
612 { 0x0012, KEY_CHANNELUP },
613 { 0x0813, KEY_CHANNELDOWN },
614 { 0x002b, KEY_VOLUMEUP },
615 { 0x082c, KEY_VOLUMEDOWN },
617 { 0x0821, KEY_DOWN },
618 { 0x0011, KEY_LEFT },
619 { 0x0810, KEY_RIGHT },
621 { 0x081f, KEY_RECORD },
622 { 0x0017, KEY_PLAYPAUSE },
623 { 0x0816, KEY_PLAYPAUSE },
624 { 0x000b, KEY_STOP },
625 { 0x0827, KEY_FASTFORWARD },
626 { 0x0026, KEY_REWIND },
627 { 0x081e, KEY_UNKNOWN }, /* Time Shift */
628 { 0x000e, KEY_UNKNOWN }, /* Snapshot */
629 { 0x082d, KEY_UNKNOWN }, /* Mouse Cursor */
630 { 0x000f, KEY_UNKNOWN }, /* Minimize/Maximize */
631 { 0x0814, KEY_UNKNOWN }, /* Shuffle */
632 { 0x0025, KEY_POWER },
635 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
637 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 };
638 static u8 reset [] = { RESET, 0x80 };
639 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
640 static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 };
641 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
642 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
644 mt352_write(fe, clock_config, sizeof(clock_config));
646 mt352_write(fe, reset, sizeof(reset));
647 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
649 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
650 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
651 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
656 static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
657 { /* used in both lgz201 and th7579 */
658 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 };
659 static u8 reset [] = { RESET, 0x80 };
660 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
661 static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 };
662 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
663 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
665 mt352_write(fe, clock_config, sizeof(clock_config));
667 mt352_write(fe, reset, sizeof(reset));
668 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
670 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
671 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
672 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
676 static struct cx22702_config cxusb_cx22702_config = {
677 .demod_address = 0x63,
678 .output_mode = CX22702_PARALLEL_OUTPUT,
681 static struct lgdt330x_config cxusb_lgdt3303_config = {
682 .demod_address = 0x0e,
683 .demod_chip = LGDT3303,
686 static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
687 .demod_address = 0x0e,
688 .demod_chip = LGDT3303,
689 .clock_polarity_flip = 2,
692 static struct mt352_config cxusb_dee1601_config = {
693 .demod_address = 0x0f,
694 .demod_init = cxusb_dee1601_demod_init,
697 static struct zl10353_config cxusb_zl10353_dee1601_config = {
698 .demod_address = 0x0f,
702 static struct mt352_config cxusb_mt352_config = {
703 /* used in both lgz201 and th7579 */
704 .demod_address = 0x0f,
705 .demod_init = cxusb_mt352_demod_init,
708 static struct zl10353_config cxusb_zl10353_xc3028_config = {
709 .demod_address = 0x0f,
715 static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
716 .demod_address = 0x0f,
720 .disable_i2c_gate_ctrl = 1,
723 static struct mt352_config cxusb_mt352_xc3028_config = {
724 .demod_address = 0x0f,
727 .demod_init = cxusb_mt352_demod_init,
730 /* FIXME: needs tweaking */
731 static struct mxl5005s_config aver_a868r_tuner = {
733 .if_freq = 6000000UL,
734 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
735 .agc_mode = MXL_SINGLE_AGC,
736 .tracking_filter = MXL_TF_C,
737 .rssi_enable = MXL_RSSI_ENABLE,
738 .cap_select = MXL_CAP_SEL_ENABLE,
739 .div_out = MXL_DIV_OUT_4,
740 .clock_out = MXL_CLOCK_OUT_DISABLE,
741 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
742 .top = MXL5005S_TOP_25P2,
743 .mod_mode = MXL_DIGITAL_MODE,
744 .if_mode = MXL_ZERO_IF,
745 .AgcMasterByte = 0x00,
748 /* FIXME: needs tweaking */
749 static struct mxl5005s_config d680_dmb_tuner = {
751 .if_freq = 36125000UL,
752 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
753 .agc_mode = MXL_SINGLE_AGC,
754 .tracking_filter = MXL_TF_C,
755 .rssi_enable = MXL_RSSI_ENABLE,
756 .cap_select = MXL_CAP_SEL_ENABLE,
757 .div_out = MXL_DIV_OUT_4,
758 .clock_out = MXL_CLOCK_OUT_DISABLE,
759 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
760 .top = MXL5005S_TOP_25P2,
761 .mod_mode = MXL_DIGITAL_MODE,
762 .if_mode = MXL_ZERO_IF,
763 .AgcMasterByte = 0x00,
766 static struct max2165_config mygica_d689_max2165_cfg = {
771 /* Callbacks for DVB USB */
772 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
774 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
775 &adap->dev->i2c_adap, 0x61,
776 TUNER_PHILIPS_FMD1216ME_MK3);
780 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
782 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
783 NULL, DVB_PLL_THOMSON_DTT7579);
787 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
789 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, NULL, DVB_PLL_LG_Z201);
793 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
795 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
796 NULL, DVB_PLL_THOMSON_DTT7579);
800 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
802 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
803 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
807 static int dvico_bluebird_xc2028_callback(void *ptr, int component,
808 int command, int arg)
810 struct dvb_usb_adapter *adap = ptr;
811 struct dvb_usb_device *d = adap->dev;
814 case XC2028_TUNER_RESET:
815 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
816 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
818 case XC2028_RESET_CLK:
819 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
822 deb_info("%s: unknown command %d, arg %d\n", __func__,
830 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
832 struct dvb_frontend *fe;
833 struct xc2028_config cfg = {
834 .i2c_adap = &adap->dev->i2c_adap,
837 static struct xc2028_ctrl ctl = {
838 .fname = XC2028_DEFAULT_FIRMWARE,
840 .demod = XC3028_FE_ZARLINK456,
843 /* FIXME: generalize & move to common area */
844 adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback;
846 fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg);
847 if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
850 fe->ops.tuner_ops.set_config(fe, &ctl);
855 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
857 dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
858 &adap->dev->i2c_adap, &aver_a868r_tuner);
862 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
864 struct dvb_frontend *fe;
865 fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
866 &adap->dev->i2c_adap, &d680_dmb_tuner);
867 return (fe == NULL) ? -EIO : 0;
870 static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
872 struct dvb_frontend *fe;
873 fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe,
874 &adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
875 return (fe == NULL) ? -EIO : 0;
878 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
881 if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
882 err("set interface failed");
884 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
886 adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
887 &adap->dev->i2c_adap);
888 if ((adap->fe_adap[0].fe) != NULL)
894 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
896 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
897 err("set interface failed");
899 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
901 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
902 &cxusb_lgdt3303_config,
903 &adap->dev->i2c_adap);
904 if ((adap->fe_adap[0].fe) != NULL)
910 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
912 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
913 &adap->dev->i2c_adap);
914 if (adap->fe_adap[0].fe != NULL)
920 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
922 /* used in both lgz201 and th7579 */
923 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
924 err("set interface failed");
926 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
928 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
929 &adap->dev->i2c_adap);
930 if ((adap->fe_adap[0].fe) != NULL)
936 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
938 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
939 err("set interface failed");
941 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
943 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
944 &adap->dev->i2c_adap);
945 if ((adap->fe_adap[0].fe) != NULL)
948 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
949 &cxusb_zl10353_dee1601_config,
950 &adap->dev->i2c_adap);
951 if ((adap->fe_adap[0].fe) != NULL)
957 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
961 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
962 .buf = ircode, .len = 4 };
964 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
965 err("set interface failed");
967 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
969 /* reset the tuner and demodulator */
970 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
971 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
972 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
974 adap->fe_adap[0].fe =
975 dvb_attach(zl10353_attach,
976 &cxusb_zl10353_xc3028_config_no_i2c_gate,
977 &adap->dev->i2c_adap);
978 if ((adap->fe_adap[0].fe) == NULL)
981 /* try to determine if there is no IR decoder on the I2C bus */
982 for (i = 0; adap->dev->props.rc.legacy.rc_map_table != NULL && i < 5; i++) {
984 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
986 if (ircode[0] == 0 && ircode[1] == 0)
988 if (ircode[2] + ircode[3] != 0xff) {
990 adap->dev->props.rc.legacy.rc_map_table = NULL;
991 info("No IR receiver detected on this device.");
999 static struct dibx000_agc_config dib7070_agc_config = {
1000 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1003 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
1004 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1005 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
1007 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
1008 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1010 .time_stabiliz = 10,
1034 .perform_agc_softsplit = 0,
1037 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1047 .IO_CLK_en_core = 1,
1050 /* refsel, sel, freq_15k */
1051 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1052 .ifreq = (0 << 25) | 0,
1054 .xtal_hz = 12000000,
1057 static struct dib7000p_config cxusb_dualdig4_rev2_config = {
1058 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
1059 .output_mpeg2_in_188_bytes = 1,
1061 .agc_config_count = 1,
1062 .agc = &dib7070_agc_config,
1063 .bw = &dib7070_bw_config_12_mhz,
1064 .tuner_is_baseband = 1,
1070 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1072 .hostbus_diversity = 1,
1075 struct dib0700_adapter_state {
1076 int (*set_param_save)(struct dvb_frontend *);
1077 struct dib7000p_ops dib7000p_ops;
1080 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1082 struct dib0700_adapter_state *state = adap->priv;
1084 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1085 err("set interface failed");
1087 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1089 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1091 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1094 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1095 &cxusb_dualdig4_rev2_config) < 0) {
1096 printk(KERN_WARNING "Unable to enumerate dib7000p\n");
1100 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1101 &cxusb_dualdig4_rev2_config);
1102 if (adap->fe_adap[0].fe == NULL)
1108 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1110 struct dvb_usb_adapter *adap = fe->dvb->priv;
1111 struct dib0700_adapter_state *state = adap->priv;
1113 return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
1116 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1121 static struct dib0070_config dib7070p_dib0070_config = {
1122 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1123 .reset = dib7070_tuner_reset,
1124 .sleep = dib7070_tuner_sleep,
1128 static int dib7070_set_param_override(struct dvb_frontend *fe)
1130 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1131 struct dvb_usb_adapter *adap = fe->dvb->priv;
1132 struct dib0700_adapter_state *state = adap->priv;
1135 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1137 case BAND_VHF: offset = 950; break;
1139 case BAND_UHF: offset = 550; break;
1142 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1144 return state->set_param_save(fe);
1147 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1149 struct dib0700_adapter_state *st = adap->priv;
1150 struct i2c_adapter *tun_i2c;
1153 * No need to call dvb7000p_attach here, as it was called
1154 * already, as frontend_attach method is called first, and
1155 * tuner_attach is only called on sucess.
1157 tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
1158 DIBX000_I2C_INTERFACE_TUNER, 1);
1160 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1161 &dib7070p_dib0070_config) == NULL)
1164 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1165 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1169 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1171 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1172 err("set interface failed");
1174 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1176 /* reset the tuner and demodulator */
1177 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1178 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1179 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1181 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
1182 &cxusb_zl10353_xc3028_config,
1183 &adap->dev->i2c_adap);
1184 if ((adap->fe_adap[0].fe) != NULL)
1187 adap->fe_adap[0].fe = dvb_attach(mt352_attach,
1188 &cxusb_mt352_xc3028_config,
1189 &adap->dev->i2c_adap);
1190 if ((adap->fe_adap[0].fe) != NULL)
1196 static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1197 .prod = LGS8GXX_PROD_LGS8GL5,
1198 .demod_address = 0x19,
1202 .if_clk_freq = 30400, /* 30.4 MHz */
1203 .if_freq = 5725, /* 5.725 MHz */
1210 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1212 struct dvb_usb_device *d = adap->dev;
1215 /* Select required USB configuration */
1216 if (usb_set_interface(d->udev, 0, 0) < 0)
1217 err("set interface failed");
1219 /* Unblock all USB pipes */
1220 usb_clear_halt(d->udev,
1221 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1222 usb_clear_halt(d->udev,
1223 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1224 usb_clear_halt(d->udev,
1225 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1227 /* Drain USB pipes to avoid hang after reboot */
1228 for (n = 0; n < 5; n++) {
1229 cxusb_d680_dmb_drain_message(d);
1230 cxusb_d680_dmb_drain_video(d);
1234 /* Reset the tuner */
1235 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1236 err("clear tuner gpio failed");
1240 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1241 err("set tuner gpio failed");
1246 /* Attach frontend */
1247 adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
1248 if (adap->fe_adap[0].fe == NULL)
1254 static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1255 .prod = ATBM8830_PROD_8830,
1256 .demod_address = 0x40,
1258 .ts_sampling_edge = 1,
1260 .osc_clk_freq = 30400, /* in kHz */
1261 .if_freq = 0, /* zero IF */
1268 static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1270 struct dvb_usb_device *d = adap->dev;
1272 /* Select required USB configuration */
1273 if (usb_set_interface(d->udev, 0, 0) < 0)
1274 err("set interface failed");
1276 /* Unblock all USB pipes */
1277 usb_clear_halt(d->udev,
1278 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1279 usb_clear_halt(d->udev,
1280 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1281 usb_clear_halt(d->udev,
1282 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1285 /* Reset the tuner */
1286 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1287 err("clear tuner gpio failed");
1291 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1292 err("set tuner gpio failed");
1297 /* Attach frontend */
1298 adap->fe_adap[0].fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg,
1300 if (adap->fe_adap[0].fe == NULL)
1306 static int cxusb_mygica_t230_frontend_attach(struct dvb_usb_adapter *adap)
1308 struct dvb_usb_device *d = adap->dev;
1309 struct cxusb_state *st = d->priv;
1310 struct i2c_adapter *adapter;
1311 struct i2c_client *client_demod;
1312 struct i2c_client *client_tuner;
1313 struct i2c_board_info info;
1314 struct si2168_config si2168_config;
1315 struct si2157_config si2157_config;
1317 /* Select required USB configuration */
1318 if (usb_set_interface(d->udev, 0, 0) < 0)
1319 err("set interface failed");
1321 /* Unblock all USB pipes */
1322 usb_clear_halt(d->udev,
1323 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1324 usb_clear_halt(d->udev,
1325 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1326 usb_clear_halt(d->udev,
1327 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1329 /* attach frontend */
1330 si2168_config.i2c_adapter = &adapter;
1331 si2168_config.fe = &adap->fe_adap[0].fe;
1332 si2168_config.ts_mode = SI2168_TS_PARALLEL;
1333 si2168_config.ts_clock_inv = 1;
1334 memset(&info, 0, sizeof(struct i2c_board_info));
1335 strlcpy(info.type, "si2168", I2C_NAME_SIZE);
1337 info.platform_data = &si2168_config;
1338 request_module(info.type);
1339 client_demod = i2c_new_device(&d->i2c_adap, &info);
1340 if (client_demod == NULL || client_demod->dev.driver == NULL)
1343 if (!try_module_get(client_demod->dev.driver->owner)) {
1344 i2c_unregister_device(client_demod);
1348 st->i2c_client_demod = client_demod;
1351 memset(&si2157_config, 0, sizeof(si2157_config));
1352 si2157_config.fe = adap->fe_adap[0].fe;
1353 memset(&info, 0, sizeof(struct i2c_board_info));
1354 strlcpy(info.type, "si2157", I2C_NAME_SIZE);
1356 info.platform_data = &si2157_config;
1357 request_module(info.type);
1358 client_tuner = i2c_new_device(adapter, &info);
1359 if (client_tuner == NULL || client_tuner->dev.driver == NULL) {
1360 module_put(client_demod->dev.driver->owner);
1361 i2c_unregister_device(client_demod);
1364 if (!try_module_get(client_tuner->dev.driver->owner)) {
1365 i2c_unregister_device(client_tuner);
1366 module_put(client_demod->dev.driver->owner);
1367 i2c_unregister_device(client_demod);
1371 st->i2c_client_tuner = client_tuner;
1377 * DViCO has shipped two devices with the same USB ID, but only one of them
1378 * needs a firmware download. Check the device class details to see if they
1379 * have non-default values to decide whether the device is actually cold or
1380 * not, and forget a match if it turns out we selected the wrong device.
1382 static int bluebird_fx2_identify_state(struct usb_device *udev,
1383 struct dvb_usb_device_properties *props,
1384 struct dvb_usb_device_description **desc,
1387 int wascold = *cold;
1389 *cold = udev->descriptor.bDeviceClass == 0xff &&
1390 udev->descriptor.bDeviceSubClass == 0xff &&
1391 udev->descriptor.bDeviceProtocol == 0xff;
1393 if (*cold && !wascold)
1400 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1401 * firmware file before download.
1404 static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1405 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1406 const struct firmware *fw)
1410 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1411 int idoff = dvico_firmware_id_offsets[pos];
1413 if (fw->size < idoff + 4)
1416 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1417 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1418 struct firmware new_fw;
1419 u8 *new_fw_data = vmalloc(fw->size);
1425 memcpy(new_fw_data, fw->data, fw->size);
1426 new_fw.size = fw->size;
1427 new_fw.data = new_fw_data;
1429 new_fw_data[idoff + 2] =
1430 le16_to_cpu(udev->descriptor.idProduct) + 1;
1431 new_fw_data[idoff + 3] =
1432 le16_to_cpu(udev->descriptor.idProduct) >> 8;
1434 ret = usb_cypress_load_firmware(udev, &new_fw,
1444 /* DVB USB Driver stuff */
1445 static struct dvb_usb_device_properties cxusb_medion_properties;
1446 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1447 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1448 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1449 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1450 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1451 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1452 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1453 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1454 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1455 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1456 static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
1457 static struct dvb_usb_device_properties cxusb_mygica_t230_properties;
1459 static int cxusb_probe(struct usb_interface *intf,
1460 const struct usb_device_id *id)
1462 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1463 THIS_MODULE, NULL, adapter_nr) ||
1464 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1465 THIS_MODULE, NULL, adapter_nr) ||
1466 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1467 THIS_MODULE, NULL, adapter_nr) ||
1468 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1469 THIS_MODULE, NULL, adapter_nr) ||
1470 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1471 THIS_MODULE, NULL, adapter_nr) ||
1472 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1473 THIS_MODULE, NULL, adapter_nr) ||
1474 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1475 THIS_MODULE, NULL, adapter_nr) ||
1476 0 == dvb_usb_device_init(intf,
1477 &cxusb_bluebird_nano2_needsfirmware_properties,
1478 THIS_MODULE, NULL, adapter_nr) ||
1479 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1480 THIS_MODULE, NULL, adapter_nr) ||
1481 0 == dvb_usb_device_init(intf,
1482 &cxusb_bluebird_dualdig4_rev2_properties,
1483 THIS_MODULE, NULL, adapter_nr) ||
1484 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1485 THIS_MODULE, NULL, adapter_nr) ||
1486 0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1487 THIS_MODULE, NULL, adapter_nr) ||
1488 0 == dvb_usb_device_init(intf, &cxusb_mygica_t230_properties,
1489 THIS_MODULE, NULL, adapter_nr) ||
1496 static void cxusb_disconnect(struct usb_interface *intf)
1498 struct dvb_usb_device *d = usb_get_intfdata(intf);
1499 struct cxusb_state *st = d->priv;
1500 struct i2c_client *client;
1502 /* remove I2C client for tuner */
1503 client = st->i2c_client_tuner;
1505 module_put(client->dev.driver->owner);
1506 i2c_unregister_device(client);
1509 /* remove I2C client for demodulator */
1510 client = st->i2c_client_demod;
1512 module_put(client->dev.driver->owner);
1513 i2c_unregister_device(client);
1516 dvb_usb_device_exit(intf);
1519 static struct usb_device_id cxusb_table [] = {
1520 { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
1521 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
1522 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
1523 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
1524 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
1525 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
1526 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
1527 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
1528 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
1529 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
1530 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
1531 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
1532 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
1533 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
1534 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
1535 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
1536 { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
1537 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
1538 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
1539 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) },
1540 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_T230) },
1541 {} /* Terminating entry */
1543 MODULE_DEVICE_TABLE (usb, cxusb_table);
1545 static struct dvb_usb_device_properties cxusb_medion_properties = {
1546 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1548 .usb_ctrl = CYPRESS_FX2,
1550 .size_of_priv = sizeof(struct cxusb_state),
1557 .streaming_ctrl = cxusb_streaming_ctrl,
1558 .frontend_attach = cxusb_cx22702_frontend_attach,
1559 .tuner_attach = cxusb_fmd1216me_tuner_attach,
1560 /* parameter for the MPEG2-data transfer */
1574 .power_ctrl = cxusb_power_ctrl,
1576 .i2c_algo = &cxusb_i2c_algo,
1578 .generic_bulk_ctrl_endpoint = 0x01,
1580 .num_device_descs = 1,
1582 { "Medion MD95700 (MDUSBTV-HYBRID)",
1584 { &cxusb_table[0], NULL },
1589 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1590 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1592 .usb_ctrl = DEVICE_SPECIFIC,
1593 .firmware = "dvb-usb-bluebird-01.fw",
1594 .download_firmware = bluebird_patch_dvico_firmware_download,
1595 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1596 use usb alt setting 7 for EP2 transfer (atsc) */
1598 .size_of_priv = sizeof(struct cxusb_state),
1605 .streaming_ctrl = cxusb_streaming_ctrl,
1606 .frontend_attach = cxusb_lgdt3303_frontend_attach,
1607 .tuner_attach = cxusb_lgh064f_tuner_attach,
1609 /* parameter for the MPEG2-data transfer */
1624 .power_ctrl = cxusb_bluebird_power_ctrl,
1626 .i2c_algo = &cxusb_i2c_algo,
1630 .rc_map_table = rc_map_dvico_portable_table,
1631 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1632 .rc_query = cxusb_rc_query,
1635 .generic_bulk_ctrl_endpoint = 0x01,
1637 .num_device_descs = 1,
1639 { "DViCO FusionHDTV5 USB Gold",
1640 { &cxusb_table[1], NULL },
1641 { &cxusb_table[2], NULL },
1646 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1647 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1649 .usb_ctrl = DEVICE_SPECIFIC,
1650 .firmware = "dvb-usb-bluebird-01.fw",
1651 .download_firmware = bluebird_patch_dvico_firmware_download,
1652 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1653 use usb alt setting 7 for EP2 transfer (atsc) */
1655 .size_of_priv = sizeof(struct cxusb_state),
1662 .streaming_ctrl = cxusb_streaming_ctrl,
1663 .frontend_attach = cxusb_dee1601_frontend_attach,
1664 .tuner_attach = cxusb_dee1601_tuner_attach,
1665 /* parameter for the MPEG2-data transfer */
1680 .power_ctrl = cxusb_bluebird_power_ctrl,
1682 .i2c_algo = &cxusb_i2c_algo,
1686 .rc_map_table = rc_map_dvico_mce_table,
1687 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
1688 .rc_query = cxusb_rc_query,
1691 .generic_bulk_ctrl_endpoint = 0x01,
1693 .num_device_descs = 3,
1695 { "DViCO FusionHDTV DVB-T Dual USB",
1696 { &cxusb_table[3], NULL },
1697 { &cxusb_table[4], NULL },
1699 { "DigitalNow DVB-T Dual USB",
1700 { &cxusb_table[9], NULL },
1701 { &cxusb_table[10], NULL },
1703 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1704 { &cxusb_table[11], NULL },
1705 { &cxusb_table[12], NULL },
1710 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1711 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1713 .usb_ctrl = DEVICE_SPECIFIC,
1714 .firmware = "dvb-usb-bluebird-01.fw",
1715 .download_firmware = bluebird_patch_dvico_firmware_download,
1716 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1717 use usb alt setting 7 for EP2 transfer (atsc) */
1719 .size_of_priv = sizeof(struct cxusb_state),
1726 .streaming_ctrl = cxusb_streaming_ctrl,
1727 .frontend_attach = cxusb_mt352_frontend_attach,
1728 .tuner_attach = cxusb_lgz201_tuner_attach,
1730 /* parameter for the MPEG2-data transfer */
1744 .power_ctrl = cxusb_bluebird_power_ctrl,
1746 .i2c_algo = &cxusb_i2c_algo,
1750 .rc_map_table = rc_map_dvico_portable_table,
1751 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1752 .rc_query = cxusb_rc_query,
1755 .generic_bulk_ctrl_endpoint = 0x01,
1756 .num_device_descs = 1,
1758 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1759 { &cxusb_table[5], NULL },
1760 { &cxusb_table[6], NULL },
1765 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1766 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1768 .usb_ctrl = DEVICE_SPECIFIC,
1769 .firmware = "dvb-usb-bluebird-01.fw",
1770 .download_firmware = bluebird_patch_dvico_firmware_download,
1771 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1772 use usb alt setting 7 for EP2 transfer (atsc) */
1774 .size_of_priv = sizeof(struct cxusb_state),
1781 .streaming_ctrl = cxusb_streaming_ctrl,
1782 .frontend_attach = cxusb_mt352_frontend_attach,
1783 .tuner_attach = cxusb_dtt7579_tuner_attach,
1785 /* parameter for the MPEG2-data transfer */
1799 .power_ctrl = cxusb_bluebird_power_ctrl,
1801 .i2c_algo = &cxusb_i2c_algo,
1805 .rc_map_table = rc_map_dvico_portable_table,
1806 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1807 .rc_query = cxusb_rc_query,
1810 .generic_bulk_ctrl_endpoint = 0x01,
1812 .num_device_descs = 1,
1814 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1815 { &cxusb_table[7], NULL },
1816 { &cxusb_table[8], NULL },
1821 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1822 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1824 .usb_ctrl = CYPRESS_FX2,
1826 .size_of_priv = sizeof(struct cxusb_state),
1833 .streaming_ctrl = cxusb_streaming_ctrl,
1834 .frontend_attach = cxusb_dualdig4_frontend_attach,
1835 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1836 /* parameter for the MPEG2-data transfer */
1851 .power_ctrl = cxusb_power_ctrl,
1853 .i2c_algo = &cxusb_i2c_algo,
1855 .generic_bulk_ctrl_endpoint = 0x01,
1859 .rc_map_table = rc_map_dvico_mce_table,
1860 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
1861 .rc_query = cxusb_bluebird2_rc_query,
1864 .num_device_descs = 1,
1866 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1868 { &cxusb_table[13], NULL },
1873 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1874 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1876 .usb_ctrl = CYPRESS_FX2,
1877 .identify_state = bluebird_fx2_identify_state,
1879 .size_of_priv = sizeof(struct cxusb_state),
1886 .streaming_ctrl = cxusb_streaming_ctrl,
1887 .frontend_attach = cxusb_nano2_frontend_attach,
1888 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1889 /* parameter for the MPEG2-data transfer */
1904 .power_ctrl = cxusb_nano2_power_ctrl,
1906 .i2c_algo = &cxusb_i2c_algo,
1908 .generic_bulk_ctrl_endpoint = 0x01,
1912 .rc_map_table = rc_map_dvico_portable_table,
1913 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1914 .rc_query = cxusb_bluebird2_rc_query,
1917 .num_device_descs = 1,
1919 { "DViCO FusionHDTV DVB-T NANO2",
1921 { &cxusb_table[14], NULL },
1926 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1927 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1929 .usb_ctrl = DEVICE_SPECIFIC,
1930 .firmware = "dvb-usb-bluebird-02.fw",
1931 .download_firmware = bluebird_patch_dvico_firmware_download,
1932 .identify_state = bluebird_fx2_identify_state,
1934 .size_of_priv = sizeof(struct cxusb_state),
1941 .streaming_ctrl = cxusb_streaming_ctrl,
1942 .frontend_attach = cxusb_nano2_frontend_attach,
1943 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1944 /* parameter for the MPEG2-data transfer */
1959 .power_ctrl = cxusb_nano2_power_ctrl,
1961 .i2c_algo = &cxusb_i2c_algo,
1963 .generic_bulk_ctrl_endpoint = 0x01,
1967 .rc_map_table = rc_map_dvico_portable_table,
1968 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1969 .rc_query = cxusb_rc_query,
1972 .num_device_descs = 1,
1974 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1975 { &cxusb_table[14], NULL },
1976 { &cxusb_table[15], NULL },
1981 static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
1982 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1984 .usb_ctrl = CYPRESS_FX2,
1986 .size_of_priv = sizeof(struct cxusb_state),
1993 .streaming_ctrl = cxusb_aver_streaming_ctrl,
1994 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
1995 .tuner_attach = cxusb_mxl5003s_tuner_attach,
1996 /* parameter for the MPEG2-data transfer */
2010 .power_ctrl = cxusb_aver_power_ctrl,
2012 .i2c_algo = &cxusb_i2c_algo,
2014 .generic_bulk_ctrl_endpoint = 0x01,
2016 .num_device_descs = 1,
2018 { "AVerMedia AVerTVHD Volar (A868R)",
2020 { &cxusb_table[16], NULL },
2026 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
2027 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2029 .usb_ctrl = CYPRESS_FX2,
2031 .size_of_priv = sizeof(struct cxusb_state),
2036 .size_of_priv = sizeof(struct dib0700_adapter_state),
2039 .streaming_ctrl = cxusb_streaming_ctrl,
2040 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
2041 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
2042 /* parameter for the MPEG2-data transfer */
2057 .power_ctrl = cxusb_bluebird_power_ctrl,
2059 .i2c_algo = &cxusb_i2c_algo,
2061 .generic_bulk_ctrl_endpoint = 0x01,
2065 .rc_map_table = rc_map_dvico_mce_table,
2066 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
2067 .rc_query = cxusb_rc_query,
2070 .num_device_descs = 1,
2072 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
2074 { &cxusb_table[17], NULL },
2079 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
2080 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2082 .usb_ctrl = CYPRESS_FX2,
2084 .size_of_priv = sizeof(struct cxusb_state),
2091 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2092 .frontend_attach = cxusb_d680_dmb_frontend_attach,
2093 .tuner_attach = cxusb_d680_dmb_tuner_attach,
2095 /* parameter for the MPEG2-data transfer */
2110 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2112 .i2c_algo = &cxusb_i2c_algo,
2114 .generic_bulk_ctrl_endpoint = 0x01,
2118 .rc_map_table = rc_map_d680_dmb_table,
2119 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2120 .rc_query = cxusb_d680_dmb_rc_query,
2123 .num_device_descs = 1,
2126 "Conexant DMB-TH Stick",
2128 { &cxusb_table[18], NULL },
2133 static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
2134 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2136 .usb_ctrl = CYPRESS_FX2,
2138 .size_of_priv = sizeof(struct cxusb_state),
2145 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2146 .frontend_attach = cxusb_mygica_d689_frontend_attach,
2147 .tuner_attach = cxusb_mygica_d689_tuner_attach,
2149 /* parameter for the MPEG2-data transfer */
2164 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2166 .i2c_algo = &cxusb_i2c_algo,
2168 .generic_bulk_ctrl_endpoint = 0x01,
2172 .rc_map_table = rc_map_d680_dmb_table,
2173 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2174 .rc_query = cxusb_d680_dmb_rc_query,
2177 .num_device_descs = 1,
2180 "Mygica D689 DMB-TH",
2182 { &cxusb_table[19], NULL },
2187 static struct dvb_usb_device_properties cxusb_mygica_t230_properties = {
2188 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2190 .usb_ctrl = CYPRESS_FX2,
2192 .size_of_priv = sizeof(struct cxusb_state),
2199 .streaming_ctrl = cxusb_streaming_ctrl,
2200 .frontend_attach = cxusb_mygica_t230_frontend_attach,
2202 /* parameter for the MPEG2-data transfer */
2217 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2219 .i2c_algo = &cxusb_i2c_algo,
2221 .generic_bulk_ctrl_endpoint = 0x01,
2225 .rc_map_table = rc_map_d680_dmb_table,
2226 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2227 .rc_query = cxusb_d680_dmb_rc_query,
2230 .num_device_descs = 1,
2233 "Mygica T230 DVB-T/T2/C",
2235 { &cxusb_table[20], NULL },
2240 static struct usb_driver cxusb_driver = {
2241 .name = "dvb_usb_cxusb",
2242 .probe = cxusb_probe,
2243 .disconnect = cxusb_disconnect,
2244 .id_table = cxusb_table,
2247 module_usb_driver(cxusb_driver);
2249 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
2250 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
2251 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
2252 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2253 MODULE_VERSION("1.0-alpha");
2254 MODULE_LICENSE("GPL");