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 if (cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4) < 0)
442 *state = REMOTE_NO_KEY_PRESSED;
444 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
445 if (rc5_custom(&keymap[i]) == ircode[2] &&
446 rc5_data(&keymap[i]) == ircode[3]) {
447 *event = keymap[i].keycode;
448 *state = REMOTE_KEY_PRESSED;
457 static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
460 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
463 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
464 .buf = ircode, .len = 4 };
467 *state = REMOTE_NO_KEY_PRESSED;
469 if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
472 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
473 if (rc5_custom(&keymap[i]) == ircode[1] &&
474 rc5_data(&keymap[i]) == ircode[2]) {
475 *event = keymap[i].keycode;
476 *state = REMOTE_KEY_PRESSED;
485 static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
488 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
493 *state = REMOTE_NO_KEY_PRESSED;
495 if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0)
498 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
499 if (rc5_custom(&keymap[i]) == ircode[0] &&
500 rc5_data(&keymap[i]) == ircode[1]) {
501 *event = keymap[i].keycode;
502 *state = REMOTE_KEY_PRESSED;
511 static struct rc_map_table rc_map_dvico_mce_table[] = {
515 { 0xfe1e, KEY_FAVORITES },
516 { 0xfe16, KEY_SETUP },
517 { 0xfe46, KEY_POWER2 },
519 { 0xfe49, KEY_BACK },
520 { 0xfe4d, KEY_MENU },
522 { 0xfe5b, KEY_LEFT },
523 { 0xfe5f, KEY_RIGHT },
524 { 0xfe53, KEY_DOWN },
526 { 0xfe59, KEY_INFO },
528 { 0xfe0f, KEY_PREVIOUSSONG },/* Replay */
529 { 0xfe12, KEY_NEXTSONG }, /* Skip */
530 { 0xfe42, KEY_ENTER }, /* Windows/Start */
531 { 0xfe15, KEY_VOLUMEUP },
532 { 0xfe05, KEY_VOLUMEDOWN },
533 { 0xfe11, KEY_CHANNELUP },
534 { 0xfe09, KEY_CHANNELDOWN },
535 { 0xfe52, KEY_CAMERA },
536 { 0xfe5a, KEY_TUNER }, /* Live */
537 { 0xfe19, KEY_OPEN },
547 { 0xfe13, KEY_ANGLE }, /* Aspect */
549 { 0xfe1f, KEY_ZOOM },
550 { 0xfe43, KEY_REWIND },
551 { 0xfe47, KEY_PLAYPAUSE },
552 { 0xfe4f, KEY_FASTFORWARD },
553 { 0xfe57, KEY_MUTE },
554 { 0xfe0d, KEY_STOP },
555 { 0xfe01, KEY_RECORD },
556 { 0xfe4e, KEY_POWER },
559 static struct rc_map_table rc_map_dvico_portable_table[] = {
560 { 0xfc02, KEY_SETUP }, /* Profile */
561 { 0xfc43, KEY_POWER2 },
563 { 0xfc5a, KEY_BACK },
564 { 0xfc05, KEY_MENU },
565 { 0xfc47, KEY_INFO },
567 { 0xfc42, KEY_PREVIOUSSONG },/* Replay */
568 { 0xfc49, KEY_VOLUMEUP },
569 { 0xfc09, KEY_VOLUMEDOWN },
570 { 0xfc54, KEY_CHANNELUP },
571 { 0xfc0b, KEY_CHANNELDOWN },
572 { 0xfc16, KEY_CAMERA },
573 { 0xfc40, KEY_TUNER }, /* ATV/DTV */
574 { 0xfc45, KEY_OPEN },
584 { 0xfc44, KEY_ANGLE }, /* Aspect */
586 { 0xfc07, KEY_ZOOM },
587 { 0xfc0a, KEY_REWIND },
588 { 0xfc08, KEY_PLAYPAUSE },
589 { 0xfc4b, KEY_FASTFORWARD },
590 { 0xfc5b, KEY_MUTE },
591 { 0xfc04, KEY_STOP },
592 { 0xfc56, KEY_RECORD },
593 { 0xfc57, KEY_POWER },
594 { 0xfc41, KEY_UNKNOWN }, /* INPUT */
595 { 0xfc00, KEY_UNKNOWN }, /* HD */
598 static struct rc_map_table rc_map_d680_dmb_table[] = {
599 { 0x0038, KEY_UNKNOWN }, /* TV/AV */
600 { 0x080c, KEY_ZOOM },
611 { 0x000a, KEY_MUTE },
612 { 0x0829, KEY_BACK },
613 { 0x0012, KEY_CHANNELUP },
614 { 0x0813, KEY_CHANNELDOWN },
615 { 0x002b, KEY_VOLUMEUP },
616 { 0x082c, KEY_VOLUMEDOWN },
618 { 0x0821, KEY_DOWN },
619 { 0x0011, KEY_LEFT },
620 { 0x0810, KEY_RIGHT },
622 { 0x081f, KEY_RECORD },
623 { 0x0017, KEY_PLAYPAUSE },
624 { 0x0816, KEY_PLAYPAUSE },
625 { 0x000b, KEY_STOP },
626 { 0x0827, KEY_FASTFORWARD },
627 { 0x0026, KEY_REWIND },
628 { 0x081e, KEY_UNKNOWN }, /* Time Shift */
629 { 0x000e, KEY_UNKNOWN }, /* Snapshot */
630 { 0x082d, KEY_UNKNOWN }, /* Mouse Cursor */
631 { 0x000f, KEY_UNKNOWN }, /* Minimize/Maximize */
632 { 0x0814, KEY_UNKNOWN }, /* Shuffle */
633 { 0x0025, KEY_POWER },
636 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
638 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 };
639 static u8 reset [] = { RESET, 0x80 };
640 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
641 static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 };
642 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
643 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
645 mt352_write(fe, clock_config, sizeof(clock_config));
647 mt352_write(fe, reset, sizeof(reset));
648 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
650 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
651 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
652 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
657 static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
658 { /* used in both lgz201 and th7579 */
659 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 };
660 static u8 reset [] = { RESET, 0x80 };
661 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
662 static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 };
663 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
664 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
666 mt352_write(fe, clock_config, sizeof(clock_config));
668 mt352_write(fe, reset, sizeof(reset));
669 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
671 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
672 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
673 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
677 static struct cx22702_config cxusb_cx22702_config = {
678 .demod_address = 0x63,
679 .output_mode = CX22702_PARALLEL_OUTPUT,
682 static struct lgdt330x_config cxusb_lgdt3303_config = {
683 .demod_address = 0x0e,
684 .demod_chip = LGDT3303,
687 static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
688 .demod_address = 0x0e,
689 .demod_chip = LGDT3303,
690 .clock_polarity_flip = 2,
693 static struct mt352_config cxusb_dee1601_config = {
694 .demod_address = 0x0f,
695 .demod_init = cxusb_dee1601_demod_init,
698 static struct zl10353_config cxusb_zl10353_dee1601_config = {
699 .demod_address = 0x0f,
703 static struct mt352_config cxusb_mt352_config = {
704 /* used in both lgz201 and th7579 */
705 .demod_address = 0x0f,
706 .demod_init = cxusb_mt352_demod_init,
709 static struct zl10353_config cxusb_zl10353_xc3028_config = {
710 .demod_address = 0x0f,
716 static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
717 .demod_address = 0x0f,
721 .disable_i2c_gate_ctrl = 1,
724 static struct mt352_config cxusb_mt352_xc3028_config = {
725 .demod_address = 0x0f,
728 .demod_init = cxusb_mt352_demod_init,
731 /* FIXME: needs tweaking */
732 static struct mxl5005s_config aver_a868r_tuner = {
734 .if_freq = 6000000UL,
735 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
736 .agc_mode = MXL_SINGLE_AGC,
737 .tracking_filter = MXL_TF_C,
738 .rssi_enable = MXL_RSSI_ENABLE,
739 .cap_select = MXL_CAP_SEL_ENABLE,
740 .div_out = MXL_DIV_OUT_4,
741 .clock_out = MXL_CLOCK_OUT_DISABLE,
742 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
743 .top = MXL5005S_TOP_25P2,
744 .mod_mode = MXL_DIGITAL_MODE,
745 .if_mode = MXL_ZERO_IF,
746 .AgcMasterByte = 0x00,
749 /* FIXME: needs tweaking */
750 static struct mxl5005s_config d680_dmb_tuner = {
752 .if_freq = 36125000UL,
753 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
754 .agc_mode = MXL_SINGLE_AGC,
755 .tracking_filter = MXL_TF_C,
756 .rssi_enable = MXL_RSSI_ENABLE,
757 .cap_select = MXL_CAP_SEL_ENABLE,
758 .div_out = MXL_DIV_OUT_4,
759 .clock_out = MXL_CLOCK_OUT_DISABLE,
760 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
761 .top = MXL5005S_TOP_25P2,
762 .mod_mode = MXL_DIGITAL_MODE,
763 .if_mode = MXL_ZERO_IF,
764 .AgcMasterByte = 0x00,
767 static struct max2165_config mygica_d689_max2165_cfg = {
772 /* Callbacks for DVB USB */
773 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
775 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
776 &adap->dev->i2c_adap, 0x61,
777 TUNER_PHILIPS_FMD1216ME_MK3);
781 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
783 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
784 NULL, DVB_PLL_THOMSON_DTT7579);
788 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
790 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, NULL, DVB_PLL_LG_Z201);
794 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
796 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
797 NULL, DVB_PLL_THOMSON_DTT7579);
801 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
803 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
804 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
808 static int dvico_bluebird_xc2028_callback(void *ptr, int component,
809 int command, int arg)
811 struct dvb_usb_adapter *adap = ptr;
812 struct dvb_usb_device *d = adap->dev;
815 case XC2028_TUNER_RESET:
816 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
817 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
819 case XC2028_RESET_CLK:
820 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
822 case XC2028_I2C_FLUSH:
825 deb_info("%s: unknown command %d, arg %d\n", __func__,
833 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
835 struct dvb_frontend *fe;
836 struct xc2028_config cfg = {
837 .i2c_adap = &adap->dev->i2c_adap,
840 static struct xc2028_ctrl ctl = {
841 .fname = "/*(DEBLOBBED)*/",
843 .demod = XC3028_FE_ZARLINK456,
846 /* FIXME: generalize & move to common area */
847 adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback;
849 fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg);
850 if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
853 fe->ops.tuner_ops.set_config(fe, &ctl);
858 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
860 dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
861 &adap->dev->i2c_adap, &aver_a868r_tuner);
865 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
867 struct dvb_frontend *fe;
868 fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
869 &adap->dev->i2c_adap, &d680_dmb_tuner);
870 return (fe == NULL) ? -EIO : 0;
873 static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
875 struct dvb_frontend *fe;
876 fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe,
877 &adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
878 return (fe == NULL) ? -EIO : 0;
881 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
884 if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
885 err("set interface failed");
887 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
889 adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
890 &adap->dev->i2c_adap);
891 if ((adap->fe_adap[0].fe) != NULL)
897 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
899 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
900 err("set interface failed");
902 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
904 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
905 &cxusb_lgdt3303_config,
906 &adap->dev->i2c_adap);
907 if ((adap->fe_adap[0].fe) != NULL)
913 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
915 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
916 &adap->dev->i2c_adap);
917 if (adap->fe_adap[0].fe != NULL)
923 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
925 /* used in both lgz201 and th7579 */
926 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
927 err("set interface failed");
929 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
931 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
932 &adap->dev->i2c_adap);
933 if ((adap->fe_adap[0].fe) != NULL)
939 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
941 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
942 err("set interface failed");
944 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
946 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
947 &adap->dev->i2c_adap);
948 if ((adap->fe_adap[0].fe) != NULL)
951 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
952 &cxusb_zl10353_dee1601_config,
953 &adap->dev->i2c_adap);
954 if ((adap->fe_adap[0].fe) != NULL)
960 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
964 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
965 .buf = ircode, .len = 4 };
967 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
968 err("set interface failed");
970 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
972 /* reset the tuner and demodulator */
973 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
974 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
975 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
977 adap->fe_adap[0].fe =
978 dvb_attach(zl10353_attach,
979 &cxusb_zl10353_xc3028_config_no_i2c_gate,
980 &adap->dev->i2c_adap);
981 if ((adap->fe_adap[0].fe) == NULL)
984 /* try to determine if there is no IR decoder on the I2C bus */
985 for (i = 0; adap->dev->props.rc.legacy.rc_map_table != NULL && i < 5; i++) {
987 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
989 if (ircode[0] == 0 && ircode[1] == 0)
991 if (ircode[2] + ircode[3] != 0xff) {
993 adap->dev->props.rc.legacy.rc_map_table = NULL;
994 info("No IR receiver detected on this device.");
1002 static struct dibx000_agc_config dib7070_agc_config = {
1003 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1006 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
1007 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1008 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
1010 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
1011 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1013 .time_stabiliz = 10,
1037 .perform_agc_softsplit = 0,
1040 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1050 .IO_CLK_en_core = 1,
1053 /* refsel, sel, freq_15k */
1054 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1055 .ifreq = (0 << 25) | 0,
1057 .xtal_hz = 12000000,
1060 static struct dib7000p_config cxusb_dualdig4_rev2_config = {
1061 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
1062 .output_mpeg2_in_188_bytes = 1,
1064 .agc_config_count = 1,
1065 .agc = &dib7070_agc_config,
1066 .bw = &dib7070_bw_config_12_mhz,
1067 .tuner_is_baseband = 1,
1073 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1075 .hostbus_diversity = 1,
1078 struct dib0700_adapter_state {
1079 int (*set_param_save)(struct dvb_frontend *);
1080 struct dib7000p_ops dib7000p_ops;
1083 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1085 struct dib0700_adapter_state *state = adap->priv;
1087 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1088 err("set interface failed");
1090 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1092 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1094 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1097 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1098 &cxusb_dualdig4_rev2_config) < 0) {
1099 printk(KERN_WARNING "Unable to enumerate dib7000p\n");
1103 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1104 &cxusb_dualdig4_rev2_config);
1105 if (adap->fe_adap[0].fe == NULL)
1111 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1113 struct dvb_usb_adapter *adap = fe->dvb->priv;
1114 struct dib0700_adapter_state *state = adap->priv;
1116 return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
1119 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1124 static struct dib0070_config dib7070p_dib0070_config = {
1125 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1126 .reset = dib7070_tuner_reset,
1127 .sleep = dib7070_tuner_sleep,
1131 static int dib7070_set_param_override(struct dvb_frontend *fe)
1133 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1134 struct dvb_usb_adapter *adap = fe->dvb->priv;
1135 struct dib0700_adapter_state *state = adap->priv;
1138 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1140 case BAND_VHF: offset = 950; break;
1142 case BAND_UHF: offset = 550; break;
1145 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1147 return state->set_param_save(fe);
1150 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1152 struct dib0700_adapter_state *st = adap->priv;
1153 struct i2c_adapter *tun_i2c;
1156 * No need to call dvb7000p_attach here, as it was called
1157 * already, as frontend_attach method is called first, and
1158 * tuner_attach is only called on sucess.
1160 tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
1161 DIBX000_I2C_INTERFACE_TUNER, 1);
1163 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1164 &dib7070p_dib0070_config) == NULL)
1167 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1168 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1172 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1174 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1175 err("set interface failed");
1177 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1179 /* reset the tuner and demodulator */
1180 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1181 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1182 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1184 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
1185 &cxusb_zl10353_xc3028_config,
1186 &adap->dev->i2c_adap);
1187 if ((adap->fe_adap[0].fe) != NULL)
1190 adap->fe_adap[0].fe = dvb_attach(mt352_attach,
1191 &cxusb_mt352_xc3028_config,
1192 &adap->dev->i2c_adap);
1193 if ((adap->fe_adap[0].fe) != NULL)
1199 static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1200 .prod = LGS8GXX_PROD_LGS8GL5,
1201 .demod_address = 0x19,
1205 .if_clk_freq = 30400, /* 30.4 MHz */
1206 .if_freq = 5725, /* 5.725 MHz */
1213 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1215 struct dvb_usb_device *d = adap->dev;
1218 /* Select required USB configuration */
1219 if (usb_set_interface(d->udev, 0, 0) < 0)
1220 err("set interface failed");
1222 /* Unblock all USB pipes */
1223 usb_clear_halt(d->udev,
1224 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1225 usb_clear_halt(d->udev,
1226 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1227 usb_clear_halt(d->udev,
1228 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1230 /* Drain USB pipes to avoid hang after reboot */
1231 for (n = 0; n < 5; n++) {
1232 cxusb_d680_dmb_drain_message(d);
1233 cxusb_d680_dmb_drain_video(d);
1237 /* Reset the tuner */
1238 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1239 err("clear tuner gpio failed");
1243 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1244 err("set tuner gpio failed");
1249 /* Attach frontend */
1250 adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
1251 if (adap->fe_adap[0].fe == NULL)
1257 static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1258 .prod = ATBM8830_PROD_8830,
1259 .demod_address = 0x40,
1261 .ts_sampling_edge = 1,
1263 .osc_clk_freq = 30400, /* in kHz */
1264 .if_freq = 0, /* zero IF */
1271 static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1273 struct dvb_usb_device *d = adap->dev;
1275 /* Select required USB configuration */
1276 if (usb_set_interface(d->udev, 0, 0) < 0)
1277 err("set interface failed");
1279 /* Unblock all USB pipes */
1280 usb_clear_halt(d->udev,
1281 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1282 usb_clear_halt(d->udev,
1283 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1284 usb_clear_halt(d->udev,
1285 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1288 /* Reset the tuner */
1289 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1290 err("clear tuner gpio failed");
1294 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1295 err("set tuner gpio failed");
1300 /* Attach frontend */
1301 adap->fe_adap[0].fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg,
1303 if (adap->fe_adap[0].fe == NULL)
1309 static int cxusb_mygica_t230_frontend_attach(struct dvb_usb_adapter *adap)
1311 struct dvb_usb_device *d = adap->dev;
1312 struct cxusb_state *st = d->priv;
1313 struct i2c_adapter *adapter;
1314 struct i2c_client *client_demod;
1315 struct i2c_client *client_tuner;
1316 struct i2c_board_info info;
1317 struct si2168_config si2168_config;
1318 struct si2157_config si2157_config;
1320 /* Select required USB configuration */
1321 if (usb_set_interface(d->udev, 0, 0) < 0)
1322 err("set interface failed");
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));
1332 /* attach frontend */
1333 si2168_config.i2c_adapter = &adapter;
1334 si2168_config.fe = &adap->fe_adap[0].fe;
1335 si2168_config.ts_mode = SI2168_TS_PARALLEL;
1336 si2168_config.ts_clock_inv = 1;
1337 memset(&info, 0, sizeof(struct i2c_board_info));
1338 strlcpy(info.type, "si2168", I2C_NAME_SIZE);
1340 info.platform_data = &si2168_config;
1341 request_module(info.type);
1342 client_demod = i2c_new_device(&d->i2c_adap, &info);
1343 if (client_demod == NULL || client_demod->dev.driver == NULL)
1346 if (!try_module_get(client_demod->dev.driver->owner)) {
1347 i2c_unregister_device(client_demod);
1351 st->i2c_client_demod = client_demod;
1354 memset(&si2157_config, 0, sizeof(si2157_config));
1355 si2157_config.fe = adap->fe_adap[0].fe;
1356 si2157_config.if_port = 1;
1357 memset(&info, 0, sizeof(struct i2c_board_info));
1358 strlcpy(info.type, "si2157", I2C_NAME_SIZE);
1360 info.platform_data = &si2157_config;
1361 request_module(info.type);
1362 client_tuner = i2c_new_device(adapter, &info);
1363 if (client_tuner == NULL || client_tuner->dev.driver == NULL) {
1364 module_put(client_demod->dev.driver->owner);
1365 i2c_unregister_device(client_demod);
1368 if (!try_module_get(client_tuner->dev.driver->owner)) {
1369 i2c_unregister_device(client_tuner);
1370 module_put(client_demod->dev.driver->owner);
1371 i2c_unregister_device(client_demod);
1375 st->i2c_client_tuner = client_tuner;
1381 * DViCO has shipped two devices with the same USB ID, but only one of them
1382 * needs a firmware download. Check the device class details to see if they
1383 * have non-default values to decide whether the device is actually cold or
1384 * not, and forget a match if it turns out we selected the wrong device.
1386 static int bluebird_fx2_identify_state(struct usb_device *udev,
1387 struct dvb_usb_device_properties *props,
1388 struct dvb_usb_device_description **desc,
1391 int wascold = *cold;
1393 *cold = udev->descriptor.bDeviceClass == 0xff &&
1394 udev->descriptor.bDeviceSubClass == 0xff &&
1395 udev->descriptor.bDeviceProtocol == 0xff;
1397 if (*cold && !wascold)
1404 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1405 * firmware file before download.
1408 static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1409 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1410 const struct firmware *fw)
1414 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1415 int idoff = dvico_firmware_id_offsets[pos];
1417 if (fw->size < idoff + 4)
1420 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1421 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1422 struct firmware new_fw;
1423 u8 *new_fw_data = vmalloc(fw->size);
1429 memcpy(new_fw_data, fw->data, fw->size);
1430 new_fw.size = fw->size;
1431 new_fw.data = new_fw_data;
1433 new_fw_data[idoff + 2] =
1434 le16_to_cpu(udev->descriptor.idProduct) + 1;
1435 new_fw_data[idoff + 3] =
1436 le16_to_cpu(udev->descriptor.idProduct) >> 8;
1438 ret = usb_cypress_load_firmware(udev, &new_fw,
1448 /* DVB USB Driver stuff */
1449 static struct dvb_usb_device_properties cxusb_medion_properties;
1450 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1451 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1452 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1453 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1454 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1455 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1456 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1457 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1458 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1459 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1460 static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
1461 static struct dvb_usb_device_properties cxusb_mygica_t230_properties;
1463 static int cxusb_probe(struct usb_interface *intf,
1464 const struct usb_device_id *id)
1466 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1467 THIS_MODULE, NULL, adapter_nr) ||
1468 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1469 THIS_MODULE, NULL, adapter_nr) ||
1470 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1471 THIS_MODULE, NULL, adapter_nr) ||
1472 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1473 THIS_MODULE, NULL, adapter_nr) ||
1474 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1475 THIS_MODULE, NULL, adapter_nr) ||
1476 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1477 THIS_MODULE, NULL, adapter_nr) ||
1478 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1479 THIS_MODULE, NULL, adapter_nr) ||
1480 0 == dvb_usb_device_init(intf,
1481 &cxusb_bluebird_nano2_needsfirmware_properties,
1482 THIS_MODULE, NULL, adapter_nr) ||
1483 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1484 THIS_MODULE, NULL, adapter_nr) ||
1485 0 == dvb_usb_device_init(intf,
1486 &cxusb_bluebird_dualdig4_rev2_properties,
1487 THIS_MODULE, NULL, adapter_nr) ||
1488 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1489 THIS_MODULE, NULL, adapter_nr) ||
1490 0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1491 THIS_MODULE, NULL, adapter_nr) ||
1492 0 == dvb_usb_device_init(intf, &cxusb_mygica_t230_properties,
1493 THIS_MODULE, NULL, adapter_nr) ||
1500 static void cxusb_disconnect(struct usb_interface *intf)
1502 struct dvb_usb_device *d = usb_get_intfdata(intf);
1503 struct cxusb_state *st = d->priv;
1504 struct i2c_client *client;
1506 /* remove I2C client for tuner */
1507 client = st->i2c_client_tuner;
1509 module_put(client->dev.driver->owner);
1510 i2c_unregister_device(client);
1513 /* remove I2C client for demodulator */
1514 client = st->i2c_client_demod;
1516 module_put(client->dev.driver->owner);
1517 i2c_unregister_device(client);
1520 dvb_usb_device_exit(intf);
1523 enum cxusb_table_index {
1525 DVICO_BLUEBIRD_LG064F_COLD,
1526 DVICO_BLUEBIRD_LG064F_WARM,
1527 DVICO_BLUEBIRD_DUAL_1_COLD,
1528 DVICO_BLUEBIRD_DUAL_1_WARM,
1529 DVICO_BLUEBIRD_LGZ201_COLD,
1530 DVICO_BLUEBIRD_LGZ201_WARM,
1531 DVICO_BLUEBIRD_TH7579_COLD,
1532 DVICO_BLUEBIRD_TH7579_WARM,
1533 DIGITALNOW_BLUEBIRD_DUAL_1_COLD,
1534 DIGITALNOW_BLUEBIRD_DUAL_1_WARM,
1535 DVICO_BLUEBIRD_DUAL_2_COLD,
1536 DVICO_BLUEBIRD_DUAL_2_WARM,
1537 DVICO_BLUEBIRD_DUAL_4,
1538 DVICO_BLUEBIRD_DVB_T_NANO_2,
1539 DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM,
1540 AVERMEDIA_VOLAR_A868R,
1541 DVICO_BLUEBIRD_DUAL_4_REV_2,
1545 NR__cxusb_table_index
1548 static struct usb_device_id cxusb_table[NR__cxusb_table_index + 1] = {
1549 [MEDION_MD95700] = {
1550 USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700)
1552 [DVICO_BLUEBIRD_LG064F_COLD] = {
1553 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD)
1555 [DVICO_BLUEBIRD_LG064F_WARM] = {
1556 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM)
1558 [DVICO_BLUEBIRD_DUAL_1_COLD] = {
1559 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD)
1561 [DVICO_BLUEBIRD_DUAL_1_WARM] = {
1562 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM)
1564 [DVICO_BLUEBIRD_LGZ201_COLD] = {
1565 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD)
1567 [DVICO_BLUEBIRD_LGZ201_WARM] = {
1568 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM)
1570 [DVICO_BLUEBIRD_TH7579_COLD] = {
1571 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD)
1573 [DVICO_BLUEBIRD_TH7579_WARM] = {
1574 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM)
1576 [DIGITALNOW_BLUEBIRD_DUAL_1_COLD] = {
1577 USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD)
1579 [DIGITALNOW_BLUEBIRD_DUAL_1_WARM] = {
1580 USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM)
1582 [DVICO_BLUEBIRD_DUAL_2_COLD] = {
1583 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD)
1585 [DVICO_BLUEBIRD_DUAL_2_WARM] = {
1586 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM)
1588 [DVICO_BLUEBIRD_DUAL_4] = {
1589 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4)
1591 [DVICO_BLUEBIRD_DVB_T_NANO_2] = {
1592 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2)
1594 [DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM] = {
1595 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM)
1597 [AVERMEDIA_VOLAR_A868R] = {
1598 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R)
1600 [DVICO_BLUEBIRD_DUAL_4_REV_2] = {
1601 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2)
1603 [CONEXANT_D680_DMB] = {
1604 USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB)
1607 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689)
1610 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_T230)
1612 {} /* Terminating entry */
1614 MODULE_DEVICE_TABLE (usb, cxusb_table);
1616 static struct dvb_usb_device_properties cxusb_medion_properties = {
1617 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1619 .usb_ctrl = CYPRESS_FX2,
1621 .size_of_priv = sizeof(struct cxusb_state),
1628 .streaming_ctrl = cxusb_streaming_ctrl,
1629 .frontend_attach = cxusb_cx22702_frontend_attach,
1630 .tuner_attach = cxusb_fmd1216me_tuner_attach,
1631 /* parameter for the MPEG2-data transfer */
1645 .power_ctrl = cxusb_power_ctrl,
1647 .i2c_algo = &cxusb_i2c_algo,
1649 .generic_bulk_ctrl_endpoint = 0x01,
1651 .num_device_descs = 1,
1653 { "Medion MD95700 (MDUSBTV-HYBRID)",
1655 { &cxusb_table[MEDION_MD95700], NULL },
1660 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1661 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1663 .usb_ctrl = DEVICE_SPECIFIC,
1664 .firmware = "/*(DEBLOBBED)*/",
1665 .download_firmware = bluebird_patch_dvico_firmware_download,
1666 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1667 use usb alt setting 7 for EP2 transfer (atsc) */
1669 .size_of_priv = sizeof(struct cxusb_state),
1676 .streaming_ctrl = cxusb_streaming_ctrl,
1677 .frontend_attach = cxusb_lgdt3303_frontend_attach,
1678 .tuner_attach = cxusb_lgh064f_tuner_attach,
1680 /* parameter for the MPEG2-data transfer */
1695 .power_ctrl = cxusb_bluebird_power_ctrl,
1697 .i2c_algo = &cxusb_i2c_algo,
1701 .rc_map_table = rc_map_dvico_portable_table,
1702 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1703 .rc_query = cxusb_rc_query,
1706 .generic_bulk_ctrl_endpoint = 0x01,
1708 .num_device_descs = 1,
1710 { "DViCO FusionHDTV5 USB Gold",
1711 { &cxusb_table[DVICO_BLUEBIRD_LG064F_COLD], NULL },
1712 { &cxusb_table[DVICO_BLUEBIRD_LG064F_WARM], NULL },
1717 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1718 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1720 .usb_ctrl = DEVICE_SPECIFIC,
1721 .firmware = "/*(DEBLOBBED)*/",
1722 .download_firmware = bluebird_patch_dvico_firmware_download,
1723 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1724 use usb alt setting 7 for EP2 transfer (atsc) */
1726 .size_of_priv = sizeof(struct cxusb_state),
1733 .streaming_ctrl = cxusb_streaming_ctrl,
1734 .frontend_attach = cxusb_dee1601_frontend_attach,
1735 .tuner_attach = cxusb_dee1601_tuner_attach,
1736 /* parameter for the MPEG2-data transfer */
1751 .power_ctrl = cxusb_bluebird_power_ctrl,
1753 .i2c_algo = &cxusb_i2c_algo,
1757 .rc_map_table = rc_map_dvico_mce_table,
1758 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
1759 .rc_query = cxusb_rc_query,
1762 .generic_bulk_ctrl_endpoint = 0x01,
1764 .num_device_descs = 3,
1766 { "DViCO FusionHDTV DVB-T Dual USB",
1767 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_COLD], NULL },
1768 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_WARM], NULL },
1770 { "DigitalNow DVB-T Dual USB",
1771 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_COLD], NULL },
1772 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_WARM], NULL },
1774 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1775 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_COLD], NULL },
1776 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_WARM], NULL },
1781 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1782 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1784 .usb_ctrl = DEVICE_SPECIFIC,
1785 .firmware = "/*(DEBLOBBED)*/",
1786 .download_firmware = bluebird_patch_dvico_firmware_download,
1787 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1788 use usb alt setting 7 for EP2 transfer (atsc) */
1790 .size_of_priv = sizeof(struct cxusb_state),
1797 .streaming_ctrl = cxusb_streaming_ctrl,
1798 .frontend_attach = cxusb_mt352_frontend_attach,
1799 .tuner_attach = cxusb_lgz201_tuner_attach,
1801 /* parameter for the MPEG2-data transfer */
1815 .power_ctrl = cxusb_bluebird_power_ctrl,
1817 .i2c_algo = &cxusb_i2c_algo,
1821 .rc_map_table = rc_map_dvico_portable_table,
1822 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1823 .rc_query = cxusb_rc_query,
1826 .generic_bulk_ctrl_endpoint = 0x01,
1827 .num_device_descs = 1,
1829 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1830 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_COLD], NULL },
1831 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_WARM], NULL },
1836 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1837 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1839 .usb_ctrl = DEVICE_SPECIFIC,
1840 .firmware = "/*(DEBLOBBED)*/",
1841 .download_firmware = bluebird_patch_dvico_firmware_download,
1842 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1843 use usb alt setting 7 for EP2 transfer (atsc) */
1845 .size_of_priv = sizeof(struct cxusb_state),
1852 .streaming_ctrl = cxusb_streaming_ctrl,
1853 .frontend_attach = cxusb_mt352_frontend_attach,
1854 .tuner_attach = cxusb_dtt7579_tuner_attach,
1856 /* parameter for the MPEG2-data transfer */
1870 .power_ctrl = cxusb_bluebird_power_ctrl,
1872 .i2c_algo = &cxusb_i2c_algo,
1876 .rc_map_table = rc_map_dvico_portable_table,
1877 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1878 .rc_query = cxusb_rc_query,
1881 .generic_bulk_ctrl_endpoint = 0x01,
1883 .num_device_descs = 1,
1885 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1886 { &cxusb_table[DVICO_BLUEBIRD_TH7579_COLD], NULL },
1887 { &cxusb_table[DVICO_BLUEBIRD_TH7579_WARM], NULL },
1892 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1893 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1895 .usb_ctrl = CYPRESS_FX2,
1897 .size_of_priv = sizeof(struct cxusb_state),
1904 .streaming_ctrl = cxusb_streaming_ctrl,
1905 .frontend_attach = cxusb_dualdig4_frontend_attach,
1906 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1907 /* parameter for the MPEG2-data transfer */
1922 .power_ctrl = cxusb_power_ctrl,
1924 .i2c_algo = &cxusb_i2c_algo,
1926 .generic_bulk_ctrl_endpoint = 0x01,
1930 .rc_map_table = rc_map_dvico_mce_table,
1931 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
1932 .rc_query = cxusb_bluebird2_rc_query,
1935 .num_device_descs = 1,
1937 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1939 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4], NULL },
1944 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1945 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1947 .usb_ctrl = CYPRESS_FX2,
1948 .identify_state = bluebird_fx2_identify_state,
1950 .size_of_priv = sizeof(struct cxusb_state),
1957 .streaming_ctrl = cxusb_streaming_ctrl,
1958 .frontend_attach = cxusb_nano2_frontend_attach,
1959 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1960 /* parameter for the MPEG2-data transfer */
1975 .power_ctrl = cxusb_nano2_power_ctrl,
1977 .i2c_algo = &cxusb_i2c_algo,
1979 .generic_bulk_ctrl_endpoint = 0x01,
1983 .rc_map_table = rc_map_dvico_portable_table,
1984 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1985 .rc_query = cxusb_bluebird2_rc_query,
1988 .num_device_descs = 1,
1990 { "DViCO FusionHDTV DVB-T NANO2",
1992 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
1997 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1998 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2000 .usb_ctrl = DEVICE_SPECIFIC,
2001 .firmware = "/*(DEBLOBBED)*/",
2002 .download_firmware = bluebird_patch_dvico_firmware_download,
2003 .identify_state = bluebird_fx2_identify_state,
2005 .size_of_priv = sizeof(struct cxusb_state),
2012 .streaming_ctrl = cxusb_streaming_ctrl,
2013 .frontend_attach = cxusb_nano2_frontend_attach,
2014 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
2015 /* parameter for the MPEG2-data transfer */
2030 .power_ctrl = cxusb_nano2_power_ctrl,
2032 .i2c_algo = &cxusb_i2c_algo,
2034 .generic_bulk_ctrl_endpoint = 0x01,
2038 .rc_map_table = rc_map_dvico_portable_table,
2039 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
2040 .rc_query = cxusb_rc_query,
2043 .num_device_descs = 1,
2045 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
2046 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
2047 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM], NULL },
2052 static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
2053 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2055 .usb_ctrl = CYPRESS_FX2,
2057 .size_of_priv = sizeof(struct cxusb_state),
2064 .streaming_ctrl = cxusb_aver_streaming_ctrl,
2065 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
2066 .tuner_attach = cxusb_mxl5003s_tuner_attach,
2067 /* parameter for the MPEG2-data transfer */
2081 .power_ctrl = cxusb_aver_power_ctrl,
2083 .i2c_algo = &cxusb_i2c_algo,
2085 .generic_bulk_ctrl_endpoint = 0x01,
2087 .num_device_descs = 1,
2089 { "AVerMedia AVerTVHD Volar (A868R)",
2091 { &cxusb_table[AVERMEDIA_VOLAR_A868R], NULL },
2097 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
2098 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2100 .usb_ctrl = CYPRESS_FX2,
2102 .size_of_priv = sizeof(struct cxusb_state),
2107 .size_of_priv = sizeof(struct dib0700_adapter_state),
2110 .streaming_ctrl = cxusb_streaming_ctrl,
2111 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
2112 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
2113 /* parameter for the MPEG2-data transfer */
2128 .power_ctrl = cxusb_bluebird_power_ctrl,
2130 .i2c_algo = &cxusb_i2c_algo,
2132 .generic_bulk_ctrl_endpoint = 0x01,
2136 .rc_map_table = rc_map_dvico_mce_table,
2137 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
2138 .rc_query = cxusb_rc_query,
2141 .num_device_descs = 1,
2143 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
2145 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4_REV_2], NULL },
2150 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
2151 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2153 .usb_ctrl = CYPRESS_FX2,
2155 .size_of_priv = sizeof(struct cxusb_state),
2162 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2163 .frontend_attach = cxusb_d680_dmb_frontend_attach,
2164 .tuner_attach = cxusb_d680_dmb_tuner_attach,
2166 /* parameter for the MPEG2-data transfer */
2181 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2183 .i2c_algo = &cxusb_i2c_algo,
2185 .generic_bulk_ctrl_endpoint = 0x01,
2189 .rc_map_table = rc_map_d680_dmb_table,
2190 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2191 .rc_query = cxusb_d680_dmb_rc_query,
2194 .num_device_descs = 1,
2197 "Conexant DMB-TH Stick",
2199 { &cxusb_table[CONEXANT_D680_DMB], NULL },
2204 static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
2205 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2207 .usb_ctrl = CYPRESS_FX2,
2209 .size_of_priv = sizeof(struct cxusb_state),
2216 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2217 .frontend_attach = cxusb_mygica_d689_frontend_attach,
2218 .tuner_attach = cxusb_mygica_d689_tuner_attach,
2220 /* parameter for the MPEG2-data transfer */
2235 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2237 .i2c_algo = &cxusb_i2c_algo,
2239 .generic_bulk_ctrl_endpoint = 0x01,
2243 .rc_map_table = rc_map_d680_dmb_table,
2244 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2245 .rc_query = cxusb_d680_dmb_rc_query,
2248 .num_device_descs = 1,
2251 "Mygica D689 DMB-TH",
2253 { &cxusb_table[MYGICA_D689], NULL },
2258 static struct dvb_usb_device_properties cxusb_mygica_t230_properties = {
2259 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2261 .usb_ctrl = CYPRESS_FX2,
2263 .size_of_priv = sizeof(struct cxusb_state),
2270 .streaming_ctrl = cxusb_streaming_ctrl,
2271 .frontend_attach = cxusb_mygica_t230_frontend_attach,
2273 /* parameter for the MPEG2-data transfer */
2288 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2290 .i2c_algo = &cxusb_i2c_algo,
2292 .generic_bulk_ctrl_endpoint = 0x01,
2296 .rc_map_table = rc_map_d680_dmb_table,
2297 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2298 .rc_query = cxusb_d680_dmb_rc_query,
2301 .num_device_descs = 1,
2304 "Mygica T230 DVB-T/T2/C",
2306 { &cxusb_table[MYGICA_T230], NULL },
2311 static struct usb_driver cxusb_driver = {
2312 .name = "dvb_usb_cxusb",
2313 .probe = cxusb_probe,
2314 .disconnect = cxusb_disconnect,
2315 .id_table = cxusb_table,
2318 module_usb_driver(cxusb_driver);
2320 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
2321 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
2322 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
2323 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2324 MODULE_VERSION("1.0-alpha");
2325 MODULE_LICENSE("GPL");