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