This source file includes following definitions.
- cxusb_ctrl_msg
- cxusb_gpio_tuner
- cxusb_bluebird_gpio_rw
- cxusb_bluebird_gpio_pulse
- cxusb_nano2_led
- cxusb_d680_dmb_gpio_tuner
- cxusb_i2c_xfer
- cxusb_i2c_func
- _cxusb_power_ctrl
- cxusb_power_ctrl
- cxusb_aver_power_ctrl
- cxusb_bluebird_power_ctrl
- cxusb_nano2_power_ctrl
- cxusb_d680_dmb_power_ctrl
- cxusb_streaming_ctrl
- cxusb_aver_streaming_ctrl
- cxusb_d680_dmb_drain_message
- cxusb_d680_dmb_drain_video
- cxusb_d680_dmb_streaming_ctrl
- cxusb_rc_query
- cxusb_bluebird2_rc_query
- cxusb_d680_dmb_rc_query
- cxusb_dee1601_demod_init
- cxusb_mt352_demod_init
- cxusb_fmd1216me_tuner_attach
- cxusb_dee1601_tuner_attach
- cxusb_lgz201_tuner_attach
- cxusb_dtt7579_tuner_attach
- cxusb_lgh064f_tuner_attach
- dvico_bluebird_xc2028_callback
- cxusb_dvico_xc3028_tuner_attach
- cxusb_mxl5003s_tuner_attach
- cxusb_d680_dmb_tuner_attach
- cxusb_mygica_d689_tuner_attach
- cxusb_medion_fe_ts_bus_ctrl
- cxusb_medion_set_mode
- cxusb_cx22702_frontend_attach
- cxusb_lgdt3303_frontend_attach
- cxusb_aver_lgdt3303_frontend_attach
- cxusb_mt352_frontend_attach
- cxusb_dee1601_frontend_attach
- cxusb_dualdig4_frontend_attach
- cxusb_dualdig4_rev2_frontend_attach
- dib7070_tuner_reset
- dib7070_tuner_sleep
- dib7070_set_param_override
- cxusb_dualdig4_rev2_tuner_attach
- cxusb_nano2_frontend_attach
- cxusb_d680_dmb_frontend_attach
- cxusb_mygica_d689_frontend_attach
- bluebird_fx2_identify_state
- bluebird_patch_dvico_firmware_download
- cxusb_medion_get
- cxusb_medion_put
- cxusb_medion_priv_init
- cxusb_medion_priv_destroy
- cxusb_medion_check_altsetting
- cxusb_medion_check_intf
- cxusb_probe
- cxusb_disconnect
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
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
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
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
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;
141 o[1] = newval & changemask;
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
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
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
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
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
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
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
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
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
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
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
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
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
357
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
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
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
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
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
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
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
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
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
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
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
520 static int cxusb_rc_query(struct dvb_usb_device *d)
521 {
522 u8 ircode[4];
523
524 if (cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4) < 0)
525 return 0;
526
527 if (ircode[2] || ircode[3])
528 rc_keydown(d->rc_dev, RC_PROTO_NEC,
529 RC_SCANCODE_NEC(~ircode[2] & 0xff, ircode[3]), 0);
530 return 0;
531 }
532
533 static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d)
534 {
535 u8 ircode[4];
536 struct i2c_msg msg = {
537 .addr = 0x6b,
538 .flags = I2C_M_RD,
539 .buf = ircode,
540 .len = 4
541 };
542
543 if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
544 return 0;
545
546 if (ircode[1] || ircode[2])
547 rc_keydown(d->rc_dev, RC_PROTO_NEC,
548 RC_SCANCODE_NEC(~ircode[1] & 0xff, ircode[2]), 0);
549 return 0;
550 }
551
552 static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d)
553 {
554 u8 ircode[2];
555
556 if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0)
557 return 0;
558
559 if (ircode[0] || ircode[1])
560 rc_keydown(d->rc_dev, RC_PROTO_UNKNOWN,
561 RC_SCANCODE_RC5(ircode[0], ircode[1]), 0);
562 return 0;
563 }
564
565 static int cxusb_dee1601_demod_init(struct dvb_frontend *fe)
566 {
567 static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x28 };
568 static u8 reset[] = { RESET, 0x80 };
569 static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
570 static u8 agc_cfg[] = { AGC_TARGET, 0x28, 0x20 };
571 static u8 gpp_ctl_cfg[] = { GPP_CTL, 0x33 };
572 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
573
574 mt352_write(fe, clock_config, sizeof(clock_config));
575 udelay(200);
576 mt352_write(fe, reset, sizeof(reset));
577 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
578
579 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
580 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
581 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
582
583 return 0;
584 }
585
586 static int cxusb_mt352_demod_init(struct dvb_frontend *fe)
587 {
588
589 static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x29 };
590 static u8 reset[] = { RESET, 0x80 };
591 static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
592 static u8 agc_cfg[] = { AGC_TARGET, 0x24, 0x20 };
593 static u8 gpp_ctl_cfg[] = { GPP_CTL, 0x33 };
594 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
595
596 mt352_write(fe, clock_config, sizeof(clock_config));
597 udelay(200);
598 mt352_write(fe, reset, sizeof(reset));
599 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
600
601 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
602 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
603 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
604 return 0;
605 }
606
607 static struct cx22702_config cxusb_cx22702_config = {
608 .demod_address = 0x63,
609 .output_mode = CX22702_PARALLEL_OUTPUT,
610 };
611
612 static struct lgdt330x_config cxusb_lgdt3303_config = {
613 .demod_chip = LGDT3303,
614 };
615
616 static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
617 .demod_chip = LGDT3303,
618 .clock_polarity_flip = 2,
619 };
620
621 static struct mt352_config cxusb_dee1601_config = {
622 .demod_address = 0x0f,
623 .demod_init = cxusb_dee1601_demod_init,
624 };
625
626 static struct zl10353_config cxusb_zl10353_dee1601_config = {
627 .demod_address = 0x0f,
628 .parallel_ts = 1,
629 };
630
631 static struct mt352_config cxusb_mt352_config = {
632
633 .demod_address = 0x0f,
634 .demod_init = cxusb_mt352_demod_init,
635 };
636
637 static struct zl10353_config cxusb_zl10353_xc3028_config = {
638 .demod_address = 0x0f,
639 .if2 = 45600,
640 .no_tuner = 1,
641 .parallel_ts = 1,
642 };
643
644 static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
645 .demod_address = 0x0f,
646 .if2 = 45600,
647 .no_tuner = 1,
648 .parallel_ts = 1,
649 .disable_i2c_gate_ctrl = 1,
650 };
651
652 static struct mt352_config cxusb_mt352_xc3028_config = {
653 .demod_address = 0x0f,
654 .if2 = 4560,
655 .no_tuner = 1,
656 .demod_init = cxusb_mt352_demod_init,
657 };
658
659
660 static struct mxl5005s_config aver_a868r_tuner = {
661 .i2c_address = 0x63,
662 .if_freq = 6000000UL,
663 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
664 .agc_mode = MXL_SINGLE_AGC,
665 .tracking_filter = MXL_TF_C,
666 .rssi_enable = MXL_RSSI_ENABLE,
667 .cap_select = MXL_CAP_SEL_ENABLE,
668 .div_out = MXL_DIV_OUT_4,
669 .clock_out = MXL_CLOCK_OUT_DISABLE,
670 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
671 .top = MXL5005S_TOP_25P2,
672 .mod_mode = MXL_DIGITAL_MODE,
673 .if_mode = MXL_ZERO_IF,
674 .AgcMasterByte = 0x00,
675 };
676
677
678 static struct mxl5005s_config d680_dmb_tuner = {
679 .i2c_address = 0x63,
680 .if_freq = 36125000UL,
681 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
682 .agc_mode = MXL_SINGLE_AGC,
683 .tracking_filter = MXL_TF_C,
684 .rssi_enable = MXL_RSSI_ENABLE,
685 .cap_select = MXL_CAP_SEL_ENABLE,
686 .div_out = MXL_DIV_OUT_4,
687 .clock_out = MXL_CLOCK_OUT_DISABLE,
688 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
689 .top = MXL5005S_TOP_25P2,
690 .mod_mode = MXL_DIGITAL_MODE,
691 .if_mode = MXL_ZERO_IF,
692 .AgcMasterByte = 0x00,
693 };
694
695 static struct max2165_config mygica_d689_max2165_cfg = {
696 .i2c_address = 0x60,
697 .osc_clk = 20
698 };
699
700
701 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
702 {
703 struct dvb_usb_device *dvbdev = adap->dev;
704 bool is_medion = dvbdev->props.devices[0].warm_ids[0] ==
705 &cxusb_table[MEDION_MD95700];
706
707 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
708 &dvbdev->i2c_adap, 0x61,
709 TUNER_PHILIPS_FMD1216ME_MK3);
710
711 if (is_medion && adap->fe_adap[0].fe)
712
713
714
715
716 adap->fe_adap[0].fe->ops.tuner_ops.sleep = NULL;
717
718 return 0;
719 }
720
721 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
722 {
723 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
724 NULL, DVB_PLL_THOMSON_DTT7579);
725 return 0;
726 }
727
728 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
729 {
730 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
731 NULL, DVB_PLL_LG_Z201);
732 return 0;
733 }
734
735 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
736 {
737 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
738 NULL, DVB_PLL_THOMSON_DTT7579);
739 return 0;
740 }
741
742 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
743 {
744 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
745 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
746 return 0;
747 }
748
749 static int dvico_bluebird_xc2028_callback(void *ptr, int component,
750 int command, int arg)
751 {
752 struct dvb_usb_adapter *adap = ptr;
753 struct dvb_usb_device *d = adap->dev;
754
755 switch (command) {
756 case XC2028_TUNER_RESET:
757 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
758 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
759 break;
760 case XC2028_RESET_CLK:
761 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
762 break;
763 case XC2028_I2C_FLUSH:
764 break;
765 default:
766 deb_info("%s: unknown command %d, arg %d\n", __func__,
767 command, arg);
768 return -EINVAL;
769 }
770
771 return 0;
772 }
773
774 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
775 {
776 struct dvb_frontend *fe;
777 struct xc2028_config cfg = {
778 .i2c_adap = &adap->dev->i2c_adap,
779 .i2c_addr = 0x61,
780 };
781 static struct xc2028_ctrl ctl = {
782 .fname = XC2028_DEFAULT_FIRMWARE,
783 .max_len = 64,
784 .demod = XC3028_FE_ZARLINK456,
785 };
786
787
788 adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback;
789
790 fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg);
791 if (!fe || !fe->ops.tuner_ops.set_config)
792 return -EIO;
793
794 fe->ops.tuner_ops.set_config(fe, &ctl);
795
796 return 0;
797 }
798
799 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
800 {
801 dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
802 &adap->dev->i2c_adap, &aver_a868r_tuner);
803 return 0;
804 }
805
806 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
807 {
808 struct dvb_frontend *fe;
809
810 fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
811 &adap->dev->i2c_adap, &d680_dmb_tuner);
812 return (!fe) ? -EIO : 0;
813 }
814
815 static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
816 {
817 struct dvb_frontend *fe;
818
819 fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe,
820 &adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
821 return (!fe) ? -EIO : 0;
822 }
823
824 static int cxusb_medion_fe_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
825 {
826 struct dvb_usb_adapter *adap = fe->dvb->priv;
827 struct dvb_usb_device *dvbdev = adap->dev;
828
829 if (acquire)
830 return cxusb_medion_get(dvbdev, CXUSB_OPEN_DIGITAL);
831
832 cxusb_medion_put(dvbdev);
833
834 return 0;
835 }
836
837 static int cxusb_medion_set_mode(struct dvb_usb_device *dvbdev, bool digital)
838 {
839 struct cxusb_state *st = dvbdev->priv;
840 int ret;
841 u8 b;
842 unsigned int i;
843
844
845
846
847
848 mutex_lock(&dvbdev->i2c_mutex);
849
850 if (digital) {
851 ret = usb_set_interface(dvbdev->udev, 0, 6);
852 if (ret != 0) {
853 dev_err(&dvbdev->udev->dev,
854 "digital interface selection failed (%d)\n",
855 ret);
856 goto ret_unlock;
857 }
858 } else {
859 ret = usb_set_interface(dvbdev->udev, 0, 1);
860 if (ret != 0) {
861 dev_err(&dvbdev->udev->dev,
862 "analog interface selection failed (%d)\n",
863 ret);
864 goto ret_unlock;
865 }
866 }
867
868
869 ret = usb_clear_halt(dvbdev->udev, usb_rcvbulkpipe(dvbdev->udev, 1));
870 if (ret != 0)
871 dev_warn(&dvbdev->udev->dev,
872 "clear halt on IN pipe failed (%d)\n",
873 ret);
874
875 ret = usb_clear_halt(dvbdev->udev, usb_sndbulkpipe(dvbdev->udev, 1));
876 if (ret != 0)
877 dev_warn(&dvbdev->udev->dev,
878 "clear halt on OUT pipe failed (%d)\n",
879 ret);
880
881 ret = cxusb_ctrl_msg(dvbdev, digital ? CMD_DIGITAL : CMD_ANALOG,
882 NULL, 0, &b, 1);
883 if (ret != 0) {
884 dev_err(&dvbdev->udev->dev, "mode switch failed (%d)\n",
885 ret);
886 goto ret_unlock;
887 }
888
889
890 for (i = 0; i < ARRAY_SIZE(st->gpio_write_refresh); i++)
891 st->gpio_write_refresh[i] = true;
892
893 ret_unlock:
894 mutex_unlock(&dvbdev->i2c_mutex);
895
896 return ret;
897 }
898
899 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
900 {
901 struct dvb_usb_device *dvbdev = adap->dev;
902 bool is_medion = dvbdev->props.devices[0].warm_ids[0] ==
903 &cxusb_table[MEDION_MD95700];
904
905 if (is_medion) {
906 int ret;
907
908 ret = cxusb_medion_set_mode(dvbdev, true);
909 if (ret)
910 return ret;
911 }
912
913 adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
914 &dvbdev->i2c_adap);
915 if (!adap->fe_adap[0].fe)
916 return -EIO;
917
918 if (is_medion)
919 adap->fe_adap[0].fe->ops.ts_bus_ctrl =
920 cxusb_medion_fe_ts_bus_ctrl;
921
922 return 0;
923 }
924
925 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
926 {
927 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
928 err("set interface failed");
929
930 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
931
932 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
933 &cxusb_lgdt3303_config,
934 0x0e,
935 &adap->dev->i2c_adap);
936 if (adap->fe_adap[0].fe)
937 return 0;
938
939 return -EIO;
940 }
941
942 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
943 {
944 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
945 &cxusb_aver_lgdt3303_config,
946 0x0e,
947 &adap->dev->i2c_adap);
948 if (adap->fe_adap[0].fe)
949 return 0;
950
951 return -EIO;
952 }
953
954 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
955 {
956
957 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
958 err("set interface failed");
959
960 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
961
962 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
963 &adap->dev->i2c_adap);
964 if (adap->fe_adap[0].fe)
965 return 0;
966
967 return -EIO;
968 }
969
970 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
971 {
972 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
973 err("set interface failed");
974
975 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
976
977 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
978 &adap->dev->i2c_adap);
979 if (adap->fe_adap[0].fe)
980 return 0;
981
982 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
983 &cxusb_zl10353_dee1601_config,
984 &adap->dev->i2c_adap);
985 if (adap->fe_adap[0].fe)
986 return 0;
987
988 return -EIO;
989 }
990
991 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
992 {
993 u8 ircode[4];
994 int i;
995 struct i2c_msg msg = {
996 .addr = 0x6b,
997 .flags = I2C_M_RD,
998 .buf = ircode,
999 .len = 4
1000 };
1001
1002 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1003 err("set interface failed");
1004
1005 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1006
1007
1008 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1009 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1010 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1011
1012 adap->fe_adap[0].fe =
1013 dvb_attach(zl10353_attach,
1014 &cxusb_zl10353_xc3028_config_no_i2c_gate,
1015 &adap->dev->i2c_adap);
1016 if (!adap->fe_adap[0].fe)
1017 return -EIO;
1018
1019
1020 for (i = 0; adap->dev->props.rc.core.rc_codes && i < 5; i++) {
1021 msleep(20);
1022 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
1023 goto no_IR;
1024 if (ircode[0] == 0 && ircode[1] == 0)
1025 continue;
1026 if (ircode[2] + ircode[3] != 0xff) {
1027 no_IR:
1028 adap->dev->props.rc.core.rc_codes = NULL;
1029 info("No IR receiver detected on this device.");
1030 break;
1031 }
1032 }
1033
1034 return 0;
1035 }
1036
1037 static struct dibx000_agc_config dib7070_agc_config = {
1038 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1039
1040
1041
1042
1043
1044
1045 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
1046 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1047 .inv_gain = 600,
1048 .time_stabiliz = 10,
1049 .alpha_level = 0,
1050 .thlock = 118,
1051 .wbd_inv = 0,
1052 .wbd_ref = 3530,
1053 .wbd_sel = 1,
1054 .wbd_alpha = 5,
1055 .agc1_max = 65535,
1056 .agc1_min = 0,
1057 .agc2_max = 65535,
1058 .agc2_min = 0,
1059 .agc1_pt1 = 0,
1060 .agc1_pt2 = 40,
1061 .agc1_pt3 = 183,
1062 .agc1_slope1 = 206,
1063 .agc1_slope2 = 255,
1064 .agc2_pt1 = 72,
1065 .agc2_pt2 = 152,
1066 .agc2_slope1 = 88,
1067 .agc2_slope2 = 90,
1068 .alpha_mant = 17,
1069 .alpha_exp = 27,
1070 .beta_mant = 23,
1071 .beta_exp = 51,
1072 .perform_agc_softsplit = 0,
1073 };
1074
1075 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1076 .internal = 60000,
1077 .sampling = 15000,
1078 .pll_prediv = 1,
1079 .pll_ratio = 20,
1080 .pll_range = 3,
1081 .pll_reset = 1,
1082 .pll_bypass = 0,
1083 .enable_refdiv = 0,
1084 .bypclk_div = 0,
1085 .IO_CLK_en_core = 1,
1086 .ADClkSrc = 1,
1087 .modulo = 2,
1088
1089 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1090 .ifreq = (0 << 25) | 0,
1091 .timf = 20452225,
1092 .xtal_hz = 12000000,
1093 };
1094
1095 static struct dib7000p_config cxusb_dualdig4_rev2_config = {
1096 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
1097 .output_mpeg2_in_188_bytes = 1,
1098
1099 .agc_config_count = 1,
1100 .agc = &dib7070_agc_config,
1101 .bw = &dib7070_bw_config_12_mhz,
1102 .tuner_is_baseband = 1,
1103 .spur_protect = 1,
1104
1105 .gpio_dir = 0xfcef,
1106 .gpio_val = 0x0110,
1107
1108 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1109
1110 .hostbus_diversity = 1,
1111 };
1112
1113 struct dib0700_adapter_state {
1114 int (*set_param_save)(struct dvb_frontend *fe);
1115 struct dib7000p_ops dib7000p_ops;
1116 };
1117
1118 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1119 {
1120 struct dib0700_adapter_state *state = adap->priv;
1121
1122 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1123 err("set interface failed");
1124
1125 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1126
1127 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1128
1129 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1130 return -ENODEV;
1131
1132 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1133 &cxusb_dualdig4_rev2_config) < 0) {
1134 pr_warn("Unable to enumerate dib7000p\n");
1135 return -ENODEV;
1136 }
1137
1138 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap,
1139 0x80,
1140 &cxusb_dualdig4_rev2_config);
1141 if (!adap->fe_adap[0].fe)
1142 return -EIO;
1143
1144 return 0;
1145 }
1146
1147 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1148 {
1149 struct dvb_usb_adapter *adap = fe->dvb->priv;
1150 struct dib0700_adapter_state *state = adap->priv;
1151
1152 return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
1153 }
1154
1155 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1156 {
1157 return 0;
1158 }
1159
1160 static struct dib0070_config dib7070p_dib0070_config = {
1161 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1162 .reset = dib7070_tuner_reset,
1163 .sleep = dib7070_tuner_sleep,
1164 .clock_khz = 12000,
1165 };
1166
1167 static int dib7070_set_param_override(struct dvb_frontend *fe)
1168 {
1169 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1170 struct dvb_usb_adapter *adap = fe->dvb->priv;
1171 struct dib0700_adapter_state *state = adap->priv;
1172
1173 u16 offset;
1174 u8 band = BAND_OF_FREQUENCY(p->frequency / 1000);
1175
1176 switch (band) {
1177 case BAND_VHF:
1178 offset = 950;
1179 break;
1180 default:
1181 case BAND_UHF:
1182 offset = 550;
1183 break;
1184 }
1185
1186 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1187
1188 return state->set_param_save(fe);
1189 }
1190
1191 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1192 {
1193 struct dib0700_adapter_state *st = adap->priv;
1194 struct i2c_adapter *tun_i2c;
1195
1196
1197
1198
1199
1200
1201 tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
1202 DIBX000_I2C_INTERFACE_TUNER, 1);
1203
1204 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1205 &dib7070p_dib0070_config) == NULL)
1206 return -ENODEV;
1207
1208 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1209 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1210 return 0;
1211 }
1212
1213 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1214 {
1215 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1216 err("set interface failed");
1217
1218 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1219
1220
1221 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1222 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1223 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1224
1225 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
1226 &cxusb_zl10353_xc3028_config,
1227 &adap->dev->i2c_adap);
1228 if (adap->fe_adap[0].fe)
1229 return 0;
1230
1231 adap->fe_adap[0].fe = dvb_attach(mt352_attach,
1232 &cxusb_mt352_xc3028_config,
1233 &adap->dev->i2c_adap);
1234 if (adap->fe_adap[0].fe)
1235 return 0;
1236
1237 return -EIO;
1238 }
1239
1240 static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1241 .prod = LGS8GXX_PROD_LGS8GL5,
1242 .demod_address = 0x19,
1243 .serial_ts = 0,
1244 .ts_clk_pol = 0,
1245 .ts_clk_gated = 1,
1246 .if_clk_freq = 30400,
1247 .if_freq = 5725,
1248 .if_neg_center = 0,
1249 .ext_adc = 0,
1250 .adc_signed = 0,
1251 .if_neg_edge = 0,
1252 };
1253
1254 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1255 {
1256 struct dvb_usb_device *d = adap->dev;
1257 int n;
1258
1259
1260 if (usb_set_interface(d->udev, 0, 0) < 0)
1261 err("set interface failed");
1262
1263
1264 usb_clear_halt(d->udev,
1265 usb_sndbulkpipe(d->udev,
1266 d->props.generic_bulk_ctrl_endpoint));
1267 usb_clear_halt(d->udev,
1268 usb_rcvbulkpipe(d->udev,
1269 d->props.generic_bulk_ctrl_endpoint));
1270 usb_clear_halt(d->udev,
1271 usb_rcvbulkpipe(d->udev,
1272 d->props.adapter[0].fe[0].stream.endpoint));
1273
1274
1275 for (n = 0; n < 5; n++) {
1276 cxusb_d680_dmb_drain_message(d);
1277 cxusb_d680_dmb_drain_video(d);
1278 msleep(200);
1279 }
1280
1281
1282 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1283 err("clear tuner gpio failed");
1284 return -EIO;
1285 }
1286 msleep(100);
1287 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1288 err("set tuner gpio failed");
1289 return -EIO;
1290 }
1291 msleep(100);
1292
1293
1294 adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach,
1295 &d680_lgs8gl5_cfg, &d->i2c_adap);
1296 if (!adap->fe_adap[0].fe)
1297 return -EIO;
1298
1299 return 0;
1300 }
1301
1302 static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1303 .prod = ATBM8830_PROD_8830,
1304 .demod_address = 0x40,
1305 .serial_ts = 0,
1306 .ts_sampling_edge = 1,
1307 .ts_clk_gated = 0,
1308 .osc_clk_freq = 30400,
1309 .if_freq = 0,
1310 .zif_swap_iq = 1,
1311 .agc_min = 0x2E,
1312 .agc_max = 0x90,
1313 .agc_hold_loop = 0,
1314 };
1315
1316 static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1317 {
1318 struct dvb_usb_device *d = adap->dev;
1319
1320
1321 if (usb_set_interface(d->udev, 0, 0) < 0)
1322 err("set interface failed");
1323
1324
1325 usb_clear_halt(d->udev,
1326 usb_sndbulkpipe(d->udev,
1327 d->props.generic_bulk_ctrl_endpoint));
1328 usb_clear_halt(d->udev,
1329 usb_rcvbulkpipe(d->udev,
1330 d->props.generic_bulk_ctrl_endpoint));
1331 usb_clear_halt(d->udev,
1332 usb_rcvbulkpipe(d->udev,
1333 d->props.adapter[0].fe[0].stream.endpoint));
1334
1335
1336 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1337 err("clear tuner gpio failed");
1338 return -EIO;
1339 }
1340 msleep(100);
1341 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1342 err("set tuner gpio failed");
1343 return -EIO;
1344 }
1345 msleep(100);
1346
1347
1348 adap->fe_adap[0].fe = dvb_attach(atbm8830_attach,
1349 &mygica_d689_atbm8830_cfg,
1350 &d->i2c_adap);
1351 if (!adap->fe_adap[0].fe)
1352 return -EIO;
1353
1354 return 0;
1355 }
1356
1357
1358
1359
1360
1361
1362
1363 static int bluebird_fx2_identify_state(struct usb_device *udev,
1364 struct dvb_usb_device_properties *props,
1365 struct dvb_usb_device_description **desc,
1366 int *cold)
1367 {
1368 int wascold = *cold;
1369
1370 *cold = udev->descriptor.bDeviceClass == 0xff &&
1371 udev->descriptor.bDeviceSubClass == 0xff &&
1372 udev->descriptor.bDeviceProtocol == 0xff;
1373
1374 if (*cold && !wascold)
1375 *desc = NULL;
1376
1377 return 0;
1378 }
1379
1380
1381
1382
1383
1384
1385 static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1386 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1387 const struct firmware *fw)
1388 {
1389 int pos;
1390
1391 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1392 int idoff = dvico_firmware_id_offsets[pos];
1393
1394 if (fw->size < idoff + 4)
1395 continue;
1396
1397 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1398 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1399 struct firmware new_fw;
1400 u8 *new_fw_data = vmalloc(fw->size);
1401 int ret;
1402
1403 if (!new_fw_data)
1404 return -ENOMEM;
1405
1406 memcpy(new_fw_data, fw->data, fw->size);
1407 new_fw.size = fw->size;
1408 new_fw.data = new_fw_data;
1409
1410 new_fw_data[idoff + 2] =
1411 le16_to_cpu(udev->descriptor.idProduct) + 1;
1412 new_fw_data[idoff + 3] =
1413 le16_to_cpu(udev->descriptor.idProduct) >> 8;
1414
1415 ret = usb_cypress_load_firmware(udev, &new_fw,
1416 CYPRESS_FX2);
1417 vfree(new_fw_data);
1418 return ret;
1419 }
1420 }
1421
1422 return -EINVAL;
1423 }
1424
1425 int cxusb_medion_get(struct dvb_usb_device *dvbdev,
1426 enum cxusb_open_type open_type)
1427 {
1428 struct cxusb_medion_dev *cxdev = dvbdev->priv;
1429 int ret = 0;
1430
1431 mutex_lock(&cxdev->open_lock);
1432
1433 if (WARN_ON((cxdev->open_type == CXUSB_OPEN_INIT ||
1434 cxdev->open_type == CXUSB_OPEN_NONE) &&
1435 cxdev->open_ctr != 0)) {
1436 ret = -EINVAL;
1437 goto ret_unlock;
1438 }
1439
1440 if (cxdev->open_type == CXUSB_OPEN_INIT) {
1441 ret = -EAGAIN;
1442 goto ret_unlock;
1443 }
1444
1445 if (cxdev->open_ctr == 0) {
1446 if (cxdev->open_type != open_type) {
1447 deb_info("will acquire and switch to %s\n",
1448 open_type == CXUSB_OPEN_ANALOG ?
1449 "analog" : "digital");
1450
1451 if (open_type == CXUSB_OPEN_ANALOG) {
1452 ret = _cxusb_power_ctrl(dvbdev, 1);
1453 if (ret != 0)
1454 dev_warn(&dvbdev->udev->dev,
1455 "powerup for analog switch failed (%d)\n",
1456 ret);
1457
1458 ret = cxusb_medion_set_mode(dvbdev, false);
1459 if (ret != 0)
1460 goto ret_unlock;
1461
1462 ret = cxusb_medion_analog_init(dvbdev);
1463 if (ret != 0)
1464 goto ret_unlock;
1465 } else {
1466 ret = _cxusb_power_ctrl(dvbdev, 1);
1467 if (ret != 0)
1468 dev_warn(&dvbdev->udev->dev,
1469 "powerup for digital switch failed (%d)\n",
1470 ret);
1471
1472 ret = cxusb_medion_set_mode(dvbdev, true);
1473 if (ret != 0)
1474 goto ret_unlock;
1475 }
1476
1477 cxdev->open_type = open_type;
1478 } else {
1479 deb_info("reacquired idle %s\n",
1480 open_type == CXUSB_OPEN_ANALOG ?
1481 "analog" : "digital");
1482 }
1483
1484 cxdev->open_ctr = 1;
1485 } else if (cxdev->open_type == open_type) {
1486 cxdev->open_ctr++;
1487 deb_info("acquired %s\n", open_type == CXUSB_OPEN_ANALOG ?
1488 "analog" : "digital");
1489 } else {
1490 ret = -EBUSY;
1491 }
1492
1493 ret_unlock:
1494 mutex_unlock(&cxdev->open_lock);
1495
1496 return ret;
1497 }
1498
1499 void cxusb_medion_put(struct dvb_usb_device *dvbdev)
1500 {
1501 struct cxusb_medion_dev *cxdev = dvbdev->priv;
1502
1503 mutex_lock(&cxdev->open_lock);
1504
1505 if (cxdev->open_type == CXUSB_OPEN_INIT) {
1506 WARN_ON(cxdev->open_ctr != 0);
1507 cxdev->open_type = CXUSB_OPEN_NONE;
1508 goto unlock;
1509 }
1510
1511 if (!WARN_ON(cxdev->open_ctr < 1)) {
1512 cxdev->open_ctr--;
1513
1514 deb_info("release %s\n",
1515 cxdev->open_type == CXUSB_OPEN_ANALOG ?
1516 "analog" : "digital");
1517 }
1518
1519 unlock:
1520 mutex_unlock(&cxdev->open_lock);
1521 }
1522
1523
1524 static struct dvb_usb_device_properties cxusb_medion_properties;
1525 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1526 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1527 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1528 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1529 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1530 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1531 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1532 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1533 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1534 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1535 static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
1536
1537 static int cxusb_medion_priv_init(struct dvb_usb_device *dvbdev)
1538 {
1539 struct cxusb_medion_dev *cxdev = dvbdev->priv;
1540
1541 cxdev->dvbdev = dvbdev;
1542 cxdev->open_type = CXUSB_OPEN_INIT;
1543 mutex_init(&cxdev->open_lock);
1544
1545 return 0;
1546 }
1547
1548 static void cxusb_medion_priv_destroy(struct dvb_usb_device *dvbdev)
1549 {
1550 struct cxusb_medion_dev *cxdev = dvbdev->priv;
1551
1552 mutex_destroy(&cxdev->open_lock);
1553 }
1554
1555 static bool cxusb_medion_check_altsetting(struct usb_host_interface *as)
1556 {
1557 unsigned int ctr;
1558
1559 for (ctr = 0; ctr < as->desc.bNumEndpoints; ctr++) {
1560 if ((as->endpoint[ctr].desc.bEndpointAddress &
1561 USB_ENDPOINT_NUMBER_MASK) != 2)
1562 continue;
1563
1564 if (as->endpoint[ctr].desc.bEndpointAddress & USB_DIR_IN &&
1565 ((as->endpoint[ctr].desc.bmAttributes &
1566 USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC))
1567 return true;
1568
1569 break;
1570 }
1571
1572 return false;
1573 }
1574
1575 static bool cxusb_medion_check_intf(struct usb_interface *intf)
1576 {
1577 unsigned int ctr;
1578
1579 if (intf->num_altsetting < 2) {
1580 dev_err(intf->usb_dev, "no alternate interface");
1581
1582 return false;
1583 }
1584
1585 for (ctr = 0; ctr < intf->num_altsetting; ctr++) {
1586 if (intf->altsetting[ctr].desc.bAlternateSetting != 1)
1587 continue;
1588
1589 if (cxusb_medion_check_altsetting(&intf->altsetting[ctr]))
1590 return true;
1591
1592 break;
1593 }
1594
1595 dev_err(intf->usb_dev, "no iso interface");
1596
1597 return false;
1598 }
1599
1600 static int cxusb_probe(struct usb_interface *intf,
1601 const struct usb_device_id *id)
1602 {
1603 struct dvb_usb_device *dvbdev;
1604 int ret;
1605
1606
1607 if (!dvb_usb_device_init(intf, &cxusb_medion_properties,
1608 THIS_MODULE, &dvbdev, adapter_nr)) {
1609 if (!cxusb_medion_check_intf(intf)) {
1610 ret = -ENODEV;
1611 goto ret_uninit;
1612 }
1613
1614 _cxusb_power_ctrl(dvbdev, 1);
1615 ret = cxusb_medion_set_mode(dvbdev, false);
1616 if (ret)
1617 goto ret_uninit;
1618
1619 ret = cxusb_medion_register_analog(dvbdev);
1620
1621 cxusb_medion_set_mode(dvbdev, true);
1622 _cxusb_power_ctrl(dvbdev, 0);
1623
1624 if (ret != 0)
1625 goto ret_uninit;
1626
1627
1628 cxusb_medion_put(dvbdev);
1629
1630 return 0;
1631 } else if (!dvb_usb_device_init(intf,
1632 &cxusb_bluebird_lgh064f_properties,
1633 THIS_MODULE, NULL, adapter_nr) ||
1634 !dvb_usb_device_init(intf,
1635 &cxusb_bluebird_dee1601_properties,
1636 THIS_MODULE, NULL, adapter_nr) ||
1637 !dvb_usb_device_init(intf,
1638 &cxusb_bluebird_lgz201_properties,
1639 THIS_MODULE, NULL, adapter_nr) ||
1640 !dvb_usb_device_init(intf,
1641 &cxusb_bluebird_dtt7579_properties,
1642 THIS_MODULE, NULL, adapter_nr) ||
1643 !dvb_usb_device_init(intf,
1644 &cxusb_bluebird_dualdig4_properties,
1645 THIS_MODULE, NULL, adapter_nr) ||
1646 !dvb_usb_device_init(intf,
1647 &cxusb_bluebird_nano2_properties,
1648 THIS_MODULE, NULL, adapter_nr) ||
1649 !dvb_usb_device_init(intf,
1650 &cxusb_bluebird_nano2_needsfirmware_properties,
1651 THIS_MODULE, NULL, adapter_nr) ||
1652 !dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1653 THIS_MODULE, NULL, adapter_nr) ||
1654 !dvb_usb_device_init(intf,
1655 &cxusb_bluebird_dualdig4_rev2_properties,
1656 THIS_MODULE, NULL, adapter_nr) ||
1657 !dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1658 THIS_MODULE, NULL, adapter_nr) ||
1659 !dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1660 THIS_MODULE, NULL, adapter_nr) ||
1661 0)
1662 return 0;
1663
1664 return -EINVAL;
1665
1666 ret_uninit:
1667 dvb_usb_device_exit(intf);
1668
1669 return ret;
1670 }
1671
1672 static void cxusb_disconnect(struct usb_interface *intf)
1673 {
1674 struct dvb_usb_device *d = usb_get_intfdata(intf);
1675 struct cxusb_state *st = d->priv;
1676 struct i2c_client *client;
1677
1678 if (d->props.devices[0].warm_ids[0] == &cxusb_table[MEDION_MD95700])
1679 cxusb_medion_unregister_analog(d);
1680
1681
1682 client = st->i2c_client_tuner;
1683 if (client) {
1684 module_put(client->dev.driver->owner);
1685 i2c_unregister_device(client);
1686 }
1687
1688
1689 client = st->i2c_client_demod;
1690 if (client) {
1691 module_put(client->dev.driver->owner);
1692 i2c_unregister_device(client);
1693 }
1694
1695 dvb_usb_device_exit(intf);
1696 }
1697
1698 static struct usb_device_id cxusb_table[NR__cxusb_table_index + 1] = {
1699 [MEDION_MD95700] = {
1700 USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700)
1701 },
1702 [DVICO_BLUEBIRD_LG064F_COLD] = {
1703 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD)
1704 },
1705 [DVICO_BLUEBIRD_LG064F_WARM] = {
1706 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM)
1707 },
1708 [DVICO_BLUEBIRD_DUAL_1_COLD] = {
1709 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD)
1710 },
1711 [DVICO_BLUEBIRD_DUAL_1_WARM] = {
1712 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM)
1713 },
1714 [DVICO_BLUEBIRD_LGZ201_COLD] = {
1715 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD)
1716 },
1717 [DVICO_BLUEBIRD_LGZ201_WARM] = {
1718 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM)
1719 },
1720 [DVICO_BLUEBIRD_TH7579_COLD] = {
1721 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD)
1722 },
1723 [DVICO_BLUEBIRD_TH7579_WARM] = {
1724 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM)
1725 },
1726 [DIGITALNOW_BLUEBIRD_DUAL_1_COLD] = {
1727 USB_DEVICE(USB_VID_DVICO,
1728 USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD)
1729 },
1730 [DIGITALNOW_BLUEBIRD_DUAL_1_WARM] = {
1731 USB_DEVICE(USB_VID_DVICO,
1732 USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM)
1733 },
1734 [DVICO_BLUEBIRD_DUAL_2_COLD] = {
1735 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD)
1736 },
1737 [DVICO_BLUEBIRD_DUAL_2_WARM] = {
1738 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM)
1739 },
1740 [DVICO_BLUEBIRD_DUAL_4] = {
1741 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4)
1742 },
1743 [DVICO_BLUEBIRD_DVB_T_NANO_2] = {
1744 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2)
1745 },
1746 [DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM] = {
1747 USB_DEVICE(USB_VID_DVICO,
1748 USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM)
1749 },
1750 [AVERMEDIA_VOLAR_A868R] = {
1751 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R)
1752 },
1753 [DVICO_BLUEBIRD_DUAL_4_REV_2] = {
1754 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2)
1755 },
1756 [CONEXANT_D680_DMB] = {
1757 USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB)
1758 },
1759 [MYGICA_D689] = {
1760 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689)
1761 },
1762 {}
1763 };
1764 MODULE_DEVICE_TABLE(usb, cxusb_table);
1765
1766 static struct dvb_usb_device_properties cxusb_medion_properties = {
1767 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1768
1769 .usb_ctrl = CYPRESS_FX2,
1770
1771 .size_of_priv = sizeof(struct cxusb_medion_dev),
1772 .priv_init = cxusb_medion_priv_init,
1773 .priv_destroy = cxusb_medion_priv_destroy,
1774
1775 .num_adapters = 1,
1776 .adapter = {
1777 {
1778 .num_frontends = 1,
1779 .fe = {{
1780 .streaming_ctrl = cxusb_streaming_ctrl,
1781 .frontend_attach = cxusb_cx22702_frontend_attach,
1782 .tuner_attach = cxusb_fmd1216me_tuner_attach,
1783
1784 .stream = {
1785 .type = USB_BULK,
1786 .count = 5,
1787 .endpoint = 0x02,
1788 .u = {
1789 .bulk = {
1790 .buffersize = 8192,
1791 }
1792 }
1793 },
1794 } },
1795 },
1796 },
1797 .power_ctrl = cxusb_power_ctrl,
1798
1799 .i2c_algo = &cxusb_i2c_algo,
1800
1801 .generic_bulk_ctrl_endpoint = 0x01,
1802
1803 .num_device_descs = 1,
1804 .devices = {
1805 {
1806 "Medion MD95700 (MDUSBTV-HYBRID)",
1807 { NULL },
1808 { &cxusb_table[MEDION_MD95700], NULL },
1809 },
1810 }
1811 };
1812
1813 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1814 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1815
1816 .usb_ctrl = DEVICE_SPECIFIC,
1817 .firmware = "dvb-usb-bluebird-01.fw",
1818 .download_firmware = bluebird_patch_dvico_firmware_download,
1819
1820
1821
1822
1823
1824 .size_of_priv = sizeof(struct cxusb_state),
1825
1826 .num_adapters = 1,
1827 .adapter = {
1828 {
1829 .num_frontends = 1,
1830 .fe = {{
1831 .streaming_ctrl = cxusb_streaming_ctrl,
1832 .frontend_attach = cxusb_lgdt3303_frontend_attach,
1833 .tuner_attach = cxusb_lgh064f_tuner_attach,
1834
1835
1836 .stream = {
1837 .type = USB_BULK,
1838 .count = 5,
1839 .endpoint = 0x02,
1840 .u = {
1841 .bulk = {
1842 .buffersize = 8192,
1843 }
1844 }
1845 },
1846 } },
1847 },
1848 },
1849
1850 .power_ctrl = cxusb_bluebird_power_ctrl,
1851
1852 .i2c_algo = &cxusb_i2c_algo,
1853
1854 .rc.core = {
1855 .rc_interval = 100,
1856 .rc_codes = RC_MAP_DVICO_PORTABLE,
1857 .module_name = KBUILD_MODNAME,
1858 .rc_query = cxusb_rc_query,
1859 .allowed_protos = RC_PROTO_BIT_NEC,
1860 },
1861
1862 .generic_bulk_ctrl_endpoint = 0x01,
1863
1864 .num_device_descs = 1,
1865 .devices = {
1866 { "DViCO FusionHDTV5 USB Gold",
1867 { &cxusb_table[DVICO_BLUEBIRD_LG064F_COLD], NULL },
1868 { &cxusb_table[DVICO_BLUEBIRD_LG064F_WARM], NULL },
1869 },
1870 }
1871 };
1872
1873 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1874 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1875
1876 .usb_ctrl = DEVICE_SPECIFIC,
1877 .firmware = "dvb-usb-bluebird-01.fw",
1878 .download_firmware = bluebird_patch_dvico_firmware_download,
1879
1880
1881
1882
1883
1884 .size_of_priv = sizeof(struct cxusb_state),
1885
1886 .num_adapters = 1,
1887 .adapter = {
1888 {
1889 .num_frontends = 1,
1890 .fe = {{
1891 .streaming_ctrl = cxusb_streaming_ctrl,
1892 .frontend_attach = cxusb_dee1601_frontend_attach,
1893 .tuner_attach = cxusb_dee1601_tuner_attach,
1894
1895 .stream = {
1896 .type = USB_BULK,
1897 .count = 5,
1898 .endpoint = 0x04,
1899 .u = {
1900 .bulk = {
1901 .buffersize = 8192,
1902 }
1903 }
1904 },
1905 } },
1906 },
1907 },
1908
1909 .power_ctrl = cxusb_bluebird_power_ctrl,
1910
1911 .i2c_algo = &cxusb_i2c_algo,
1912
1913 .rc.core = {
1914 .rc_interval = 100,
1915 .rc_codes = RC_MAP_DVICO_MCE,
1916 .module_name = KBUILD_MODNAME,
1917 .rc_query = cxusb_rc_query,
1918 .allowed_protos = RC_PROTO_BIT_NEC,
1919 },
1920
1921 .generic_bulk_ctrl_endpoint = 0x01,
1922
1923 .num_device_descs = 3,
1924 .devices = {
1925 { "DViCO FusionHDTV DVB-T Dual USB",
1926 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_COLD], NULL },
1927 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_WARM], NULL },
1928 },
1929 { "DigitalNow DVB-T Dual USB",
1930 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_COLD], NULL },
1931 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_WARM], NULL },
1932 },
1933 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1934 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_COLD], NULL },
1935 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_WARM], NULL },
1936 },
1937 }
1938 };
1939
1940 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1941 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1942
1943 .usb_ctrl = DEVICE_SPECIFIC,
1944 .firmware = "dvb-usb-bluebird-01.fw",
1945 .download_firmware = bluebird_patch_dvico_firmware_download,
1946
1947
1948
1949
1950
1951 .size_of_priv = sizeof(struct cxusb_state),
1952
1953 .num_adapters = 2,
1954 .adapter = {
1955 {
1956 .num_frontends = 1,
1957 .fe = {{
1958 .streaming_ctrl = cxusb_streaming_ctrl,
1959 .frontend_attach = cxusb_mt352_frontend_attach,
1960 .tuner_attach = cxusb_lgz201_tuner_attach,
1961
1962
1963 .stream = {
1964 .type = USB_BULK,
1965 .count = 5,
1966 .endpoint = 0x04,
1967 .u = {
1968 .bulk = {
1969 .buffersize = 8192,
1970 }
1971 }
1972 },
1973 } },
1974 },
1975 },
1976 .power_ctrl = cxusb_bluebird_power_ctrl,
1977
1978 .i2c_algo = &cxusb_i2c_algo,
1979
1980 .rc.core = {
1981 .rc_interval = 100,
1982 .rc_codes = RC_MAP_DVICO_PORTABLE,
1983 .module_name = KBUILD_MODNAME,
1984 .rc_query = cxusb_rc_query,
1985 .allowed_protos = RC_PROTO_BIT_NEC,
1986 },
1987
1988 .generic_bulk_ctrl_endpoint = 0x01,
1989 .num_device_descs = 1,
1990 .devices = {
1991 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1992 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_COLD], NULL },
1993 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_WARM], NULL },
1994 },
1995 }
1996 };
1997
1998 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1999 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2000
2001 .usb_ctrl = DEVICE_SPECIFIC,
2002 .firmware = "dvb-usb-bluebird-01.fw",
2003 .download_firmware = bluebird_patch_dvico_firmware_download,
2004
2005
2006
2007
2008
2009
2010 .size_of_priv = sizeof(struct cxusb_state),
2011
2012 .num_adapters = 1,
2013 .adapter = {
2014 {
2015 .num_frontends = 1,
2016 .fe = {{
2017 .streaming_ctrl = cxusb_streaming_ctrl,
2018 .frontend_attach = cxusb_mt352_frontend_attach,
2019 .tuner_attach = cxusb_dtt7579_tuner_attach,
2020
2021
2022 .stream = {
2023 .type = USB_BULK,
2024 .count = 5,
2025 .endpoint = 0x04,
2026 .u = {
2027 .bulk = {
2028 .buffersize = 8192,
2029 }
2030 }
2031 },
2032 } },
2033 },
2034 },
2035 .power_ctrl = cxusb_bluebird_power_ctrl,
2036
2037 .i2c_algo = &cxusb_i2c_algo,
2038
2039 .rc.core = {
2040 .rc_interval = 100,
2041 .rc_codes = RC_MAP_DVICO_PORTABLE,
2042 .module_name = KBUILD_MODNAME,
2043 .rc_query = cxusb_rc_query,
2044 .allowed_protos = RC_PROTO_BIT_NEC,
2045 },
2046
2047 .generic_bulk_ctrl_endpoint = 0x01,
2048
2049 .num_device_descs = 1,
2050 .devices = {
2051 { "DViCO FusionHDTV DVB-T USB (TH7579)",
2052 { &cxusb_table[DVICO_BLUEBIRD_TH7579_COLD], NULL },
2053 { &cxusb_table[DVICO_BLUEBIRD_TH7579_WARM], NULL },
2054 },
2055 }
2056 };
2057
2058 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
2059 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2060
2061 .usb_ctrl = CYPRESS_FX2,
2062
2063 .size_of_priv = sizeof(struct cxusb_state),
2064
2065 .num_adapters = 1,
2066 .adapter = {
2067 {
2068 .num_frontends = 1,
2069 .fe = {{
2070 .streaming_ctrl = cxusb_streaming_ctrl,
2071 .frontend_attach = cxusb_dualdig4_frontend_attach,
2072 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
2073
2074 .stream = {
2075 .type = USB_BULK,
2076 .count = 5,
2077 .endpoint = 0x02,
2078 .u = {
2079 .bulk = {
2080 .buffersize = 8192,
2081 }
2082 }
2083 },
2084 } },
2085 },
2086 },
2087
2088 .power_ctrl = cxusb_power_ctrl,
2089
2090 .i2c_algo = &cxusb_i2c_algo,
2091
2092 .generic_bulk_ctrl_endpoint = 0x01,
2093
2094 .rc.core = {
2095 .rc_interval = 100,
2096 .rc_codes = RC_MAP_DVICO_MCE,
2097 .module_name = KBUILD_MODNAME,
2098 .rc_query = cxusb_bluebird2_rc_query,
2099 .allowed_protos = RC_PROTO_BIT_NEC,
2100 },
2101
2102 .num_device_descs = 1,
2103 .devices = {
2104 { "DViCO FusionHDTV DVB-T Dual Digital 4",
2105 { NULL },
2106 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4], NULL },
2107 },
2108 }
2109 };
2110
2111 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
2112 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2113
2114 .usb_ctrl = CYPRESS_FX2,
2115 .identify_state = bluebird_fx2_identify_state,
2116
2117 .size_of_priv = sizeof(struct cxusb_state),
2118
2119 .num_adapters = 1,
2120 .adapter = {
2121 {
2122 .num_frontends = 1,
2123 .fe = {{
2124 .streaming_ctrl = cxusb_streaming_ctrl,
2125 .frontend_attach = cxusb_nano2_frontend_attach,
2126 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
2127
2128 .stream = {
2129 .type = USB_BULK,
2130 .count = 5,
2131 .endpoint = 0x02,
2132 .u = {
2133 .bulk = {
2134 .buffersize = 8192,
2135 }
2136 }
2137 },
2138 } },
2139 },
2140 },
2141
2142 .power_ctrl = cxusb_nano2_power_ctrl,
2143
2144 .i2c_algo = &cxusb_i2c_algo,
2145
2146 .generic_bulk_ctrl_endpoint = 0x01,
2147
2148 .rc.core = {
2149 .rc_interval = 100,
2150 .rc_codes = RC_MAP_DVICO_PORTABLE,
2151 .module_name = KBUILD_MODNAME,
2152 .rc_query = cxusb_bluebird2_rc_query,
2153 .allowed_protos = RC_PROTO_BIT_NEC,
2154 },
2155
2156 .num_device_descs = 1,
2157 .devices = {
2158 { "DViCO FusionHDTV DVB-T NANO2",
2159 { NULL },
2160 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
2161 },
2162 }
2163 };
2164
2165 static struct dvb_usb_device_properties
2166 cxusb_bluebird_nano2_needsfirmware_properties = {
2167 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2168
2169 .usb_ctrl = DEVICE_SPECIFIC,
2170 .firmware = "dvb-usb-bluebird-02.fw",
2171 .download_firmware = bluebird_patch_dvico_firmware_download,
2172 .identify_state = bluebird_fx2_identify_state,
2173
2174 .size_of_priv = sizeof(struct cxusb_state),
2175
2176 .num_adapters = 1,
2177 .adapter = {
2178 {
2179 .num_frontends = 1,
2180 .fe = {{
2181 .streaming_ctrl = cxusb_streaming_ctrl,
2182 .frontend_attach = cxusb_nano2_frontend_attach,
2183 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
2184
2185 .stream = {
2186 .type = USB_BULK,
2187 .count = 5,
2188 .endpoint = 0x02,
2189 .u = {
2190 .bulk = {
2191 .buffersize = 8192,
2192 }
2193 }
2194 },
2195 } },
2196 },
2197 },
2198
2199 .power_ctrl = cxusb_nano2_power_ctrl,
2200
2201 .i2c_algo = &cxusb_i2c_algo,
2202
2203 .generic_bulk_ctrl_endpoint = 0x01,
2204
2205 .rc.core = {
2206 .rc_interval = 100,
2207 .rc_codes = RC_MAP_DVICO_PORTABLE,
2208 .module_name = KBUILD_MODNAME,
2209 .rc_query = cxusb_rc_query,
2210 .allowed_protos = RC_PROTO_BIT_NEC,
2211 },
2212
2213 .num_device_descs = 1,
2214 .devices = { {
2215 "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
2216 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
2217 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM],
2218 NULL },
2219 },
2220 }
2221 };
2222
2223 static struct dvb_usb_device_properties cxusb_aver_a868r_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 .num_frontends = 1,
2234 .fe = {{
2235 .streaming_ctrl = cxusb_aver_streaming_ctrl,
2236 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
2237 .tuner_attach = cxusb_mxl5003s_tuner_attach,
2238
2239 .stream = {
2240 .type = USB_BULK,
2241 .count = 5,
2242 .endpoint = 0x04,
2243 .u = {
2244 .bulk = {
2245 .buffersize = 8192,
2246 }
2247 }
2248 },
2249 } },
2250 },
2251 },
2252 .power_ctrl = cxusb_aver_power_ctrl,
2253
2254 .i2c_algo = &cxusb_i2c_algo,
2255
2256 .generic_bulk_ctrl_endpoint = 0x01,
2257
2258 .num_device_descs = 1,
2259 .devices = {
2260 { "AVerMedia AVerTVHD Volar (A868R)",
2261 { NULL },
2262 { &cxusb_table[AVERMEDIA_VOLAR_A868R], NULL },
2263 },
2264 }
2265 };
2266
2267 static
2268 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
2269 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2270
2271 .usb_ctrl = CYPRESS_FX2,
2272
2273 .size_of_priv = sizeof(struct cxusb_state),
2274
2275 .num_adapters = 1,
2276 .adapter = {
2277 {
2278 .size_of_priv = sizeof(struct dib0700_adapter_state),
2279 .num_frontends = 1,
2280 .fe = {{
2281 .streaming_ctrl = cxusb_streaming_ctrl,
2282 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
2283 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
2284
2285 .stream = {
2286 .type = USB_BULK,
2287 .count = 7,
2288 .endpoint = 0x02,
2289 .u = {
2290 .bulk = {
2291 .buffersize = 4096,
2292 }
2293 }
2294 },
2295 } },
2296 },
2297 },
2298
2299 .power_ctrl = cxusb_bluebird_power_ctrl,
2300
2301 .i2c_algo = &cxusb_i2c_algo,
2302
2303 .generic_bulk_ctrl_endpoint = 0x01,
2304
2305 .rc.core = {
2306 .rc_interval = 100,
2307 .rc_codes = RC_MAP_DVICO_MCE,
2308 .module_name = KBUILD_MODNAME,
2309 .rc_query = cxusb_rc_query,
2310 .allowed_protos = RC_PROTO_BIT_NEC,
2311 },
2312
2313 .num_device_descs = 1,
2314 .devices = {
2315 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
2316 { NULL },
2317 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4_REV_2], NULL },
2318 },
2319 }
2320 };
2321
2322 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
2323 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2324
2325 .usb_ctrl = CYPRESS_FX2,
2326
2327 .size_of_priv = sizeof(struct cxusb_state),
2328
2329 .num_adapters = 1,
2330 .adapter = {
2331 {
2332 .num_frontends = 1,
2333 .fe = {{
2334 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2335 .frontend_attach = cxusb_d680_dmb_frontend_attach,
2336 .tuner_attach = cxusb_d680_dmb_tuner_attach,
2337
2338
2339 .stream = {
2340 .type = USB_BULK,
2341 .count = 5,
2342 .endpoint = 0x02,
2343 .u = {
2344 .bulk = {
2345 .buffersize = 8192,
2346 }
2347 }
2348 },
2349 } },
2350 },
2351 },
2352
2353 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2354
2355 .i2c_algo = &cxusb_i2c_algo,
2356
2357 .generic_bulk_ctrl_endpoint = 0x01,
2358
2359 .rc.core = {
2360 .rc_interval = 100,
2361 .rc_codes = RC_MAP_TOTAL_MEDIA_IN_HAND_02,
2362 .module_name = KBUILD_MODNAME,
2363 .rc_query = cxusb_d680_dmb_rc_query,
2364 .allowed_protos = RC_PROTO_BIT_UNKNOWN,
2365 },
2366
2367 .num_device_descs = 1,
2368 .devices = {
2369 {
2370 "Conexant DMB-TH Stick",
2371 { NULL },
2372 { &cxusb_table[CONEXANT_D680_DMB], NULL },
2373 },
2374 }
2375 };
2376
2377 static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
2378 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2379
2380 .usb_ctrl = CYPRESS_FX2,
2381
2382 .size_of_priv = sizeof(struct cxusb_state),
2383
2384 .num_adapters = 1,
2385 .adapter = {
2386 {
2387 .num_frontends = 1,
2388 .fe = {{
2389 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2390 .frontend_attach = cxusb_mygica_d689_frontend_attach,
2391 .tuner_attach = cxusb_mygica_d689_tuner_attach,
2392
2393
2394 .stream = {
2395 .type = USB_BULK,
2396 .count = 5,
2397 .endpoint = 0x02,
2398 .u = {
2399 .bulk = {
2400 .buffersize = 8192,
2401 }
2402 }
2403 },
2404 } },
2405 },
2406 },
2407
2408 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2409
2410 .i2c_algo = &cxusb_i2c_algo,
2411
2412 .generic_bulk_ctrl_endpoint = 0x01,
2413
2414 .rc.core = {
2415 .rc_interval = 100,
2416 .rc_codes = RC_MAP_D680_DMB,
2417 .module_name = KBUILD_MODNAME,
2418 .rc_query = cxusb_d680_dmb_rc_query,
2419 .allowed_protos = RC_PROTO_BIT_UNKNOWN,
2420 },
2421
2422 .num_device_descs = 1,
2423 .devices = {
2424 {
2425 "Mygica D689 DMB-TH",
2426 { NULL },
2427 { &cxusb_table[MYGICA_D689], NULL },
2428 },
2429 }
2430 };
2431
2432 static struct usb_driver cxusb_driver = {
2433 .name = "dvb_usb_cxusb",
2434 .probe = cxusb_probe,
2435 .disconnect = cxusb_disconnect,
2436 .id_table = cxusb_table,
2437 };
2438
2439 module_usb_driver(cxusb_driver);
2440
2441 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2442 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
2443 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
2444 MODULE_AUTHOR("Maciej S. Szmigiero <mail@maciej.szmigiero.name>");
2445 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2446 MODULE_LICENSE("GPL");