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