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@posteo.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"
49 static int dvb_usb_cxusb_debug
;
50 module_param_named(debug
, dvb_usb_cxusb_debug
, int, 0644);
51 MODULE_PARM_DESC(debug
, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS
);
53 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
55 #define deb_info(args...) dprintk(dvb_usb_cxusb_debug, 0x03, args)
56 #define deb_i2c(args...) dprintk(dvb_usb_cxusb_debug, 0x02, args)
58 static int cxusb_ctrl_msg(struct dvb_usb_device
*d
,
59 u8 cmd
, u8
*wbuf
, int wlen
, u8
*rbuf
, int rlen
)
61 struct cxusb_state
*st
= d
->priv
;
64 if (1 + wlen
> MAX_XFER_SIZE
) {
65 warn("i2c wr: len=%d is too big!\n", wlen
);
69 if (rlen
> MAX_XFER_SIZE
) {
70 warn("i2c rd: len=%d is too big!\n", rlen
);
74 mutex_lock(&d
->data_mutex
);
76 memcpy(&st
->data
[1], wbuf
, wlen
);
77 ret
= dvb_usb_generic_rw(d
, st
->data
, 1 + wlen
, st
->data
, rlen
, 0);
78 if (!ret
&& rbuf
&& rlen
)
79 memcpy(rbuf
, st
->data
, rlen
);
81 mutex_unlock(&d
->data_mutex
);
86 static void cxusb_gpio_tuner(struct dvb_usb_device
*d
, int onoff
)
88 struct cxusb_state
*st
= d
->priv
;
91 if (st
->gpio_write_state
[GPIO_TUNER
] == onoff
)
96 cxusb_ctrl_msg(d
, CMD_GPIO_WRITE
, o
, 2, &i
, 1);
99 deb_info("gpio_write failed.\n");
101 st
->gpio_write_state
[GPIO_TUNER
] = onoff
;
104 static int cxusb_bluebird_gpio_rw(struct dvb_usb_device
*d
, u8 changemask
,
110 o
[0] = 0xff & ~changemask
; /* mask of bits to keep */
111 o
[1] = newval
& changemask
; /* new values for bits */
113 rc
= cxusb_ctrl_msg(d
, CMD_BLUEBIRD_GPIO_RW
, o
, 2, &gpio_state
, 1);
114 if (rc
< 0 || (gpio_state
& changemask
) != (newval
& changemask
))
115 deb_info("bluebird_gpio_write failed.\n");
117 return rc
< 0 ? rc
: gpio_state
;
120 static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device
*d
, u8 pin
, int low
)
122 cxusb_bluebird_gpio_rw(d
, pin
, low
? 0 : pin
);
124 cxusb_bluebird_gpio_rw(d
, pin
, low
? pin
: 0);
127 static void cxusb_nano2_led(struct dvb_usb_device
*d
, int onoff
)
129 cxusb_bluebird_gpio_rw(d
, 0x40, onoff
? 0 : 0x40);
132 static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device
*d
,
135 u8 o
[2] = {addr
, onoff
};
139 rc
= cxusb_ctrl_msg(d
, CMD_GPIO_WRITE
, o
, 2, &i
, 1);
146 deb_info("gpio_write failed.\n");
152 static int cxusb_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg msg
[],
155 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
159 if (mutex_lock_interruptible(&d
->i2c_mutex
) < 0)
162 for (i
= 0; i
< num
; i
++) {
164 if (le16_to_cpu(d
->udev
->descriptor
.idVendor
) == USB_VID_MEDION
)
165 switch (msg
[i
].addr
) {
167 cxusb_gpio_tuner(d
, 0);
170 cxusb_gpio_tuner(d
, 1);
174 if (msg
[i
].flags
& I2C_M_RD
) {
176 u8 obuf
[3], ibuf
[MAX_XFER_SIZE
];
178 if (1 + msg
[i
].len
> sizeof(ibuf
)) {
179 warn("i2c rd: len=%d is too big!\n",
185 obuf
[1] = msg
[i
].len
;
186 obuf
[2] = msg
[i
].addr
;
187 if (cxusb_ctrl_msg(d
, CMD_I2C_READ
,
189 ibuf
, 1+msg
[i
].len
) < 0) {
190 warn("i2c read failed");
193 memcpy(msg
[i
].buf
, &ibuf
[1], msg
[i
].len
);
194 } else if (i
+1 < num
&& (msg
[i
+1].flags
& I2C_M_RD
) &&
195 msg
[i
].addr
== msg
[i
+1].addr
) {
196 /* write to then read from same address */
197 u8 obuf
[MAX_XFER_SIZE
], ibuf
[MAX_XFER_SIZE
];
199 if (3 + msg
[i
].len
> sizeof(obuf
)) {
200 warn("i2c wr: len=%d is too big!\n",
205 if (1 + msg
[i
+ 1].len
> sizeof(ibuf
)) {
206 warn("i2c rd: len=%d is too big!\n",
211 obuf
[0] = msg
[i
].len
;
212 obuf
[1] = msg
[i
+1].len
;
213 obuf
[2] = msg
[i
].addr
;
214 memcpy(&obuf
[3], msg
[i
].buf
, msg
[i
].len
);
216 if (cxusb_ctrl_msg(d
, CMD_I2C_READ
,
218 ibuf
, 1+msg
[i
+1].len
) < 0)
222 deb_i2c("i2c read may have failed\n");
224 memcpy(msg
[i
+1].buf
, &ibuf
[1], msg
[i
+1].len
);
229 u8 obuf
[MAX_XFER_SIZE
], ibuf
;
231 if (2 + msg
[i
].len
> sizeof(obuf
)) {
232 warn("i2c wr: len=%d is too big!\n",
237 obuf
[0] = msg
[i
].addr
;
238 obuf
[1] = msg
[i
].len
;
239 memcpy(&obuf
[2], msg
[i
].buf
, msg
[i
].len
);
241 if (cxusb_ctrl_msg(d
, CMD_I2C_WRITE
, obuf
,
242 2+msg
[i
].len
, &ibuf
,1) < 0)
245 deb_i2c("i2c write may have failed\n");
255 mutex_unlock(&d
->i2c_mutex
);
259 static u32
cxusb_i2c_func(struct i2c_adapter
*adapter
)
264 static struct i2c_algorithm cxusb_i2c_algo
= {
265 .master_xfer
= cxusb_i2c_xfer
,
266 .functionality
= cxusb_i2c_func
,
269 static int cxusb_power_ctrl(struct dvb_usb_device
*d
, int onoff
)
273 return cxusb_ctrl_msg(d
, CMD_POWER_ON
, &b
, 1, NULL
, 0);
275 return cxusb_ctrl_msg(d
, CMD_POWER_OFF
, &b
, 1, NULL
, 0);
278 static int cxusb_aver_power_ctrl(struct dvb_usb_device
*d
, int onoff
)
282 return cxusb_ctrl_msg(d
, CMD_POWER_OFF
, NULL
, 0, NULL
, 0);
283 if (d
->state
== DVB_USB_STATE_INIT
&&
284 usb_set_interface(d
->udev
, 0, 0) < 0)
285 err("set interface failed");
286 do {} while (!(ret
= cxusb_ctrl_msg(d
, CMD_POWER_ON
, NULL
, 0, NULL
, 0)) &&
287 !(ret
= cxusb_ctrl_msg(d
, 0x15, NULL
, 0, NULL
, 0)) &&
288 !(ret
= cxusb_ctrl_msg(d
, 0x17, NULL
, 0, NULL
, 0)) && 0);
290 /* FIXME: We don't know why, but we need to configure the
291 * lgdt3303 with the register settings below on resume */
294 0x0e, 0x2, 0x00, 0x7f,
295 0x0e, 0x2, 0x02, 0xfe,
296 0x0e, 0x2, 0x02, 0x01,
297 0x0e, 0x2, 0x00, 0x03,
298 0x0e, 0x2, 0x0d, 0x40,
299 0x0e, 0x2, 0x0e, 0x87,
300 0x0e, 0x2, 0x0f, 0x8e,
301 0x0e, 0x2, 0x10, 0x01,
302 0x0e, 0x2, 0x14, 0xd7,
303 0x0e, 0x2, 0x47, 0x88,
306 for (i
= 0; i
< sizeof(bufs
)/sizeof(u8
); i
+= 4/sizeof(u8
)) {
307 ret
= cxusb_ctrl_msg(d
, CMD_I2C_WRITE
,
318 static int cxusb_bluebird_power_ctrl(struct dvb_usb_device
*d
, int onoff
)
322 return cxusb_ctrl_msg(d
, CMD_POWER_ON
, &b
, 1, NULL
, 0);
327 static int cxusb_nano2_power_ctrl(struct dvb_usb_device
*d
, int onoff
)
331 rc
= cxusb_power_ctrl(d
, onoff
);
333 cxusb_nano2_led(d
, 0);
338 static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device
*d
, int onoff
)
342 ret
= cxusb_power_ctrl(d
, onoff
);
347 cxusb_ctrl_msg(d
, CMD_DIGITAL
, NULL
, 0, &b
, 1);
352 static int cxusb_streaming_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
354 u8 buf
[2] = { 0x03, 0x00 };
356 cxusb_ctrl_msg(adap
->dev
, CMD_STREAMING_ON
, buf
, 2, NULL
, 0);
358 cxusb_ctrl_msg(adap
->dev
, CMD_STREAMING_OFF
, NULL
, 0, NULL
, 0);
363 static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
366 cxusb_ctrl_msg(adap
->dev
, CMD_AVER_STREAM_ON
, NULL
, 0, NULL
, 0);
368 cxusb_ctrl_msg(adap
->dev
, CMD_AVER_STREAM_OFF
,
373 static int cxusb_read_status(struct dvb_frontend
*fe
,
374 enum fe_status
*status
)
376 struct dvb_usb_adapter
*adap
= (struct dvb_usb_adapter
*)fe
->dvb
->priv
;
377 struct cxusb_state
*state
= (struct cxusb_state
*)adap
->dev
->priv
;
380 ret
= state
->fe_read_status(fe
, status
);
382 /* it need resync slave fifo when signal change from unlock to lock.*/
383 if ((*status
& FE_HAS_LOCK
) && (!state
->last_lock
)) {
384 mutex_lock(&state
->stream_mutex
);
385 cxusb_streaming_ctrl(adap
, 1);
386 mutex_unlock(&state
->stream_mutex
);
389 state
->last_lock
= (*status
& FE_HAS_LOCK
) ? 1 : 0;
393 static void cxusb_d680_dmb_drain_message(struct dvb_usb_device
*d
)
395 int ep
= d
->props
.generic_bulk_ctrl_endpoint
;
396 const int timeout
= 100;
397 const int junk_len
= 32;
401 /* Discard remaining data in video pipe */
402 junk
= kmalloc(junk_len
, GFP_KERNEL
);
406 if (usb_bulk_msg(d
->udev
,
407 usb_rcvbulkpipe(d
->udev
, ep
),
408 junk
, junk_len
, &rd_count
, timeout
) < 0)
416 static void cxusb_d680_dmb_drain_video(struct dvb_usb_device
*d
)
418 struct usb_data_stream_properties
*p
= &d
->props
.adapter
[0].fe
[0].stream
;
419 const int timeout
= 100;
420 const int junk_len
= p
->u
.bulk
.buffersize
;
424 /* Discard remaining data in video pipe */
425 junk
= kmalloc(junk_len
, GFP_KERNEL
);
429 if (usb_bulk_msg(d
->udev
,
430 usb_rcvbulkpipe(d
->udev
, p
->endpoint
),
431 junk
, junk_len
, &rd_count
, timeout
) < 0)
439 static int cxusb_d680_dmb_streaming_ctrl(
440 struct dvb_usb_adapter
*adap
, int onoff
)
443 u8 buf
[2] = { 0x03, 0x00 };
444 cxusb_d680_dmb_drain_video(adap
->dev
);
445 return cxusb_ctrl_msg(adap
->dev
, CMD_STREAMING_ON
,
446 buf
, sizeof(buf
), NULL
, 0);
448 int ret
= cxusb_ctrl_msg(adap
->dev
,
449 CMD_STREAMING_OFF
, NULL
, 0, NULL
, 0);
454 static int cxusb_rc_query(struct dvb_usb_device
*d
)
458 cxusb_ctrl_msg(d
, CMD_GET_IR_CODE
, NULL
, 0, ircode
, 4);
460 if (ircode
[2] || ircode
[3])
461 rc_keydown(d
->rc_dev
, RC_TYPE_UNKNOWN
,
462 RC_SCANCODE_RC5(ircode
[2], ircode
[3]), 0);
466 static int cxusb_bluebird2_rc_query(struct dvb_usb_device
*d
)
469 struct i2c_msg msg
= { .addr
= 0x6b, .flags
= I2C_M_RD
,
470 .buf
= ircode
, .len
= 4 };
472 if (cxusb_i2c_xfer(&d
->i2c_adap
, &msg
, 1) != 1)
475 if (ircode
[1] || ircode
[2])
476 rc_keydown(d
->rc_dev
, RC_TYPE_UNKNOWN
,
477 RC_SCANCODE_RC5(ircode
[1], ircode
[2]), 0);
481 static int cxusb_d680_dmb_rc_query(struct dvb_usb_device
*d
)
485 if (cxusb_ctrl_msg(d
, 0x10, NULL
, 0, ircode
, 2) < 0)
488 if (ircode
[0] || ircode
[1])
489 rc_keydown(d
->rc_dev
, RC_TYPE_UNKNOWN
,
490 RC_SCANCODE_RC5(ircode
[0], ircode
[1]), 0);
494 static int cxusb_dee1601_demod_init(struct dvb_frontend
* fe
)
496 static u8 clock_config
[] = { CLOCK_CTL
, 0x38, 0x28 };
497 static u8 reset
[] = { RESET
, 0x80 };
498 static u8 adc_ctl_1_cfg
[] = { ADC_CTL_1
, 0x40 };
499 static u8 agc_cfg
[] = { AGC_TARGET
, 0x28, 0x20 };
500 static u8 gpp_ctl_cfg
[] = { GPP_CTL
, 0x33 };
501 static u8 capt_range_cfg
[] = { CAPT_RANGE
, 0x32 };
503 mt352_write(fe
, clock_config
, sizeof(clock_config
));
505 mt352_write(fe
, reset
, sizeof(reset
));
506 mt352_write(fe
, adc_ctl_1_cfg
, sizeof(adc_ctl_1_cfg
));
508 mt352_write(fe
, agc_cfg
, sizeof(agc_cfg
));
509 mt352_write(fe
, gpp_ctl_cfg
, sizeof(gpp_ctl_cfg
));
510 mt352_write(fe
, capt_range_cfg
, sizeof(capt_range_cfg
));
515 static int cxusb_mt352_demod_init(struct dvb_frontend
* fe
)
516 { /* used in both lgz201 and th7579 */
517 static u8 clock_config
[] = { CLOCK_CTL
, 0x38, 0x29 };
518 static u8 reset
[] = { RESET
, 0x80 };
519 static u8 adc_ctl_1_cfg
[] = { ADC_CTL_1
, 0x40 };
520 static u8 agc_cfg
[] = { AGC_TARGET
, 0x24, 0x20 };
521 static u8 gpp_ctl_cfg
[] = { GPP_CTL
, 0x33 };
522 static u8 capt_range_cfg
[] = { CAPT_RANGE
, 0x32 };
524 mt352_write(fe
, clock_config
, sizeof(clock_config
));
526 mt352_write(fe
, reset
, sizeof(reset
));
527 mt352_write(fe
, adc_ctl_1_cfg
, sizeof(adc_ctl_1_cfg
));
529 mt352_write(fe
, agc_cfg
, sizeof(agc_cfg
));
530 mt352_write(fe
, gpp_ctl_cfg
, sizeof(gpp_ctl_cfg
));
531 mt352_write(fe
, capt_range_cfg
, sizeof(capt_range_cfg
));
535 static struct cx22702_config cxusb_cx22702_config
= {
536 .demod_address
= 0x63,
537 .output_mode
= CX22702_PARALLEL_OUTPUT
,
540 static struct lgdt330x_config cxusb_lgdt3303_config
= {
541 .demod_address
= 0x0e,
542 .demod_chip
= LGDT3303
,
545 static struct lgdt330x_config cxusb_aver_lgdt3303_config
= {
546 .demod_address
= 0x0e,
547 .demod_chip
= LGDT3303
,
548 .clock_polarity_flip
= 2,
551 static struct mt352_config cxusb_dee1601_config
= {
552 .demod_address
= 0x0f,
553 .demod_init
= cxusb_dee1601_demod_init
,
556 static struct zl10353_config cxusb_zl10353_dee1601_config
= {
557 .demod_address
= 0x0f,
561 static struct mt352_config cxusb_mt352_config
= {
562 /* used in both lgz201 and th7579 */
563 .demod_address
= 0x0f,
564 .demod_init
= cxusb_mt352_demod_init
,
567 static struct zl10353_config cxusb_zl10353_xc3028_config
= {
568 .demod_address
= 0x0f,
574 static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate
= {
575 .demod_address
= 0x0f,
579 .disable_i2c_gate_ctrl
= 1,
582 static struct mt352_config cxusb_mt352_xc3028_config
= {
583 .demod_address
= 0x0f,
586 .demod_init
= cxusb_mt352_demod_init
,
589 /* FIXME: needs tweaking */
590 static struct mxl5005s_config aver_a868r_tuner
= {
592 .if_freq
= 6000000UL,
593 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
594 .agc_mode
= MXL_SINGLE_AGC
,
595 .tracking_filter
= MXL_TF_C
,
596 .rssi_enable
= MXL_RSSI_ENABLE
,
597 .cap_select
= MXL_CAP_SEL_ENABLE
,
598 .div_out
= MXL_DIV_OUT_4
,
599 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
600 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
601 .top
= MXL5005S_TOP_25P2
,
602 .mod_mode
= MXL_DIGITAL_MODE
,
603 .if_mode
= MXL_ZERO_IF
,
604 .AgcMasterByte
= 0x00,
607 /* FIXME: needs tweaking */
608 static struct mxl5005s_config d680_dmb_tuner
= {
610 .if_freq
= 36125000UL,
611 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
612 .agc_mode
= MXL_SINGLE_AGC
,
613 .tracking_filter
= MXL_TF_C
,
614 .rssi_enable
= MXL_RSSI_ENABLE
,
615 .cap_select
= MXL_CAP_SEL_ENABLE
,
616 .div_out
= MXL_DIV_OUT_4
,
617 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
618 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
619 .top
= MXL5005S_TOP_25P2
,
620 .mod_mode
= MXL_DIGITAL_MODE
,
621 .if_mode
= MXL_ZERO_IF
,
622 .AgcMasterByte
= 0x00,
625 static struct max2165_config mygica_d689_max2165_cfg
= {
630 /* Callbacks for DVB USB */
631 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter
*adap
)
633 dvb_attach(simple_tuner_attach
, adap
->fe_adap
[0].fe
,
634 &adap
->dev
->i2c_adap
, 0x61,
635 TUNER_PHILIPS_FMD1216ME_MK3
);
639 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter
*adap
)
641 dvb_attach(dvb_pll_attach
, adap
->fe_adap
[0].fe
, 0x61,
642 NULL
, DVB_PLL_THOMSON_DTT7579
);
646 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter
*adap
)
648 dvb_attach(dvb_pll_attach
, adap
->fe_adap
[0].fe
, 0x61, NULL
, DVB_PLL_LG_Z201
);
652 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter
*adap
)
654 dvb_attach(dvb_pll_attach
, adap
->fe_adap
[0].fe
, 0x60,
655 NULL
, DVB_PLL_THOMSON_DTT7579
);
659 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter
*adap
)
661 dvb_attach(simple_tuner_attach
, adap
->fe_adap
[0].fe
,
662 &adap
->dev
->i2c_adap
, 0x61, TUNER_LG_TDVS_H06XF
);
666 static int dvico_bluebird_xc2028_callback(void *ptr
, int component
,
667 int command
, int arg
)
669 struct dvb_usb_adapter
*adap
= ptr
;
670 struct dvb_usb_device
*d
= adap
->dev
;
673 case XC2028_TUNER_RESET
:
674 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__
, arg
);
675 cxusb_bluebird_gpio_pulse(d
, 0x01, 1);
677 case XC2028_RESET_CLK
:
678 deb_info("%s: XC2028_RESET_CLK %d\n", __func__
, arg
);
681 deb_info("%s: unknown command %d, arg %d\n", __func__
,
689 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter
*adap
)
691 struct dvb_frontend
*fe
;
692 struct xc2028_config cfg
= {
693 .i2c_adap
= &adap
->dev
->i2c_adap
,
696 static struct xc2028_ctrl ctl
= {
697 .fname
= XC2028_DEFAULT_FIRMWARE
,
699 .demod
= XC3028_FE_ZARLINK456
,
702 /* FIXME: generalize & move to common area */
703 adap
->fe_adap
[0].fe
->callback
= dvico_bluebird_xc2028_callback
;
705 fe
= dvb_attach(xc2028_attach
, adap
->fe_adap
[0].fe
, &cfg
);
706 if (fe
== NULL
|| fe
->ops
.tuner_ops
.set_config
== NULL
)
709 fe
->ops
.tuner_ops
.set_config(fe
, &ctl
);
714 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter
*adap
)
716 dvb_attach(mxl5005s_attach
, adap
->fe_adap
[0].fe
,
717 &adap
->dev
->i2c_adap
, &aver_a868r_tuner
);
721 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter
*adap
)
723 struct dvb_frontend
*fe
;
724 fe
= dvb_attach(mxl5005s_attach
, adap
->fe_adap
[0].fe
,
725 &adap
->dev
->i2c_adap
, &d680_dmb_tuner
);
726 return (fe
== NULL
) ? -EIO
: 0;
729 static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter
*adap
)
731 struct dvb_frontend
*fe
;
732 fe
= dvb_attach(max2165_attach
, adap
->fe_adap
[0].fe
,
733 &adap
->dev
->i2c_adap
, &mygica_d689_max2165_cfg
);
734 return (fe
== NULL
) ? -EIO
: 0;
737 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter
*adap
)
740 if (usb_set_interface(adap
->dev
->udev
, 0, 6) < 0)
741 err("set interface failed");
743 cxusb_ctrl_msg(adap
->dev
, CMD_DIGITAL
, NULL
, 0, &b
, 1);
745 adap
->fe_adap
[0].fe
= dvb_attach(cx22702_attach
, &cxusb_cx22702_config
,
746 &adap
->dev
->i2c_adap
);
747 if ((adap
->fe_adap
[0].fe
) != NULL
)
753 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter
*adap
)
755 if (usb_set_interface(adap
->dev
->udev
, 0, 7) < 0)
756 err("set interface failed");
758 cxusb_ctrl_msg(adap
->dev
, CMD_DIGITAL
, NULL
, 0, NULL
, 0);
760 adap
->fe_adap
[0].fe
= dvb_attach(lgdt330x_attach
,
761 &cxusb_lgdt3303_config
,
762 &adap
->dev
->i2c_adap
);
763 if ((adap
->fe_adap
[0].fe
) != NULL
)
769 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter
*adap
)
771 adap
->fe_adap
[0].fe
= dvb_attach(lgdt330x_attach
, &cxusb_aver_lgdt3303_config
,
772 &adap
->dev
->i2c_adap
);
773 if (adap
->fe_adap
[0].fe
!= NULL
)
779 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter
*adap
)
781 /* used in both lgz201 and th7579 */
782 if (usb_set_interface(adap
->dev
->udev
, 0, 0) < 0)
783 err("set interface failed");
785 cxusb_ctrl_msg(adap
->dev
, CMD_DIGITAL
, NULL
, 0, NULL
, 0);
787 adap
->fe_adap
[0].fe
= dvb_attach(mt352_attach
, &cxusb_mt352_config
,
788 &adap
->dev
->i2c_adap
);
789 if ((adap
->fe_adap
[0].fe
) != NULL
)
795 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter
*adap
)
797 if (usb_set_interface(adap
->dev
->udev
, 0, 0) < 0)
798 err("set interface failed");
800 cxusb_ctrl_msg(adap
->dev
, CMD_DIGITAL
, NULL
, 0, NULL
, 0);
802 adap
->fe_adap
[0].fe
= dvb_attach(mt352_attach
, &cxusb_dee1601_config
,
803 &adap
->dev
->i2c_adap
);
804 if ((adap
->fe_adap
[0].fe
) != NULL
)
807 adap
->fe_adap
[0].fe
= dvb_attach(zl10353_attach
,
808 &cxusb_zl10353_dee1601_config
,
809 &adap
->dev
->i2c_adap
);
810 if ((adap
->fe_adap
[0].fe
) != NULL
)
816 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter
*adap
)
820 struct i2c_msg msg
= { .addr
= 0x6b, .flags
= I2C_M_RD
,
821 .buf
= ircode
, .len
= 4 };
823 if (usb_set_interface(adap
->dev
->udev
, 0, 1) < 0)
824 err("set interface failed");
826 cxusb_ctrl_msg(adap
->dev
, CMD_DIGITAL
, NULL
, 0, NULL
, 0);
828 /* reset the tuner and demodulator */
829 cxusb_bluebird_gpio_rw(adap
->dev
, 0x04, 0);
830 cxusb_bluebird_gpio_pulse(adap
->dev
, 0x01, 1);
831 cxusb_bluebird_gpio_pulse(adap
->dev
, 0x02, 1);
833 adap
->fe_adap
[0].fe
=
834 dvb_attach(zl10353_attach
,
835 &cxusb_zl10353_xc3028_config_no_i2c_gate
,
836 &adap
->dev
->i2c_adap
);
837 if ((adap
->fe_adap
[0].fe
) == NULL
)
840 /* try to determine if there is no IR decoder on the I2C bus */
841 for (i
= 0; adap
->dev
->props
.rc
.core
.rc_codes
&& i
< 5; i
++) {
843 if (cxusb_i2c_xfer(&adap
->dev
->i2c_adap
, &msg
, 1) != 1)
845 if (ircode
[0] == 0 && ircode
[1] == 0)
847 if (ircode
[2] + ircode
[3] != 0xff) {
849 adap
->dev
->props
.rc
.core
.rc_codes
= NULL
;
850 info("No IR receiver detected on this device.");
858 static struct dibx000_agc_config dib7070_agc_config
= {
859 .band_caps
= BAND_UHF
| BAND_VHF
| BAND_LBAND
| BAND_SBAND
,
862 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
863 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
864 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
866 .setup
= (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
867 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
893 .perform_agc_softsplit
= 0,
896 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz
= {
909 /* refsel, sel, freq_15k */
910 .sad_cfg
= (3 << 14) | (1 << 12) | (524 << 0),
911 .ifreq
= (0 << 25) | 0,
916 static struct dib7000p_config cxusb_dualdig4_rev2_config
= {
917 .output_mode
= OUTMODE_MPEG2_PAR_GATED_CLK
,
918 .output_mpeg2_in_188_bytes
= 1,
920 .agc_config_count
= 1,
921 .agc
= &dib7070_agc_config
,
922 .bw
= &dib7070_bw_config_12_mhz
,
923 .tuner_is_baseband
= 1,
929 .gpio_pwm_pos
= DIB7000P_GPIO_DEFAULT_PWM_POS
,
931 .hostbus_diversity
= 1,
934 struct dib0700_adapter_state
{
935 int (*set_param_save
)(struct dvb_frontend
*);
936 struct dib7000p_ops dib7000p_ops
;
939 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter
*adap
)
941 struct dib0700_adapter_state
*state
= adap
->priv
;
943 if (usb_set_interface(adap
->dev
->udev
, 0, 1) < 0)
944 err("set interface failed");
946 cxusb_ctrl_msg(adap
->dev
, CMD_DIGITAL
, NULL
, 0, NULL
, 0);
948 cxusb_bluebird_gpio_pulse(adap
->dev
, 0x02, 1);
950 if (!dvb_attach(dib7000p_attach
, &state
->dib7000p_ops
))
953 if (state
->dib7000p_ops
.i2c_enumeration(&adap
->dev
->i2c_adap
, 1, 18,
954 &cxusb_dualdig4_rev2_config
) < 0) {
955 printk(KERN_WARNING
"Unable to enumerate dib7000p\n");
959 adap
->fe_adap
[0].fe
= state
->dib7000p_ops
.init(&adap
->dev
->i2c_adap
, 0x80,
960 &cxusb_dualdig4_rev2_config
);
961 if (adap
->fe_adap
[0].fe
== NULL
)
967 static int dib7070_tuner_reset(struct dvb_frontend
*fe
, int onoff
)
969 struct dvb_usb_adapter
*adap
= fe
->dvb
->priv
;
970 struct dib0700_adapter_state
*state
= adap
->priv
;
972 return state
->dib7000p_ops
.set_gpio(fe
, 8, 0, !onoff
);
975 static int dib7070_tuner_sleep(struct dvb_frontend
*fe
, int onoff
)
980 static struct dib0070_config dib7070p_dib0070_config
= {
981 .i2c_address
= DEFAULT_DIB0070_I2C_ADDRESS
,
982 .reset
= dib7070_tuner_reset
,
983 .sleep
= dib7070_tuner_sleep
,
987 static int dib7070_set_param_override(struct dvb_frontend
*fe
)
989 struct dtv_frontend_properties
*p
= &fe
->dtv_property_cache
;
990 struct dvb_usb_adapter
*adap
= fe
->dvb
->priv
;
991 struct dib0700_adapter_state
*state
= adap
->priv
;
994 u8 band
= BAND_OF_FREQUENCY(p
->frequency
/1000);
996 case BAND_VHF
: offset
= 950; break;
998 case BAND_UHF
: offset
= 550; break;
1001 state
->dib7000p_ops
.set_wbd_ref(fe
, offset
+ dib0070_wbd_offset(fe
));
1003 return state
->set_param_save(fe
);
1006 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter
*adap
)
1008 struct dib0700_adapter_state
*st
= adap
->priv
;
1009 struct i2c_adapter
*tun_i2c
;
1012 * No need to call dvb7000p_attach here, as it was called
1013 * already, as frontend_attach method is called first, and
1014 * tuner_attach is only called on sucess.
1016 tun_i2c
= st
->dib7000p_ops
.get_i2c_master(adap
->fe_adap
[0].fe
,
1017 DIBX000_I2C_INTERFACE_TUNER
, 1);
1019 if (dvb_attach(dib0070_attach
, adap
->fe_adap
[0].fe
, tun_i2c
,
1020 &dib7070p_dib0070_config
) == NULL
)
1023 st
->set_param_save
= adap
->fe_adap
[0].fe
->ops
.tuner_ops
.set_params
;
1024 adap
->fe_adap
[0].fe
->ops
.tuner_ops
.set_params
= dib7070_set_param_override
;
1028 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter
*adap
)
1030 if (usb_set_interface(adap
->dev
->udev
, 0, 1) < 0)
1031 err("set interface failed");
1033 cxusb_ctrl_msg(adap
->dev
, CMD_DIGITAL
, NULL
, 0, NULL
, 0);
1035 /* reset the tuner and demodulator */
1036 cxusb_bluebird_gpio_rw(adap
->dev
, 0x04, 0);
1037 cxusb_bluebird_gpio_pulse(adap
->dev
, 0x01, 1);
1038 cxusb_bluebird_gpio_pulse(adap
->dev
, 0x02, 1);
1040 adap
->fe_adap
[0].fe
= dvb_attach(zl10353_attach
,
1041 &cxusb_zl10353_xc3028_config
,
1042 &adap
->dev
->i2c_adap
);
1043 if ((adap
->fe_adap
[0].fe
) != NULL
)
1046 adap
->fe_adap
[0].fe
= dvb_attach(mt352_attach
,
1047 &cxusb_mt352_xc3028_config
,
1048 &adap
->dev
->i2c_adap
);
1049 if ((adap
->fe_adap
[0].fe
) != NULL
)
1055 static struct lgs8gxx_config d680_lgs8gl5_cfg
= {
1056 .prod
= LGS8GXX_PROD_LGS8GL5
,
1057 .demod_address
= 0x19,
1061 .if_clk_freq
= 30400, /* 30.4 MHz */
1062 .if_freq
= 5725, /* 5.725 MHz */
1069 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter
*adap
)
1071 struct dvb_usb_device
*d
= adap
->dev
;
1074 /* Select required USB configuration */
1075 if (usb_set_interface(d
->udev
, 0, 0) < 0)
1076 err("set interface failed");
1078 /* Unblock all USB pipes */
1079 usb_clear_halt(d
->udev
,
1080 usb_sndbulkpipe(d
->udev
, d
->props
.generic_bulk_ctrl_endpoint
));
1081 usb_clear_halt(d
->udev
,
1082 usb_rcvbulkpipe(d
->udev
, d
->props
.generic_bulk_ctrl_endpoint
));
1083 usb_clear_halt(d
->udev
,
1084 usb_rcvbulkpipe(d
->udev
, d
->props
.adapter
[0].fe
[0].stream
.endpoint
));
1086 /* Drain USB pipes to avoid hang after reboot */
1087 for (n
= 0; n
< 5; n
++) {
1088 cxusb_d680_dmb_drain_message(d
);
1089 cxusb_d680_dmb_drain_video(d
);
1093 /* Reset the tuner */
1094 if (cxusb_d680_dmb_gpio_tuner(d
, 0x07, 0) < 0) {
1095 err("clear tuner gpio failed");
1099 if (cxusb_d680_dmb_gpio_tuner(d
, 0x07, 1) < 0) {
1100 err("set tuner gpio failed");
1105 /* Attach frontend */
1106 adap
->fe_adap
[0].fe
= dvb_attach(lgs8gxx_attach
, &d680_lgs8gl5_cfg
, &d
->i2c_adap
);
1107 if (adap
->fe_adap
[0].fe
== NULL
)
1113 static struct atbm8830_config mygica_d689_atbm8830_cfg
= {
1114 .prod
= ATBM8830_PROD_8830
,
1115 .demod_address
= 0x40,
1117 .ts_sampling_edge
= 1,
1119 .osc_clk_freq
= 30400, /* in kHz */
1120 .if_freq
= 0, /* zero IF */
1127 static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter
*adap
)
1129 struct dvb_usb_device
*d
= adap
->dev
;
1131 /* Select required USB configuration */
1132 if (usb_set_interface(d
->udev
, 0, 0) < 0)
1133 err("set interface failed");
1135 /* Unblock all USB pipes */
1136 usb_clear_halt(d
->udev
,
1137 usb_sndbulkpipe(d
->udev
, d
->props
.generic_bulk_ctrl_endpoint
));
1138 usb_clear_halt(d
->udev
,
1139 usb_rcvbulkpipe(d
->udev
, d
->props
.generic_bulk_ctrl_endpoint
));
1140 usb_clear_halt(d
->udev
,
1141 usb_rcvbulkpipe(d
->udev
, d
->props
.adapter
[0].fe
[0].stream
.endpoint
));
1144 /* Reset the tuner */
1145 if (cxusb_d680_dmb_gpio_tuner(d
, 0x07, 0) < 0) {
1146 err("clear tuner gpio failed");
1150 if (cxusb_d680_dmb_gpio_tuner(d
, 0x07, 1) < 0) {
1151 err("set tuner gpio failed");
1156 /* Attach frontend */
1157 adap
->fe_adap
[0].fe
= dvb_attach(atbm8830_attach
, &mygica_d689_atbm8830_cfg
,
1159 if (adap
->fe_adap
[0].fe
== NULL
)
1165 static int cxusb_mygica_t230_frontend_attach(struct dvb_usb_adapter
*adap
)
1167 struct dvb_usb_device
*d
= adap
->dev
;
1168 struct cxusb_state
*st
= d
->priv
;
1169 struct i2c_adapter
*adapter
;
1170 struct i2c_client
*client_demod
;
1171 struct i2c_client
*client_tuner
;
1172 struct i2c_board_info info
;
1173 struct si2168_config si2168_config
;
1174 struct si2157_config si2157_config
;
1176 /* Select required USB configuration */
1177 if (usb_set_interface(d
->udev
, 0, 0) < 0)
1178 err("set interface failed");
1180 /* Unblock all USB pipes */
1181 usb_clear_halt(d
->udev
,
1182 usb_sndbulkpipe(d
->udev
, d
->props
.generic_bulk_ctrl_endpoint
));
1183 usb_clear_halt(d
->udev
,
1184 usb_rcvbulkpipe(d
->udev
, d
->props
.generic_bulk_ctrl_endpoint
));
1185 usb_clear_halt(d
->udev
,
1186 usb_rcvbulkpipe(d
->udev
, d
->props
.adapter
[0].fe
[0].stream
.endpoint
));
1188 /* attach frontend */
1189 si2168_config
.i2c_adapter
= &adapter
;
1190 si2168_config
.fe
= &adap
->fe_adap
[0].fe
;
1191 si2168_config
.ts_mode
= SI2168_TS_PARALLEL
;
1192 si2168_config
.ts_clock_inv
= 1;
1193 memset(&info
, 0, sizeof(struct i2c_board_info
));
1194 strlcpy(info
.type
, "si2168", I2C_NAME_SIZE
);
1196 info
.platform_data
= &si2168_config
;
1197 request_module(info
.type
);
1198 client_demod
= i2c_new_device(&d
->i2c_adap
, &info
);
1199 if (client_demod
== NULL
|| client_demod
->dev
.driver
== NULL
)
1202 if (!try_module_get(client_demod
->dev
.driver
->owner
)) {
1203 i2c_unregister_device(client_demod
);
1207 st
->i2c_client_demod
= client_demod
;
1210 memset(&si2157_config
, 0, sizeof(si2157_config
));
1211 si2157_config
.fe
= adap
->fe_adap
[0].fe
;
1212 si2157_config
.if_port
= 1;
1213 memset(&info
, 0, sizeof(struct i2c_board_info
));
1214 strlcpy(info
.type
, "si2157", I2C_NAME_SIZE
);
1216 info
.platform_data
= &si2157_config
;
1217 request_module(info
.type
);
1218 client_tuner
= i2c_new_device(adapter
, &info
);
1219 if (client_tuner
== NULL
|| client_tuner
->dev
.driver
== NULL
) {
1220 module_put(client_demod
->dev
.driver
->owner
);
1221 i2c_unregister_device(client_demod
);
1224 if (!try_module_get(client_tuner
->dev
.driver
->owner
)) {
1225 i2c_unregister_device(client_tuner
);
1226 module_put(client_demod
->dev
.driver
->owner
);
1227 i2c_unregister_device(client_demod
);
1231 st
->i2c_client_tuner
= client_tuner
;
1233 /* hook fe: need to resync the slave fifo when signal locks. */
1234 mutex_init(&st
->stream_mutex
);
1236 st
->fe_read_status
= adap
->fe_adap
[0].fe
->ops
.read_status
;
1237 adap
->fe_adap
[0].fe
->ops
.read_status
= cxusb_read_status
;
1243 * DViCO has shipped two devices with the same USB ID, but only one of them
1244 * needs a firmware download. Check the device class details to see if they
1245 * have non-default values to decide whether the device is actually cold or
1246 * not, and forget a match if it turns out we selected the wrong device.
1248 static int bluebird_fx2_identify_state(struct usb_device
*udev
,
1249 struct dvb_usb_device_properties
*props
,
1250 struct dvb_usb_device_description
**desc
,
1253 int wascold
= *cold
;
1255 *cold
= udev
->descriptor
.bDeviceClass
== 0xff &&
1256 udev
->descriptor
.bDeviceSubClass
== 0xff &&
1257 udev
->descriptor
.bDeviceProtocol
== 0xff;
1259 if (*cold
&& !wascold
)
1266 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1267 * firmware file before download.
1270 static const int dvico_firmware_id_offsets
[] = { 6638, 3204 };
1271 static int bluebird_patch_dvico_firmware_download(struct usb_device
*udev
,
1272 const struct firmware
*fw
)
1276 for (pos
= 0; pos
< ARRAY_SIZE(dvico_firmware_id_offsets
); pos
++) {
1277 int idoff
= dvico_firmware_id_offsets
[pos
];
1279 if (fw
->size
< idoff
+ 4)
1282 if (fw
->data
[idoff
] == (USB_VID_DVICO
& 0xff) &&
1283 fw
->data
[idoff
+ 1] == USB_VID_DVICO
>> 8) {
1284 struct firmware new_fw
;
1285 u8
*new_fw_data
= vmalloc(fw
->size
);
1291 memcpy(new_fw_data
, fw
->data
, fw
->size
);
1292 new_fw
.size
= fw
->size
;
1293 new_fw
.data
= new_fw_data
;
1295 new_fw_data
[idoff
+ 2] =
1296 le16_to_cpu(udev
->descriptor
.idProduct
) + 1;
1297 new_fw_data
[idoff
+ 3] =
1298 le16_to_cpu(udev
->descriptor
.idProduct
) >> 8;
1300 ret
= usb_cypress_load_firmware(udev
, &new_fw
,
1310 /* DVB USB Driver stuff */
1311 static struct dvb_usb_device_properties cxusb_medion_properties
;
1312 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties
;
1313 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties
;
1314 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties
;
1315 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties
;
1316 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties
;
1317 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties
;
1318 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties
;
1319 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties
;
1320 static struct dvb_usb_device_properties cxusb_aver_a868r_properties
;
1321 static struct dvb_usb_device_properties cxusb_d680_dmb_properties
;
1322 static struct dvb_usb_device_properties cxusb_mygica_d689_properties
;
1323 static struct dvb_usb_device_properties cxusb_mygica_t230_properties
;
1325 static int cxusb_probe(struct usb_interface
*intf
,
1326 const struct usb_device_id
*id
)
1328 if (0 == dvb_usb_device_init(intf
, &cxusb_medion_properties
,
1329 THIS_MODULE
, NULL
, adapter_nr
) ||
1330 0 == dvb_usb_device_init(intf
, &cxusb_bluebird_lgh064f_properties
,
1331 THIS_MODULE
, NULL
, adapter_nr
) ||
1332 0 == dvb_usb_device_init(intf
, &cxusb_bluebird_dee1601_properties
,
1333 THIS_MODULE
, NULL
, adapter_nr
) ||
1334 0 == dvb_usb_device_init(intf
, &cxusb_bluebird_lgz201_properties
,
1335 THIS_MODULE
, NULL
, adapter_nr
) ||
1336 0 == dvb_usb_device_init(intf
, &cxusb_bluebird_dtt7579_properties
,
1337 THIS_MODULE
, NULL
, adapter_nr
) ||
1338 0 == dvb_usb_device_init(intf
, &cxusb_bluebird_dualdig4_properties
,
1339 THIS_MODULE
, NULL
, adapter_nr
) ||
1340 0 == dvb_usb_device_init(intf
, &cxusb_bluebird_nano2_properties
,
1341 THIS_MODULE
, NULL
, adapter_nr
) ||
1342 0 == dvb_usb_device_init(intf
,
1343 &cxusb_bluebird_nano2_needsfirmware_properties
,
1344 THIS_MODULE
, NULL
, adapter_nr
) ||
1345 0 == dvb_usb_device_init(intf
, &cxusb_aver_a868r_properties
,
1346 THIS_MODULE
, NULL
, adapter_nr
) ||
1347 0 == dvb_usb_device_init(intf
,
1348 &cxusb_bluebird_dualdig4_rev2_properties
,
1349 THIS_MODULE
, NULL
, adapter_nr
) ||
1350 0 == dvb_usb_device_init(intf
, &cxusb_d680_dmb_properties
,
1351 THIS_MODULE
, NULL
, adapter_nr
) ||
1352 0 == dvb_usb_device_init(intf
, &cxusb_mygica_d689_properties
,
1353 THIS_MODULE
, NULL
, adapter_nr
) ||
1354 0 == dvb_usb_device_init(intf
, &cxusb_mygica_t230_properties
,
1355 THIS_MODULE
, NULL
, adapter_nr
) ||
1362 static void cxusb_disconnect(struct usb_interface
*intf
)
1364 struct dvb_usb_device
*d
= usb_get_intfdata(intf
);
1365 struct cxusb_state
*st
= d
->priv
;
1366 struct i2c_client
*client
;
1368 /* remove I2C client for tuner */
1369 client
= st
->i2c_client_tuner
;
1371 module_put(client
->dev
.driver
->owner
);
1372 i2c_unregister_device(client
);
1375 /* remove I2C client for demodulator */
1376 client
= st
->i2c_client_demod
;
1378 module_put(client
->dev
.driver
->owner
);
1379 i2c_unregister_device(client
);
1382 dvb_usb_device_exit(intf
);
1385 enum cxusb_table_index
{
1387 DVICO_BLUEBIRD_LG064F_COLD
,
1388 DVICO_BLUEBIRD_LG064F_WARM
,
1389 DVICO_BLUEBIRD_DUAL_1_COLD
,
1390 DVICO_BLUEBIRD_DUAL_1_WARM
,
1391 DVICO_BLUEBIRD_LGZ201_COLD
,
1392 DVICO_BLUEBIRD_LGZ201_WARM
,
1393 DVICO_BLUEBIRD_TH7579_COLD
,
1394 DVICO_BLUEBIRD_TH7579_WARM
,
1395 DIGITALNOW_BLUEBIRD_DUAL_1_COLD
,
1396 DIGITALNOW_BLUEBIRD_DUAL_1_WARM
,
1397 DVICO_BLUEBIRD_DUAL_2_COLD
,
1398 DVICO_BLUEBIRD_DUAL_2_WARM
,
1399 DVICO_BLUEBIRD_DUAL_4
,
1400 DVICO_BLUEBIRD_DVB_T_NANO_2
,
1401 DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM
,
1402 AVERMEDIA_VOLAR_A868R
,
1403 DVICO_BLUEBIRD_DUAL_4_REV_2
,
1407 NR__cxusb_table_index
1410 static struct usb_device_id cxusb_table
[NR__cxusb_table_index
+ 1] = {
1411 [MEDION_MD95700
] = {
1412 USB_DEVICE(USB_VID_MEDION
, USB_PID_MEDION_MD95700
)
1414 [DVICO_BLUEBIRD_LG064F_COLD
] = {
1415 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_LG064F_COLD
)
1417 [DVICO_BLUEBIRD_LG064F_WARM
] = {
1418 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_LG064F_WARM
)
1420 [DVICO_BLUEBIRD_DUAL_1_COLD
] = {
1421 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD
)
1423 [DVICO_BLUEBIRD_DUAL_1_WARM
] = {
1424 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM
)
1426 [DVICO_BLUEBIRD_LGZ201_COLD
] = {
1427 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD
)
1429 [DVICO_BLUEBIRD_LGZ201_WARM
] = {
1430 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM
)
1432 [DVICO_BLUEBIRD_TH7579_COLD
] = {
1433 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_TH7579_COLD
)
1435 [DVICO_BLUEBIRD_TH7579_WARM
] = {
1436 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_TH7579_WARM
)
1438 [DIGITALNOW_BLUEBIRD_DUAL_1_COLD
] = {
1439 USB_DEVICE(USB_VID_DVICO
, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD
)
1441 [DIGITALNOW_BLUEBIRD_DUAL_1_WARM
] = {
1442 USB_DEVICE(USB_VID_DVICO
, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM
)
1444 [DVICO_BLUEBIRD_DUAL_2_COLD
] = {
1445 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD
)
1447 [DVICO_BLUEBIRD_DUAL_2_WARM
] = {
1448 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM
)
1450 [DVICO_BLUEBIRD_DUAL_4
] = {
1451 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DUAL_4
)
1453 [DVICO_BLUEBIRD_DVB_T_NANO_2
] = {
1454 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2
)
1456 [DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM
] = {
1457 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM
)
1459 [AVERMEDIA_VOLAR_A868R
] = {
1460 USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_VOLAR_A868R
)
1462 [DVICO_BLUEBIRD_DUAL_4_REV_2
] = {
1463 USB_DEVICE(USB_VID_DVICO
, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2
)
1465 [CONEXANT_D680_DMB
] = {
1466 USB_DEVICE(USB_VID_CONEXANT
, USB_PID_CONEXANT_D680_DMB
)
1469 USB_DEVICE(USB_VID_CONEXANT
, USB_PID_MYGICA_D689
)
1472 USB_DEVICE(USB_VID_CONEXANT
, USB_PID_MYGICA_T230
)
1474 {} /* Terminating entry */
1476 MODULE_DEVICE_TABLE (usb
, cxusb_table
);
1478 static struct dvb_usb_device_properties cxusb_medion_properties
= {
1479 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1481 .usb_ctrl
= CYPRESS_FX2
,
1483 .size_of_priv
= sizeof(struct cxusb_state
),
1490 .streaming_ctrl
= cxusb_streaming_ctrl
,
1491 .frontend_attach
= cxusb_cx22702_frontend_attach
,
1492 .tuner_attach
= cxusb_fmd1216me_tuner_attach
,
1493 /* parameter for the MPEG2-data transfer */
1507 .power_ctrl
= cxusb_power_ctrl
,
1509 .i2c_algo
= &cxusb_i2c_algo
,
1511 .generic_bulk_ctrl_endpoint
= 0x01,
1513 .num_device_descs
= 1,
1515 { "Medion MD95700 (MDUSBTV-HYBRID)",
1517 { &cxusb_table
[MEDION_MD95700
], NULL
},
1522 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties
= {
1523 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1525 .usb_ctrl
= DEVICE_SPECIFIC
,
1526 .firmware
= "dvb-usb-bluebird-01.fw",
1527 .download_firmware
= bluebird_patch_dvico_firmware_download
,
1528 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1529 use usb alt setting 7 for EP2 transfer (atsc) */
1531 .size_of_priv
= sizeof(struct cxusb_state
),
1538 .streaming_ctrl
= cxusb_streaming_ctrl
,
1539 .frontend_attach
= cxusb_lgdt3303_frontend_attach
,
1540 .tuner_attach
= cxusb_lgh064f_tuner_attach
,
1542 /* parameter for the MPEG2-data transfer */
1557 .power_ctrl
= cxusb_bluebird_power_ctrl
,
1559 .i2c_algo
= &cxusb_i2c_algo
,
1563 .rc_codes
= RC_MAP_DVICO_PORTABLE
,
1564 .module_name
= KBUILD_MODNAME
,
1565 .rc_query
= cxusb_rc_query
,
1566 .allowed_protos
= RC_BIT_UNKNOWN
,
1569 .generic_bulk_ctrl_endpoint
= 0x01,
1571 .num_device_descs
= 1,
1573 { "DViCO FusionHDTV5 USB Gold",
1574 { &cxusb_table
[DVICO_BLUEBIRD_LG064F_COLD
], NULL
},
1575 { &cxusb_table
[DVICO_BLUEBIRD_LG064F_WARM
], NULL
},
1580 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties
= {
1581 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1583 .usb_ctrl
= DEVICE_SPECIFIC
,
1584 .firmware
= "dvb-usb-bluebird-01.fw",
1585 .download_firmware
= bluebird_patch_dvico_firmware_download
,
1586 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1587 use usb alt setting 7 for EP2 transfer (atsc) */
1589 .size_of_priv
= sizeof(struct cxusb_state
),
1596 .streaming_ctrl
= cxusb_streaming_ctrl
,
1597 .frontend_attach
= cxusb_dee1601_frontend_attach
,
1598 .tuner_attach
= cxusb_dee1601_tuner_attach
,
1599 /* parameter for the MPEG2-data transfer */
1614 .power_ctrl
= cxusb_bluebird_power_ctrl
,
1616 .i2c_algo
= &cxusb_i2c_algo
,
1620 .rc_codes
= RC_MAP_DVICO_MCE
,
1621 .module_name
= KBUILD_MODNAME
,
1622 .rc_query
= cxusb_rc_query
,
1623 .allowed_protos
= RC_BIT_UNKNOWN
,
1626 .generic_bulk_ctrl_endpoint
= 0x01,
1628 .num_device_descs
= 3,
1630 { "DViCO FusionHDTV DVB-T Dual USB",
1631 { &cxusb_table
[DVICO_BLUEBIRD_DUAL_1_COLD
], NULL
},
1632 { &cxusb_table
[DVICO_BLUEBIRD_DUAL_1_WARM
], NULL
},
1634 { "DigitalNow DVB-T Dual USB",
1635 { &cxusb_table
[DIGITALNOW_BLUEBIRD_DUAL_1_COLD
], NULL
},
1636 { &cxusb_table
[DIGITALNOW_BLUEBIRD_DUAL_1_WARM
], NULL
},
1638 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1639 { &cxusb_table
[DVICO_BLUEBIRD_DUAL_2_COLD
], NULL
},
1640 { &cxusb_table
[DVICO_BLUEBIRD_DUAL_2_WARM
], NULL
},
1645 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties
= {
1646 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1648 .usb_ctrl
= DEVICE_SPECIFIC
,
1649 .firmware
= "dvb-usb-bluebird-01.fw",
1650 .download_firmware
= bluebird_patch_dvico_firmware_download
,
1651 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1652 use usb alt setting 7 for EP2 transfer (atsc) */
1654 .size_of_priv
= sizeof(struct cxusb_state
),
1661 .streaming_ctrl
= cxusb_streaming_ctrl
,
1662 .frontend_attach
= cxusb_mt352_frontend_attach
,
1663 .tuner_attach
= cxusb_lgz201_tuner_attach
,
1665 /* parameter for the MPEG2-data transfer */
1679 .power_ctrl
= cxusb_bluebird_power_ctrl
,
1681 .i2c_algo
= &cxusb_i2c_algo
,
1685 .rc_codes
= RC_MAP_DVICO_PORTABLE
,
1686 .module_name
= KBUILD_MODNAME
,
1687 .rc_query
= cxusb_rc_query
,
1688 .allowed_protos
= RC_BIT_UNKNOWN
,
1691 .generic_bulk_ctrl_endpoint
= 0x01,
1692 .num_device_descs
= 1,
1694 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1695 { &cxusb_table
[DVICO_BLUEBIRD_LGZ201_COLD
], NULL
},
1696 { &cxusb_table
[DVICO_BLUEBIRD_LGZ201_WARM
], NULL
},
1701 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties
= {
1702 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1704 .usb_ctrl
= DEVICE_SPECIFIC
,
1705 .firmware
= "dvb-usb-bluebird-01.fw",
1706 .download_firmware
= bluebird_patch_dvico_firmware_download
,
1707 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1708 use usb alt setting 7 for EP2 transfer (atsc) */
1710 .size_of_priv
= sizeof(struct cxusb_state
),
1717 .streaming_ctrl
= cxusb_streaming_ctrl
,
1718 .frontend_attach
= cxusb_mt352_frontend_attach
,
1719 .tuner_attach
= cxusb_dtt7579_tuner_attach
,
1721 /* parameter for the MPEG2-data transfer */
1735 .power_ctrl
= cxusb_bluebird_power_ctrl
,
1737 .i2c_algo
= &cxusb_i2c_algo
,
1741 .rc_codes
= RC_MAP_DVICO_PORTABLE
,
1742 .module_name
= KBUILD_MODNAME
,
1743 .rc_query
= cxusb_rc_query
,
1744 .allowed_protos
= RC_BIT_UNKNOWN
,
1747 .generic_bulk_ctrl_endpoint
= 0x01,
1749 .num_device_descs
= 1,
1751 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1752 { &cxusb_table
[DVICO_BLUEBIRD_TH7579_COLD
], NULL
},
1753 { &cxusb_table
[DVICO_BLUEBIRD_TH7579_WARM
], NULL
},
1758 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties
= {
1759 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1761 .usb_ctrl
= CYPRESS_FX2
,
1763 .size_of_priv
= sizeof(struct cxusb_state
),
1770 .streaming_ctrl
= cxusb_streaming_ctrl
,
1771 .frontend_attach
= cxusb_dualdig4_frontend_attach
,
1772 .tuner_attach
= cxusb_dvico_xc3028_tuner_attach
,
1773 /* parameter for the MPEG2-data transfer */
1788 .power_ctrl
= cxusb_power_ctrl
,
1790 .i2c_algo
= &cxusb_i2c_algo
,
1792 .generic_bulk_ctrl_endpoint
= 0x01,
1796 .rc_codes
= RC_MAP_DVICO_MCE
,
1797 .module_name
= KBUILD_MODNAME
,
1798 .rc_query
= cxusb_bluebird2_rc_query
,
1799 .allowed_protos
= RC_BIT_UNKNOWN
,
1802 .num_device_descs
= 1,
1804 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1806 { &cxusb_table
[DVICO_BLUEBIRD_DUAL_4
], NULL
},
1811 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties
= {
1812 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1814 .usb_ctrl
= CYPRESS_FX2
,
1815 .identify_state
= bluebird_fx2_identify_state
,
1817 .size_of_priv
= sizeof(struct cxusb_state
),
1824 .streaming_ctrl
= cxusb_streaming_ctrl
,
1825 .frontend_attach
= cxusb_nano2_frontend_attach
,
1826 .tuner_attach
= cxusb_dvico_xc3028_tuner_attach
,
1827 /* parameter for the MPEG2-data transfer */
1842 .power_ctrl
= cxusb_nano2_power_ctrl
,
1844 .i2c_algo
= &cxusb_i2c_algo
,
1846 .generic_bulk_ctrl_endpoint
= 0x01,
1850 .rc_codes
= RC_MAP_DVICO_PORTABLE
,
1851 .module_name
= KBUILD_MODNAME
,
1852 .rc_query
= cxusb_bluebird2_rc_query
,
1853 .allowed_protos
= RC_BIT_UNKNOWN
,
1856 .num_device_descs
= 1,
1858 { "DViCO FusionHDTV DVB-T NANO2",
1860 { &cxusb_table
[DVICO_BLUEBIRD_DVB_T_NANO_2
], NULL
},
1865 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties
= {
1866 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1868 .usb_ctrl
= DEVICE_SPECIFIC
,
1869 .firmware
= "dvb-usb-bluebird-02.fw",
1870 .download_firmware
= bluebird_patch_dvico_firmware_download
,
1871 .identify_state
= bluebird_fx2_identify_state
,
1873 .size_of_priv
= sizeof(struct cxusb_state
),
1880 .streaming_ctrl
= cxusb_streaming_ctrl
,
1881 .frontend_attach
= cxusb_nano2_frontend_attach
,
1882 .tuner_attach
= cxusb_dvico_xc3028_tuner_attach
,
1883 /* parameter for the MPEG2-data transfer */
1898 .power_ctrl
= cxusb_nano2_power_ctrl
,
1900 .i2c_algo
= &cxusb_i2c_algo
,
1902 .generic_bulk_ctrl_endpoint
= 0x01,
1906 .rc_codes
= RC_MAP_DVICO_PORTABLE
,
1907 .module_name
= KBUILD_MODNAME
,
1908 .rc_query
= cxusb_rc_query
,
1909 .allowed_protos
= RC_BIT_UNKNOWN
,
1912 .num_device_descs
= 1,
1914 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1915 { &cxusb_table
[DVICO_BLUEBIRD_DVB_T_NANO_2
], NULL
},
1916 { &cxusb_table
[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM
], NULL
},
1921 static struct dvb_usb_device_properties cxusb_aver_a868r_properties
= {
1922 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1924 .usb_ctrl
= CYPRESS_FX2
,
1926 .size_of_priv
= sizeof(struct cxusb_state
),
1933 .streaming_ctrl
= cxusb_aver_streaming_ctrl
,
1934 .frontend_attach
= cxusb_aver_lgdt3303_frontend_attach
,
1935 .tuner_attach
= cxusb_mxl5003s_tuner_attach
,
1936 /* parameter for the MPEG2-data transfer */
1950 .power_ctrl
= cxusb_aver_power_ctrl
,
1952 .i2c_algo
= &cxusb_i2c_algo
,
1954 .generic_bulk_ctrl_endpoint
= 0x01,
1956 .num_device_descs
= 1,
1958 { "AVerMedia AVerTVHD Volar (A868R)",
1960 { &cxusb_table
[AVERMEDIA_VOLAR_A868R
], NULL
},
1966 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties
= {
1967 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1969 .usb_ctrl
= CYPRESS_FX2
,
1971 .size_of_priv
= sizeof(struct cxusb_state
),
1976 .size_of_priv
= sizeof(struct dib0700_adapter_state
),
1979 .streaming_ctrl
= cxusb_streaming_ctrl
,
1980 .frontend_attach
= cxusb_dualdig4_rev2_frontend_attach
,
1981 .tuner_attach
= cxusb_dualdig4_rev2_tuner_attach
,
1982 /* parameter for the MPEG2-data transfer */
1997 .power_ctrl
= cxusb_bluebird_power_ctrl
,
1999 .i2c_algo
= &cxusb_i2c_algo
,
2001 .generic_bulk_ctrl_endpoint
= 0x01,
2005 .rc_codes
= RC_MAP_DVICO_MCE
,
2006 .module_name
= KBUILD_MODNAME
,
2007 .rc_query
= cxusb_rc_query
,
2008 .allowed_protos
= RC_BIT_UNKNOWN
,
2011 .num_device_descs
= 1,
2013 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
2015 { &cxusb_table
[DVICO_BLUEBIRD_DUAL_4_REV_2
], NULL
},
2020 static struct dvb_usb_device_properties cxusb_d680_dmb_properties
= {
2021 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
2023 .usb_ctrl
= CYPRESS_FX2
,
2025 .size_of_priv
= sizeof(struct cxusb_state
),
2032 .streaming_ctrl
= cxusb_d680_dmb_streaming_ctrl
,
2033 .frontend_attach
= cxusb_d680_dmb_frontend_attach
,
2034 .tuner_attach
= cxusb_d680_dmb_tuner_attach
,
2036 /* parameter for the MPEG2-data transfer */
2051 .power_ctrl
= cxusb_d680_dmb_power_ctrl
,
2053 .i2c_algo
= &cxusb_i2c_algo
,
2055 .generic_bulk_ctrl_endpoint
= 0x01,
2059 .rc_codes
= RC_MAP_D680_DMB
,
2060 .module_name
= KBUILD_MODNAME
,
2061 .rc_query
= cxusb_d680_dmb_rc_query
,
2062 .allowed_protos
= RC_BIT_UNKNOWN
,
2065 .num_device_descs
= 1,
2068 "Conexant DMB-TH Stick",
2070 { &cxusb_table
[CONEXANT_D680_DMB
], NULL
},
2075 static struct dvb_usb_device_properties cxusb_mygica_d689_properties
= {
2076 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
2078 .usb_ctrl
= CYPRESS_FX2
,
2080 .size_of_priv
= sizeof(struct cxusb_state
),
2087 .streaming_ctrl
= cxusb_d680_dmb_streaming_ctrl
,
2088 .frontend_attach
= cxusb_mygica_d689_frontend_attach
,
2089 .tuner_attach
= cxusb_mygica_d689_tuner_attach
,
2091 /* parameter for the MPEG2-data transfer */
2106 .power_ctrl
= cxusb_d680_dmb_power_ctrl
,
2108 .i2c_algo
= &cxusb_i2c_algo
,
2110 .generic_bulk_ctrl_endpoint
= 0x01,
2114 .rc_codes
= RC_MAP_D680_DMB
,
2115 .module_name
= KBUILD_MODNAME
,
2116 .rc_query
= cxusb_d680_dmb_rc_query
,
2117 .allowed_protos
= RC_BIT_UNKNOWN
,
2120 .num_device_descs
= 1,
2123 "Mygica D689 DMB-TH",
2125 { &cxusb_table
[MYGICA_D689
], NULL
},
2130 static struct dvb_usb_device_properties cxusb_mygica_t230_properties
= {
2131 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
2133 .usb_ctrl
= CYPRESS_FX2
,
2135 .size_of_priv
= sizeof(struct cxusb_state
),
2142 .streaming_ctrl
= cxusb_streaming_ctrl
,
2143 .frontend_attach
= cxusb_mygica_t230_frontend_attach
,
2145 /* parameter for the MPEG2-data transfer */
2160 .power_ctrl
= cxusb_d680_dmb_power_ctrl
,
2162 .i2c_algo
= &cxusb_i2c_algo
,
2164 .generic_bulk_ctrl_endpoint
= 0x01,
2168 .rc_codes
= RC_MAP_D680_DMB
,
2169 .module_name
= KBUILD_MODNAME
,
2170 .rc_query
= cxusb_d680_dmb_rc_query
,
2171 .allowed_protos
= RC_BIT_UNKNOWN
,
2174 .num_device_descs
= 1,
2177 "Mygica T230 DVB-T/T2/C",
2179 { &cxusb_table
[MYGICA_T230
], NULL
},
2184 static struct usb_driver cxusb_driver
= {
2185 .name
= "dvb_usb_cxusb",
2186 .probe
= cxusb_probe
,
2187 .disconnect
= cxusb_disconnect
,
2188 .id_table
= cxusb_table
,
2191 module_usb_driver(cxusb_driver
);
2193 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2194 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
2195 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
2196 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2197 MODULE_VERSION("1.0-alpha");
2198 MODULE_LICENSE("GPL");