?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: qmi_wwan: add Olivetti Olicard 500
[linux/fpc-iii.git] / drivers / media / usb / dvb-usb / cxusb.c
bloba1c641e18362ad288ebd1972c389831d2abb1db3
1 /* DVB USB compliant linux driver for Conexant USB reference design.
2 *
3 * The Conexant reference design I saw on their website was only for analogue
4 * capturing (using the cx25842). The box I took to write this driver (reverse
5 * engineered) is the one labeled Medion MD95700. In addition to the cx25842
6 * for analogue capturing it also has a cx22702 DVB-T demodulator on the main
7 * board. Besides it has a atiremote (X10) and a USB2.0 hub onboard.
8 *
9 * Maybe it is a little bit premature to call this driver cxusb, but I assume
10 * the USB protocol is identical or at least inherited from the reference
11 * design, so it can be reused for the "analogue-only" device (if it will
12 * appear at all).
13 *
14 * TODO: Use the cx25840-driver for the analogue part
15 *
16 * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de)
17 * Copyright (C) 2006 Michael Krufky (mkrufky@linuxtv.org)
18 * Copyright (C) 2006, 2007 Chris Pascoe (c.pascoe@itee.uq.edu.au)
19 *
20 * This program is free software; you can redistribute it and/or modify it
21 * under the terms of the GNU General Public License as published by the Free
22 * Software Foundation, version 2.
23 *
24 * see Documentation/dvb/README.dvb-usb for more information
25 */
26 #include <media/tuner.h>
27 #include <linux/vmalloc.h>
28 #include <linux/slab.h>
29
30 #include "cxusb.h"
31
32 #include "cx22702.h"
33 #include "lgdt330x.h"
34 #include "mt352.h"
35 #include "mt352_priv.h"
36 #include "zl10353.h"
37 #include "tuner-xc2028.h"
38 #include "tuner-simple.h"
39 #include "mxl5005s.h"
40 #include "max2165.h"
41 #include "dib7000p.h"
42 #include "dib0070.h"
43 #include "lgs8gxx.h"
44 #include "atbm8830.h"
45
46 /* Max transfer size done by I2C transfer functions */
47 #define MAX_XFER_SIZE 64
48
49 /* debug */
50 static int dvb_usb_cxusb_debug;
51 module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
52 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
53
54 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
55
56 #define deb_info(args...) dprintk(dvb_usb_cxusb_debug, 0x03, args)
57 #define deb_i2c(args...) dprintk(dvb_usb_cxusb_debug, 0x02, args)
58
59 static int cxusb_ctrl_msg(struct dvb_usb_device *d,
60 u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
61 {
62 int wo = (rbuf == NULL || rlen == 0); /* write-only */
63 u8 sndbuf[MAX_XFER_SIZE];
64
65 if (1 + wlen > sizeof(sndbuf)) {
66 warn("i2c wr: len=%d is too big!\n",
67 wlen);
68 return -EOPNOTSUPP;
69 }
70
71 memset(sndbuf, 0, 1+wlen);
72
73 sndbuf[0] = cmd;
74 memcpy(&sndbuf[1], wbuf, wlen);
75 if (wo)
76 return dvb_usb_generic_write(d, sndbuf, 1+wlen);
77 else
78 return dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0);
79 }
80
81 /* GPIO */
82 static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
83 {
84 struct cxusb_state *st = d->priv;
85 u8 o[2], i;
86
87 if (st->gpio_write_state[GPIO_TUNER] == onoff)
88 return;
89
90 o[0] = GPIO_TUNER;
91 o[1] = onoff;
92 cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
93
94 if (i != 0x01)
95 deb_info("gpio_write failed.\n");
96
97 st->gpio_write_state[GPIO_TUNER] = onoff;
98 }
99
100 static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask,
101 u8 newval)
102 {
103 u8 o[2], gpio_state;
104 int rc;
105
106 o[0] = 0xff & ~changemask; /* mask of bits to keep */
107 o[1] = newval & changemask; /* new values for bits */
108
109 rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, o, 2, &gpio_state, 1);
110 if (rc < 0 || (gpio_state & changemask) != (newval & changemask))
111 deb_info("bluebird_gpio_write failed.\n");
112
113 return rc < 0 ? rc : gpio_state;
114 }
115
116 static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low)
117 {
118 cxusb_bluebird_gpio_rw(d, pin, low ? 0 : pin);
119 msleep(5);
120 cxusb_bluebird_gpio_rw(d, pin, low ? pin : 0);
121 }
122
123 static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
124 {
125 cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40);
126 }
127
128 static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
129 u8 addr, int onoff)
130 {
131 u8 o[2] = {addr, onoff};
132 u8 i;
133 int rc;
134
135 rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
136
137 if (rc < 0)
138 return rc;
139 if (i == 0x01)
140 return 0;
141 else {
142 deb_info("gpio_write failed.\n");
143 return -EIO;
144 }
145 }
146
147 /* I2C */
148 static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
149 int num)
150 {
151 struct dvb_usb_device *d = i2c_get_adapdata(adap);
152 int ret;
153 int i;
154
155 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
156 return -EAGAIN;
157
158 for (i = 0; i < num; i++) {
159
160 if (d->udev->descriptor.idVendor == USB_VID_MEDION)
161 switch (msg[i].addr) {
162 case 0x63:
163 cxusb_gpio_tuner(d, 0);
164 break;
165 default:
166 cxusb_gpio_tuner(d, 1);
167 break;
168 }
169
170 if (msg[i].flags & I2C_M_RD) {
171 /* read only */
172 u8 obuf[3], ibuf[MAX_XFER_SIZE];
173
174 if (1 + msg[i].len > sizeof(ibuf)) {
175 warn("i2c rd: len=%d is too big!\n",
176 msg[i].len);
177 ret = -EOPNOTSUPP;
178 goto unlock;
179 }
180 obuf[0] = 0;
181 obuf[1] = msg[i].len;
182 obuf[2] = msg[i].addr;
183 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
184 obuf, 3,
185 ibuf, 1+msg[i].len) < 0) {
186 warn("i2c read failed");
187 break;
188 }
189 memcpy(msg[i].buf, &ibuf[1], msg[i].len);
190 } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) &&
191 msg[i].addr == msg[i+1].addr) {
192 /* write to then read from same address */
193 u8 obuf[MAX_XFER_SIZE], ibuf[MAX_XFER_SIZE];
194
195 if (3 + msg[i].len > sizeof(obuf)) {
196 warn("i2c wr: len=%d is too big!\n",
197 msg[i].len);
198 ret = -EOPNOTSUPP;
199 goto unlock;
200 }
201 if (1 + msg[i + 1].len > sizeof(ibuf)) {
202 warn("i2c rd: len=%d is too big!\n",
203 msg[i + 1].len);
204 ret = -EOPNOTSUPP;
205 goto unlock;
206 }
207 obuf[0] = msg[i].len;
208 obuf[1] = msg[i+1].len;
209 obuf[2] = msg[i].addr;
210 memcpy(&obuf[3], msg[i].buf, msg[i].len);
211
212 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
213 obuf, 3+msg[i].len,
214 ibuf, 1+msg[i+1].len) < 0)
215 break;
216
217 if (ibuf[0] != 0x08)
218 deb_i2c("i2c read may have failed\n");
219
220 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
221
222 i++;
223 } else {
224 /* write only */
225 u8 obuf[MAX_XFER_SIZE], ibuf;
226
227 if (2 + msg[i].len > sizeof(obuf)) {
228 warn("i2c wr: len=%d is too big!\n",
229 msg[i].len);
230 ret = -EOPNOTSUPP;
231 goto unlock;
232 }
233 obuf[0] = msg[i].addr;
234 obuf[1] = msg[i].len;
235 memcpy(&obuf[2], msg[i].buf, msg[i].len);
236
237 if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
238 2+msg[i].len, &ibuf,1) < 0)
239 break;
240 if (ibuf != 0x08)
241 deb_i2c("i2c write may have failed\n");
242 }
243 }
244
245 if (i == num)
246 ret = num;
247 else
248 ret = -EREMOTEIO;
249
250 unlock:
251 mutex_unlock(&d->i2c_mutex);
252 return ret;
253 }
254
255 static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
256 {
257 return I2C_FUNC_I2C;
258 }
259
260 static struct i2c_algorithm cxusb_i2c_algo = {
261 .master_xfer = cxusb_i2c_xfer,
262 .functionality = cxusb_i2c_func,
263 };
264
265 static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
266 {
267 u8 b = 0;
268 if (onoff)
269 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
270 else
271 return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0);
272 }
273
274 static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff)
275 {
276 int ret;
277 if (!onoff)
278 return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, 0, NULL, 0);
279 if (d->state == DVB_USB_STATE_INIT &&
280 usb_set_interface(d->udev, 0, 0) < 0)
281 err("set interface failed");
282 do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) &&
283 !(ret = cxusb_ctrl_msg(d, 0x15, NULL, 0, NULL, 0)) &&
284 !(ret = cxusb_ctrl_msg(d, 0x17, NULL, 0, NULL, 0)) && 0);
285 if (!ret) {
286 /* FIXME: We don't know why, but we need to configure the
287 * lgdt3303 with the register settings below on resume */
288 int i;
289 u8 buf, bufs[] = {
290 0x0e, 0x2, 0x00, 0x7f,
291 0x0e, 0x2, 0x02, 0xfe,
292 0x0e, 0x2, 0x02, 0x01,
293 0x0e, 0x2, 0x00, 0x03,
294 0x0e, 0x2, 0x0d, 0x40,
295 0x0e, 0x2, 0x0e, 0x87,
296 0x0e, 0x2, 0x0f, 0x8e,
297 0x0e, 0x2, 0x10, 0x01,
298 0x0e, 0x2, 0x14, 0xd7,
299 0x0e, 0x2, 0x47, 0x88,
300 };
301 msleep(20);
302 for (i = 0; i < sizeof(bufs)/sizeof(u8); i += 4/sizeof(u8)) {
303 ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE,
304 bufs+i, 4, &buf, 1);
305 if (ret)
306 break;
307 if (buf != 0x8)
308 return -EREMOTEIO;
309 }
310 }
311 return ret;
312 }
313
314 static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
315 {
316 u8 b = 0;
317 if (onoff)
318 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
319 else
320 return 0;
321 }
322
323 static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff)
324 {
325 int rc = 0;
326
327 rc = cxusb_power_ctrl(d, onoff);
328 if (!onoff)
329 cxusb_nano2_led(d, 0);
330
331 return rc;
332 }
333
334 static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device *d, int onoff)
335 {
336 int ret;
337 u8 b;
338 ret = cxusb_power_ctrl(d, onoff);
339 if (!onoff)
340 return ret;
341
342 msleep(128);
343 cxusb_ctrl_msg(d, CMD_DIGITAL, NULL, 0, &b, 1);
344 msleep(100);
345 return ret;
346 }
347
348 static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
349 {
350 u8 buf[2] = { 0x03, 0x00 };
351 if (onoff)
352 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
353 else
354 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
355
356 return 0;
357 }
358
359 static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
360 {
361 if (onoff)
362 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_ON, NULL, 0, NULL, 0);
363 else
364 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_OFF,
365 NULL, 0, NULL, 0);
366 return 0;
367 }
368
369 static void cxusb_d680_dmb_drain_message(struct dvb_usb_device *d)
370 {
371 int ep = d->props.generic_bulk_ctrl_endpoint;
372 const int timeout = 100;
373 const int junk_len = 32;
374 u8 *junk;
375 int rd_count;
376
377 /* Discard remaining data in video pipe */
378 junk = kmalloc(junk_len, GFP_KERNEL);
379 if (!junk)
380 return;
381 while (1) {
382 if (usb_bulk_msg(d->udev,
383 usb_rcvbulkpipe(d->udev, ep),
384 junk, junk_len, &rd_count, timeout) < 0)
385 break;
386 if (!rd_count)
387 break;
388 }
389 kfree(junk);
390 }
391
392 static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d)
393 {
394 struct usb_data_stream_properties *p = &d->props.adapter[0].fe[0].stream;
395 const int timeout = 100;
396 const int junk_len = p->u.bulk.buffersize;
397 u8 *junk;
398 int rd_count;
399
400 /* Discard remaining data in video pipe */
401 junk = kmalloc(junk_len, GFP_KERNEL);
402 if (!junk)
403 return;
404 while (1) {
405 if (usb_bulk_msg(d->udev,
406 usb_rcvbulkpipe(d->udev, p->endpoint),
407 junk, junk_len, &rd_count, timeout) < 0)
408 break;
409 if (!rd_count)
410 break;
411 }
412 kfree(junk);
413 }
414
415 static int cxusb_d680_dmb_streaming_ctrl(
416 struct dvb_usb_adapter *adap, int onoff)
417 {
418 if (onoff) {
419 u8 buf[2] = { 0x03, 0x00 };
420 cxusb_d680_dmb_drain_video(adap->dev);
421 return cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON,
422 buf, sizeof(buf), NULL, 0);
423 } else {
424 int ret = cxusb_ctrl_msg(adap->dev,
425 CMD_STREAMING_OFF, NULL, 0, NULL, 0);
426 return ret;
427 }
428 }
429
430 static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
431 {
432 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
433 u8 ircode[4];
434 int i;
435
436 cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
437
438 *event = 0;
439 *state = REMOTE_NO_KEY_PRESSED;
440
441 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
442 if (rc5_custom(&keymap[i]) == ircode[2] &&
443 rc5_data(&keymap[i]) == ircode[3]) {
444 *event = keymap[i].keycode;
445 *state = REMOTE_KEY_PRESSED;
446
447 return 0;
448 }
449 }
450
451 return 0;
452 }
453
454 static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
455 int *state)
456 {
457 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
458 u8 ircode[4];
459 int i;
460 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
461 .buf = ircode, .len = 4 };
462
463 *event = 0;
464 *state = REMOTE_NO_KEY_PRESSED;
465
466 if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
467 return 0;
468
469 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
470 if (rc5_custom(&keymap[i]) == ircode[1] &&
471 rc5_data(&keymap[i]) == ircode[2]) {
472 *event = keymap[i].keycode;
473 *state = REMOTE_KEY_PRESSED;
474
475 return 0;
476 }
477 }
478
479 return 0;
480 }
481
482 static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
483 int *state)
484 {
485 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
486 u8 ircode[2];
487 int i;
488
489 *event = 0;
490 *state = REMOTE_NO_KEY_PRESSED;
491
492 if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0)
493 return 0;
494
495 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
496 if (rc5_custom(&keymap[i]) == ircode[0] &&
497 rc5_data(&keymap[i]) == ircode[1]) {
498 *event = keymap[i].keycode;
499 *state = REMOTE_KEY_PRESSED;
500
501 return 0;
502 }
503 }
504
505 return 0;
506 }
507
508 static struct rc_map_table rc_map_dvico_mce_table[] = {
509 { 0xfe02, KEY_TV },
510 { 0xfe0e, KEY_MP3 },
511 { 0xfe1a, KEY_DVD },
512 { 0xfe1e, KEY_FAVORITES },
513 { 0xfe16, KEY_SETUP },
514 { 0xfe46, KEY_POWER2 },
515 { 0xfe0a, KEY_EPG },
516 { 0xfe49, KEY_BACK },
517 { 0xfe4d, KEY_MENU },
518 { 0xfe51, KEY_UP },
519 { 0xfe5b, KEY_LEFT },
520 { 0xfe5f, KEY_RIGHT },
521 { 0xfe53, KEY_DOWN },
522 { 0xfe5e, KEY_OK },
523 { 0xfe59, KEY_INFO },
524 { 0xfe55, KEY_TAB },
525 { 0xfe0f, KEY_PREVIOUSSONG },/* Replay */
526 { 0xfe12, KEY_NEXTSONG }, /* Skip */
527 { 0xfe42, KEY_ENTER }, /* Windows/Start */
528 { 0xfe15, KEY_VOLUMEUP },
529 { 0xfe05, KEY_VOLUMEDOWN },
530 { 0xfe11, KEY_CHANNELUP },
531 { 0xfe09, KEY_CHANNELDOWN },
532 { 0xfe52, KEY_CAMERA },
533 { 0xfe5a, KEY_TUNER }, /* Live */
534 { 0xfe19, KEY_OPEN },
535 { 0xfe0b, KEY_1 },
536 { 0xfe17, KEY_2 },
537 { 0xfe1b, KEY_3 },
538 { 0xfe07, KEY_4 },
539 { 0xfe50, KEY_5 },
540 { 0xfe54, KEY_6 },
541 { 0xfe48, KEY_7 },
542 { 0xfe4c, KEY_8 },
543 { 0xfe58, KEY_9 },
544 { 0xfe13, KEY_ANGLE }, /* Aspect */
545 { 0xfe03, KEY_0 },
546 { 0xfe1f, KEY_ZOOM },
547 { 0xfe43, KEY_REWIND },
548 { 0xfe47, KEY_PLAYPAUSE },
549 { 0xfe4f, KEY_FASTFORWARD },
550 { 0xfe57, KEY_MUTE },
551 { 0xfe0d, KEY_STOP },
552 { 0xfe01, KEY_RECORD },
553 { 0xfe4e, KEY_POWER },
554 };
555
556 static struct rc_map_table rc_map_dvico_portable_table[] = {
557 { 0xfc02, KEY_SETUP }, /* Profile */
558 { 0xfc43, KEY_POWER2 },
559 { 0xfc06, KEY_EPG },
560 { 0xfc5a, KEY_BACK },
561 { 0xfc05, KEY_MENU },
562 { 0xfc47, KEY_INFO },
563 { 0xfc01, KEY_TAB },
564 { 0xfc42, KEY_PREVIOUSSONG },/* Replay */
565 { 0xfc49, KEY_VOLUMEUP },
566 { 0xfc09, KEY_VOLUMEDOWN },
567 { 0xfc54, KEY_CHANNELUP },
568 { 0xfc0b, KEY_CHANNELDOWN },
569 { 0xfc16, KEY_CAMERA },
570 { 0xfc40, KEY_TUNER }, /* ATV/DTV */
571 { 0xfc45, KEY_OPEN },
572 { 0xfc19, KEY_1 },
573 { 0xfc18, KEY_2 },
574 { 0xfc1b, KEY_3 },
575 { 0xfc1a, KEY_4 },
576 { 0xfc58, KEY_5 },
577 { 0xfc59, KEY_6 },
578 { 0xfc15, KEY_7 },
579 { 0xfc14, KEY_8 },
580 { 0xfc17, KEY_9 },
581 { 0xfc44, KEY_ANGLE }, /* Aspect */
582 { 0xfc55, KEY_0 },
583 { 0xfc07, KEY_ZOOM },
584 { 0xfc0a, KEY_REWIND },
585 { 0xfc08, KEY_PLAYPAUSE },
586 { 0xfc4b, KEY_FASTFORWARD },
587 { 0xfc5b, KEY_MUTE },
588 { 0xfc04, KEY_STOP },
589 { 0xfc56, KEY_RECORD },
590 { 0xfc57, KEY_POWER },
591 { 0xfc41, KEY_UNKNOWN }, /* INPUT */
592 { 0xfc00, KEY_UNKNOWN }, /* HD */
593 };
594
595 static struct rc_map_table rc_map_d680_dmb_table[] = {
596 { 0x0038, KEY_UNKNOWN }, /* TV/AV */
597 { 0x080c, KEY_ZOOM },
598 { 0x0800, KEY_0 },
599 { 0x0001, KEY_1 },
600 { 0x0802, KEY_2 },
601 { 0x0003, KEY_3 },
602 { 0x0804, KEY_4 },
603 { 0x0005, KEY_5 },
604 { 0x0806, KEY_6 },
605 { 0x0007, KEY_7 },
606 { 0x0808, KEY_8 },
607 { 0x0009, KEY_9 },
608 { 0x000a, KEY_MUTE },
609 { 0x0829, KEY_BACK },
610 { 0x0012, KEY_CHANNELUP },
611 { 0x0813, KEY_CHANNELDOWN },
612 { 0x002b, KEY_VOLUMEUP },
613 { 0x082c, KEY_VOLUMEDOWN },
614 { 0x0020, KEY_UP },
615 { 0x0821, KEY_DOWN },
616 { 0x0011, KEY_LEFT },
617 { 0x0810, KEY_RIGHT },
618 { 0x000d, KEY_OK },
619 { 0x081f, KEY_RECORD },
620 { 0x0017, KEY_PLAYPAUSE },
621 { 0x0816, KEY_PLAYPAUSE },
622 { 0x000b, KEY_STOP },
623 { 0x0827, KEY_FASTFORWARD },
624 { 0x0026, KEY_REWIND },
625 { 0x081e, KEY_UNKNOWN }, /* Time Shift */
626 { 0x000e, KEY_UNKNOWN }, /* Snapshot */
627 { 0x082d, KEY_UNKNOWN }, /* Mouse Cursor */
628 { 0x000f, KEY_UNKNOWN }, /* Minimize/Maximize */
629 { 0x0814, KEY_UNKNOWN }, /* Shuffle */
630 { 0x0025, KEY_POWER },
631 };
632
633 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
634 {
635 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 };
636 static u8 reset [] = { RESET, 0x80 };
637 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
638 static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 };
639 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
640 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
641
642 mt352_write(fe, clock_config, sizeof(clock_config));
643 udelay(200);
644 mt352_write(fe, reset, sizeof(reset));
645 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
646
647 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
648 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
649 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
650
651 return 0;
652 }
653
654 static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
655 { /* used in both lgz201 and th7579 */
656 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 };
657 static u8 reset [] = { RESET, 0x80 };
658 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
659 static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 };
660 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
661 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
662
663 mt352_write(fe, clock_config, sizeof(clock_config));
664 udelay(200);
665 mt352_write(fe, reset, sizeof(reset));
666 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
667
668 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
669 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
670 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
671 return 0;
672 }
673
674 static struct cx22702_config cxusb_cx22702_config = {
675 .demod_address = 0x63,
676 .output_mode = CX22702_PARALLEL_OUTPUT,
677 };
678
679 static struct lgdt330x_config cxusb_lgdt3303_config = {
680 .demod_address = 0x0e,
681 .demod_chip = LGDT3303,
682 };
683
684 static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
685 .demod_address = 0x0e,
686 .demod_chip = LGDT3303,
687 .clock_polarity_flip = 2,
688 };
689
690 static struct mt352_config cxusb_dee1601_config = {
691 .demod_address = 0x0f,
692 .demod_init = cxusb_dee1601_demod_init,
693 };
694
695 static struct zl10353_config cxusb_zl10353_dee1601_config = {
696 .demod_address = 0x0f,
697 .parallel_ts = 1,
698 };
699
700 static struct mt352_config cxusb_mt352_config = {
701 /* used in both lgz201 and th7579 */
702 .demod_address = 0x0f,
703 .demod_init = cxusb_mt352_demod_init,
704 };
705
706 static struct zl10353_config cxusb_zl10353_xc3028_config = {
707 .demod_address = 0x0f,
708 .if2 = 45600,
709 .no_tuner = 1,
710 .parallel_ts = 1,
711 };
712
713 static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
714 .demod_address = 0x0f,
715 .if2 = 45600,
716 .no_tuner = 1,
717 .parallel_ts = 1,
718 .disable_i2c_gate_ctrl = 1,
719 };
720
721 static struct mt352_config cxusb_mt352_xc3028_config = {
722 .demod_address = 0x0f,
723 .if2 = 4560,
724 .no_tuner = 1,
725 .demod_init = cxusb_mt352_demod_init,
726 };
727
728 /* FIXME: needs tweaking */
729 static struct mxl5005s_config aver_a868r_tuner = {
730 .i2c_address = 0x63,
731 .if_freq = 6000000UL,
732 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
733 .agc_mode = MXL_SINGLE_AGC,
734 .tracking_filter = MXL_TF_C,
735 .rssi_enable = MXL_RSSI_ENABLE,
736 .cap_select = MXL_CAP_SEL_ENABLE,
737 .div_out = MXL_DIV_OUT_4,
738 .clock_out = MXL_CLOCK_OUT_DISABLE,
739 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
740 .top = MXL5005S_TOP_25P2,
741 .mod_mode = MXL_DIGITAL_MODE,
742 .if_mode = MXL_ZERO_IF,
743 .AgcMasterByte = 0x00,
744 };
745
746 /* FIXME: needs tweaking */
747 static struct mxl5005s_config d680_dmb_tuner = {
748 .i2c_address = 0x63,
749 .if_freq = 36125000UL,
750 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
751 .agc_mode = MXL_SINGLE_AGC,
752 .tracking_filter = MXL_TF_C,
753 .rssi_enable = MXL_RSSI_ENABLE,
754 .cap_select = MXL_CAP_SEL_ENABLE,
755 .div_out = MXL_DIV_OUT_4,
756 .clock_out = MXL_CLOCK_OUT_DISABLE,
757 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
758 .top = MXL5005S_TOP_25P2,
759 .mod_mode = MXL_DIGITAL_MODE,
760 .if_mode = MXL_ZERO_IF,
761 .AgcMasterByte = 0x00,
762 };
763
764 static struct max2165_config mygica_d689_max2165_cfg = {
765 .i2c_address = 0x60,
766 .osc_clk = 20
767 };
768
769 /* Callbacks for DVB USB */
770 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
771 {
772 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
773 &adap->dev->i2c_adap, 0x61,
774 TUNER_PHILIPS_FMD1216ME_MK3);
775 return 0;
776 }
777
778 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
779 {
780 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
781 NULL, DVB_PLL_THOMSON_DTT7579);
782 return 0;
783 }
784
785 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
786 {
787 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, NULL, DVB_PLL_LG_Z201);
788 return 0;
789 }
790
791 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
792 {
793 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
794 NULL, DVB_PLL_THOMSON_DTT7579);
795 return 0;
796 }
797
798 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
799 {
800 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
801 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
802 return 0;
803 }
804
805 static int dvico_bluebird_xc2028_callback(void *ptr, int component,
806 int command, int arg)
807 {
808 struct dvb_usb_adapter *adap = ptr;
809 struct dvb_usb_device *d = adap->dev;
810
811 switch (command) {
812 case XC2028_TUNER_RESET:
813 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
814 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
815 break;
816 case XC2028_RESET_CLK:
817 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
818 break;
819 default:
820 deb_info("%s: unknown command %d, arg %d\n", __func__,
821 command, arg);
822 return -EINVAL;
823 }
824
825 return 0;
826 }
827
828 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
829 {
830 struct dvb_frontend *fe;
831 struct xc2028_config cfg = {
832 .i2c_adap = &adap->dev->i2c_adap,
833 .i2c_addr = 0x61,
834 };
835 static struct xc2028_ctrl ctl = {
836 .fname = XC2028_DEFAULT_FIRMWARE,
837 .max_len = 64,
838 .demod = XC3028_FE_ZARLINK456,
839 };
840
841 /* FIXME: generalize & move to common area */
842 adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback;
843
844 fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg);
845 if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
846 return -EIO;
847
848 fe->ops.tuner_ops.set_config(fe, &ctl);
849
850 return 0;
851 }
852
853 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
854 {
855 dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
856 &adap->dev->i2c_adap, &aver_a868r_tuner);
857 return 0;
858 }
859
860 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
861 {
862 struct dvb_frontend *fe;
863 fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
864 &adap->dev->i2c_adap, &d680_dmb_tuner);
865 return (fe == NULL) ? -EIO : 0;
866 }
867
868 static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
869 {
870 struct dvb_frontend *fe;
871 fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe,
872 &adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
873 return (fe == NULL) ? -EIO : 0;
874 }
875
876 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
877 {
878 u8 b;
879 if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
880 err("set interface failed");
881
882 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
883
884 adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
885 &adap->dev->i2c_adap);
886 if ((adap->fe_adap[0].fe) != NULL)
887 return 0;
888
889 return -EIO;
890 }
891
892 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
893 {
894 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
895 err("set interface failed");
896
897 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
898
899 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
900 &cxusb_lgdt3303_config,
901 &adap->dev->i2c_adap);
902 if ((adap->fe_adap[0].fe) != NULL)
903 return 0;
904
905 return -EIO;
906 }
907
908 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
909 {
910 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
911 &adap->dev->i2c_adap);
912 if (adap->fe_adap[0].fe != NULL)
913 return 0;
914
915 return -EIO;
916 }
917
918 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
919 {
920 /* used in both lgz201 and th7579 */
921 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
922 err("set interface failed");
923
924 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
925
926 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
927 &adap->dev->i2c_adap);
928 if ((adap->fe_adap[0].fe) != NULL)
929 return 0;
930
931 return -EIO;
932 }
933
934 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
935 {
936 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
937 err("set interface failed");
938
939 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
940
941 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
942 &adap->dev->i2c_adap);
943 if ((adap->fe_adap[0].fe) != NULL)
944 return 0;
945
946 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
947 &cxusb_zl10353_dee1601_config,
948 &adap->dev->i2c_adap);
949 if ((adap->fe_adap[0].fe) != NULL)
950 return 0;
951
952 return -EIO;
953 }
954
955 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
956 {
957 u8 ircode[4];
958 int i;
959 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
960 .buf = ircode, .len = 4 };
961
962 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
963 err("set interface failed");
964
965 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
966
967 /* reset the tuner and demodulator */
968 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
969 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
970 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
971
972 adap->fe_adap[0].fe =
973 dvb_attach(zl10353_attach,
974 &cxusb_zl10353_xc3028_config_no_i2c_gate,
975 &adap->dev->i2c_adap);
976 if ((adap->fe_adap[0].fe) == NULL)
977 return -EIO;
978
979 /* try to determine if there is no IR decoder on the I2C bus */
980 for (i = 0; adap->dev->props.rc.legacy.rc_map_table != NULL && i < 5; i++) {
981 msleep(20);
982 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
983 goto no_IR;
984 if (ircode[0] == 0 && ircode[1] == 0)
985 continue;
986 if (ircode[2] + ircode[3] != 0xff) {
987 no_IR:
988 adap->dev->props.rc.legacy.rc_map_table = NULL;
989 info("No IR receiver detected on this device.");
990 break;
991 }
992 }
993
994 return 0;
995 }
996
997 static struct dibx000_agc_config dib7070_agc_config = {
998 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
999
1000 /*
1001 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
1002 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1003 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
1004 */
1005 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
1006 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1007 .inv_gain = 600,
1008 .time_stabiliz = 10,
1009 .alpha_level = 0,
1010 .thlock = 118,
1011 .wbd_inv = 0,
1012 .wbd_ref = 3530,
1013 .wbd_sel = 1,
1014 .wbd_alpha = 5,
1015 .agc1_max = 65535,
1016 .agc1_min = 0,
1017 .agc2_max = 65535,
1018 .agc2_min = 0,
1019 .agc1_pt1 = 0,
1020 .agc1_pt2 = 40,
1021 .agc1_pt3 = 183,
1022 .agc1_slope1 = 206,
1023 .agc1_slope2 = 255,
1024 .agc2_pt1 = 72,
1025 .agc2_pt2 = 152,
1026 .agc2_slope1 = 88,
1027 .agc2_slope2 = 90,
1028 .alpha_mant = 17,
1029 .alpha_exp = 27,
1030 .beta_mant = 23,
1031 .beta_exp = 51,
1032 .perform_agc_softsplit = 0,
1033 };
1034
1035 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1036 .internal = 60000,
1037 .sampling = 15000,
1038 .pll_prediv = 1,
1039 .pll_ratio = 20,
1040 .pll_range = 3,
1041 .pll_reset = 1,
1042 .pll_bypass = 0,
1043 .enable_refdiv = 0,
1044 .bypclk_div = 0,
1045 .IO_CLK_en_core = 1,
1046 .ADClkSrc = 1,
1047 .modulo = 2,
1048 /* refsel, sel, freq_15k */
1049 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1050 .ifreq = (0 << 25) | 0,
1051 .timf = 20452225,
1052 .xtal_hz = 12000000,
1053 };
1054
1055 static struct dib7000p_config cxusb_dualdig4_rev2_config = {
1056 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
1057 .output_mpeg2_in_188_bytes = 1,
1058
1059 .agc_config_count = 1,
1060 .agc = &dib7070_agc_config,
1061 .bw = &dib7070_bw_config_12_mhz,
1062 .tuner_is_baseband = 1,
1063 .spur_protect = 1,
1064
1065 .gpio_dir = 0xfcef,
1066 .gpio_val = 0x0110,
1067
1068 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1069
1070 .hostbus_diversity = 1,
1071 };
1072
1073 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1074 {
1075 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1076 err("set interface failed");
1077
1078 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1079
1080 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1081
1082 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1083 &cxusb_dualdig4_rev2_config) < 0) {
1084 printk(KERN_WARNING "Unable to enumerate dib7000p\n");
1085 return -ENODEV;
1086 }
1087
1088 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1089 &cxusb_dualdig4_rev2_config);
1090 if (adap->fe_adap[0].fe == NULL)
1091 return -EIO;
1092
1093 return 0;
1094 }
1095
1096 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1097 {
1098 return dib7000p_set_gpio(fe, 8, 0, !onoff);
1099 }
1100
1101 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1102 {
1103 return 0;
1104 }
1105
1106 static struct dib0070_config dib7070p_dib0070_config = {
1107 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1108 .reset = dib7070_tuner_reset,
1109 .sleep = dib7070_tuner_sleep,
1110 .clock_khz = 12000,
1111 };
1112
1113 struct dib0700_adapter_state {
1114 int (*set_param_save) (struct dvb_frontend *);
1115 };
1116
1117 static int dib7070_set_param_override(struct dvb_frontend *fe)
1118 {
1119 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1120 struct dvb_usb_adapter *adap = fe->dvb->priv;
1121 struct dib0700_adapter_state *state = adap->priv;
1122
1123 u16 offset;
1124 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1125 switch (band) {
1126 case BAND_VHF: offset = 950; break;
1127 default:
1128 case BAND_UHF: offset = 550; break;
1129 }
1130
1131 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1132
1133 return state->set_param_save(fe);
1134 }
1135
1136 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1137 {
1138 struct dib0700_adapter_state *st = adap->priv;
1139 struct i2c_adapter *tun_i2c =
1140 dib7000p_get_i2c_master(adap->fe_adap[0].fe,
1141 DIBX000_I2C_INTERFACE_TUNER, 1);
1142
1143 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1144 &dib7070p_dib0070_config) == NULL)
1145 return -ENODEV;
1146
1147 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1148 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1149 return 0;
1150 }
1151
1152 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1153 {
1154 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1155 err("set interface failed");
1156
1157 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1158
1159 /* reset the tuner and demodulator */
1160 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1161 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1162 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1163
1164 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
1165 &cxusb_zl10353_xc3028_config,
1166 &adap->dev->i2c_adap);
1167 if ((adap->fe_adap[0].fe) != NULL)
1168 return 0;
1169
1170 adap->fe_adap[0].fe = dvb_attach(mt352_attach,
1171 &cxusb_mt352_xc3028_config,
1172 &adap->dev->i2c_adap);
1173 if ((adap->fe_adap[0].fe) != NULL)
1174 return 0;
1175
1176 return -EIO;
1177 }
1178
1179 static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1180 .prod = LGS8GXX_PROD_LGS8GL5,
1181 .demod_address = 0x19,
1182 .serial_ts = 0,
1183 .ts_clk_pol = 0,
1184 .ts_clk_gated = 1,
1185 .if_clk_freq = 30400, /* 30.4 MHz */
1186 .if_freq = 5725, /* 5.725 MHz */
1187 .if_neg_center = 0,
1188 .ext_adc = 0,
1189 .adc_signed = 0,
1190 .if_neg_edge = 0,
1191 };
1192
1193 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1194 {
1195 struct dvb_usb_device *d = adap->dev;
1196 int n;
1197
1198 /* Select required USB configuration */
1199 if (usb_set_interface(d->udev, 0, 0) < 0)
1200 err("set interface failed");
1201
1202 /* Unblock all USB pipes */
1203 usb_clear_halt(d->udev,
1204 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1205 usb_clear_halt(d->udev,
1206 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1207 usb_clear_halt(d->udev,
1208 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1209
1210 /* Drain USB pipes to avoid hang after reboot */
1211 for (n = 0; n < 5; n++) {
1212 cxusb_d680_dmb_drain_message(d);
1213 cxusb_d680_dmb_drain_video(d);
1214 msleep(200);
1215 }
1216
1217 /* Reset the tuner */
1218 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1219 err("clear tuner gpio failed");
1220 return -EIO;
1221 }
1222 msleep(100);
1223 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1224 err("set tuner gpio failed");
1225 return -EIO;
1226 }
1227 msleep(100);
1228
1229 /* Attach frontend */
1230 adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
1231 if (adap->fe_adap[0].fe == NULL)
1232 return -EIO;
1233
1234 return 0;
1235 }
1236
1237 static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1238 .prod = ATBM8830_PROD_8830,
1239 .demod_address = 0x40,
1240 .serial_ts = 0,
1241 .ts_sampling_edge = 1,
1242 .ts_clk_gated = 0,
1243 .osc_clk_freq = 30400, /* in kHz */
1244 .if_freq = 0, /* zero IF */
1245 .zif_swap_iq = 1,
1246 .agc_min = 0x2E,
1247 .agc_max = 0x90,
1248 .agc_hold_loop = 0,
1249 };
1250
1251 static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1252 {
1253 struct dvb_usb_device *d = adap->dev;
1254
1255 /* Select required USB configuration */
1256 if (usb_set_interface(d->udev, 0, 0) < 0)
1257 err("set interface failed");
1258
1259 /* Unblock all USB pipes */
1260 usb_clear_halt(d->udev,
1261 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1262 usb_clear_halt(d->udev,
1263 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1264 usb_clear_halt(d->udev,
1265 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1266
1267
1268 /* Reset the tuner */
1269 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1270 err("clear tuner gpio failed");
1271 return -EIO;
1272 }
1273 msleep(100);
1274 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1275 err("set tuner gpio failed");
1276 return -EIO;
1277 }
1278 msleep(100);
1279
1280 /* Attach frontend */
1281 adap->fe_adap[0].fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg,
1282 &d->i2c_adap);
1283 if (adap->fe_adap[0].fe == NULL)
1284 return -EIO;
1285
1286 return 0;
1287 }
1288
1289 /*
1290 * DViCO has shipped two devices with the same USB ID, but only one of them
1291 * needs a firmware download. Check the device class details to see if they
1292 * have non-default values to decide whether the device is actually cold or
1293 * not, and forget a match if it turns out we selected the wrong device.
1294 */
1295 static int bluebird_fx2_identify_state(struct usb_device *udev,
1296 struct dvb_usb_device_properties *props,
1297 struct dvb_usb_device_description **desc,
1298 int *cold)
1299 {
1300 int wascold = *cold;
1301
1302 *cold = udev->descriptor.bDeviceClass == 0xff &&
1303 udev->descriptor.bDeviceSubClass == 0xff &&
1304 udev->descriptor.bDeviceProtocol == 0xff;
1305
1306 if (*cold && !wascold)
1307 *desc = NULL;
1308
1309 return 0;
1310 }
1311
1312 /*
1313 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1314 * firmware file before download.
1315 */
1316
1317 static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1318 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1319 const struct firmware *fw)
1320 {
1321 int pos;
1322
1323 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1324 int idoff = dvico_firmware_id_offsets[pos];
1325
1326 if (fw->size < idoff + 4)
1327 continue;
1328
1329 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1330 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1331 struct firmware new_fw;
1332 u8 *new_fw_data = vmalloc(fw->size);
1333 int ret;
1334
1335 if (!new_fw_data)
1336 return -ENOMEM;
1337
1338 memcpy(new_fw_data, fw->data, fw->size);
1339 new_fw.size = fw->size;
1340 new_fw.data = new_fw_data;
1341
1342 new_fw_data[idoff + 2] =
1343 le16_to_cpu(udev->descriptor.idProduct) + 1;
1344 new_fw_data[idoff + 3] =
1345 le16_to_cpu(udev->descriptor.idProduct) >> 8;
1346
1347 ret = usb_cypress_load_firmware(udev, &new_fw,
1348 CYPRESS_FX2);
1349 vfree(new_fw_data);
1350 return ret;
1351 }
1352 }
1353
1354 return -EINVAL;
1355 }
1356
1357 /* DVB USB Driver stuff */
1358 static struct dvb_usb_device_properties cxusb_medion_properties;
1359 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1360 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1361 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1362 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1363 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1364 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1365 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1366 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1367 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1368 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1369 static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
1370
1371 static int cxusb_probe(struct usb_interface *intf,
1372 const struct usb_device_id *id)
1373 {
1374 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1375 THIS_MODULE, NULL, adapter_nr) ||
1376 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1377 THIS_MODULE, NULL, adapter_nr) ||
1378 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1379 THIS_MODULE, NULL, adapter_nr) ||
1380 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1381 THIS_MODULE, NULL, adapter_nr) ||
1382 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1383 THIS_MODULE, NULL, adapter_nr) ||
1384 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1385 THIS_MODULE, NULL, adapter_nr) ||
1386 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1387 THIS_MODULE, NULL, adapter_nr) ||
1388 0 == dvb_usb_device_init(intf,
1389 &cxusb_bluebird_nano2_needsfirmware_properties,
1390 THIS_MODULE, NULL, adapter_nr) ||
1391 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1392 THIS_MODULE, NULL, adapter_nr) ||
1393 0 == dvb_usb_device_init(intf,
1394 &cxusb_bluebird_dualdig4_rev2_properties,
1395 THIS_MODULE, NULL, adapter_nr) ||
1396 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1397 THIS_MODULE, NULL, adapter_nr) ||
1398 0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1399 THIS_MODULE, NULL, adapter_nr) ||
1400 0)
1401 return 0;
1402
1403 return -EINVAL;
1404 }
1405
1406 static struct usb_device_id cxusb_table [] = {
1407 { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
1408 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
1409 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
1410 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
1411 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
1412 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
1413 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
1414 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
1415 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
1416 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
1417 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
1418 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
1419 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
1420 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
1421 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
1422 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
1423 { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
1424 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
1425 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
1426 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) },
1427 {} /* Terminating entry */
1428 };
1429 MODULE_DEVICE_TABLE (usb, cxusb_table);
1430
1431 static struct dvb_usb_device_properties cxusb_medion_properties = {
1432 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1433
1434 .usb_ctrl = CYPRESS_FX2,
1435
1436 .size_of_priv = sizeof(struct cxusb_state),
1437
1438 .num_adapters = 1,
1439 .adapter = {
1440 {
1441 .num_frontends = 1,
1442 .fe = {{
1443 .streaming_ctrl = cxusb_streaming_ctrl,
1444 .frontend_attach = cxusb_cx22702_frontend_attach,
1445 .tuner_attach = cxusb_fmd1216me_tuner_attach,
1446 /* parameter for the MPEG2-data transfer */
1447 .stream = {
1448 .type = USB_BULK,
1449 .count = 5,
1450 .endpoint = 0x02,
1451 .u = {
1452 .bulk = {
1453 .buffersize = 8192,
1454 }
1455 }
1456 },
1457 }},
1458 },
1459 },
1460 .power_ctrl = cxusb_power_ctrl,
1461
1462 .i2c_algo = &cxusb_i2c_algo,
1463
1464 .generic_bulk_ctrl_endpoint = 0x01,
1465
1466 .num_device_descs = 1,
1467 .devices = {
1468 { "Medion MD95700 (MDUSBTV-HYBRID)",
1469 { NULL },
1470 { &cxusb_table[0], NULL },
1471 },
1472 }
1473 };
1474
1475 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1476 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1477
1478 .usb_ctrl = DEVICE_SPECIFIC,
1479 .firmware = "dvb-usb-bluebird-01.fw",
1480 .download_firmware = bluebird_patch_dvico_firmware_download,
1481 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1482 use usb alt setting 7 for EP2 transfer (atsc) */
1483
1484 .size_of_priv = sizeof(struct cxusb_state),
1485
1486 .num_adapters = 1,
1487 .adapter = {
1488 {
1489 .num_frontends = 1,
1490 .fe = {{
1491 .streaming_ctrl = cxusb_streaming_ctrl,
1492 .frontend_attach = cxusb_lgdt3303_frontend_attach,
1493 .tuner_attach = cxusb_lgh064f_tuner_attach,
1494
1495 /* parameter for the MPEG2-data transfer */
1496 .stream = {
1497 .type = USB_BULK,
1498 .count = 5,
1499 .endpoint = 0x02,
1500 .u = {
1501 .bulk = {
1502 .buffersize = 8192,
1503 }
1504 }
1505 },
1506 }},
1507 },
1508 },
1509
1510 .power_ctrl = cxusb_bluebird_power_ctrl,
1511
1512 .i2c_algo = &cxusb_i2c_algo,
1513
1514 .rc.legacy = {
1515 .rc_interval = 100,
1516 .rc_map_table = rc_map_dvico_portable_table,
1517 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1518 .rc_query = cxusb_rc_query,
1519 },
1520
1521 .generic_bulk_ctrl_endpoint = 0x01,
1522
1523 .num_device_descs = 1,
1524 .devices = {
1525 { "DViCO FusionHDTV5 USB Gold",
1526 { &cxusb_table[1], NULL },
1527 { &cxusb_table[2], NULL },
1528 },
1529 }
1530 };
1531
1532 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1533 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1534
1535 .usb_ctrl = DEVICE_SPECIFIC,
1536 .firmware = "dvb-usb-bluebird-01.fw",
1537 .download_firmware = bluebird_patch_dvico_firmware_download,
1538 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1539 use usb alt setting 7 for EP2 transfer (atsc) */
1540
1541 .size_of_priv = sizeof(struct cxusb_state),
1542
1543 .num_adapters = 1,
1544 .adapter = {
1545 {
1546 .num_frontends = 1,
1547 .fe = {{
1548 .streaming_ctrl = cxusb_streaming_ctrl,
1549 .frontend_attach = cxusb_dee1601_frontend_attach,
1550 .tuner_attach = cxusb_dee1601_tuner_attach,
1551 /* parameter for the MPEG2-data transfer */
1552 .stream = {
1553 .type = USB_BULK,
1554 .count = 5,
1555 .endpoint = 0x04,
1556 .u = {
1557 .bulk = {
1558 .buffersize = 8192,
1559 }
1560 }
1561 },
1562 }},
1563 },
1564 },
1565
1566 .power_ctrl = cxusb_bluebird_power_ctrl,
1567
1568 .i2c_algo = &cxusb_i2c_algo,
1569
1570 .rc.legacy = {
1571 .rc_interval = 150,
1572 .rc_map_table = rc_map_dvico_mce_table,
1573 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
1574 .rc_query = cxusb_rc_query,
1575 },
1576
1577 .generic_bulk_ctrl_endpoint = 0x01,
1578
1579 .num_device_descs = 3,
1580 .devices = {
1581 { "DViCO FusionHDTV DVB-T Dual USB",
1582 { &cxusb_table[3], NULL },
1583 { &cxusb_table[4], NULL },
1584 },
1585 { "DigitalNow DVB-T Dual USB",
1586 { &cxusb_table[9], NULL },
1587 { &cxusb_table[10], NULL },
1588 },
1589 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1590 { &cxusb_table[11], NULL },
1591 { &cxusb_table[12], NULL },
1592 },
1593 }
1594 };
1595
1596 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1597 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1598
1599 .usb_ctrl = DEVICE_SPECIFIC,
1600 .firmware = "dvb-usb-bluebird-01.fw",
1601 .download_firmware = bluebird_patch_dvico_firmware_download,
1602 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1603 use usb alt setting 7 for EP2 transfer (atsc) */
1604
1605 .size_of_priv = sizeof(struct cxusb_state),
1606
1607 .num_adapters = 2,
1608 .adapter = {
1609 {
1610 .num_frontends = 1,
1611 .fe = {{
1612 .streaming_ctrl = cxusb_streaming_ctrl,
1613 .frontend_attach = cxusb_mt352_frontend_attach,
1614 .tuner_attach = cxusb_lgz201_tuner_attach,
1615
1616 /* parameter for the MPEG2-data transfer */
1617 .stream = {
1618 .type = USB_BULK,
1619 .count = 5,
1620 .endpoint = 0x04,
1621 .u = {
1622 .bulk = {
1623 .buffersize = 8192,
1624 }
1625 }
1626 },
1627 }},
1628 },
1629 },
1630 .power_ctrl = cxusb_bluebird_power_ctrl,
1631
1632 .i2c_algo = &cxusb_i2c_algo,
1633
1634 .rc.legacy = {
1635 .rc_interval = 100,
1636 .rc_map_table = rc_map_dvico_portable_table,
1637 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1638 .rc_query = cxusb_rc_query,
1639 },
1640
1641 .generic_bulk_ctrl_endpoint = 0x01,
1642 .num_device_descs = 1,
1643 .devices = {
1644 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1645 { &cxusb_table[5], NULL },
1646 { &cxusb_table[6], NULL },
1647 },
1648 }
1649 };
1650
1651 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1652 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1653
1654 .usb_ctrl = DEVICE_SPECIFIC,
1655 .firmware = "dvb-usb-bluebird-01.fw",
1656 .download_firmware = bluebird_patch_dvico_firmware_download,
1657 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1658 use usb alt setting 7 for EP2 transfer (atsc) */
1659
1660 .size_of_priv = sizeof(struct cxusb_state),
1661
1662 .num_adapters = 1,
1663 .adapter = {
1664 {
1665 .num_frontends = 1,
1666 .fe = {{
1667 .streaming_ctrl = cxusb_streaming_ctrl,
1668 .frontend_attach = cxusb_mt352_frontend_attach,
1669 .tuner_attach = cxusb_dtt7579_tuner_attach,
1670
1671 /* parameter for the MPEG2-data transfer */
1672 .stream = {
1673 .type = USB_BULK,
1674 .count = 5,
1675 .endpoint = 0x04,
1676 .u = {
1677 .bulk = {
1678 .buffersize = 8192,
1679 }
1680 }
1681 },
1682 }},
1683 },
1684 },
1685 .power_ctrl = cxusb_bluebird_power_ctrl,
1686
1687 .i2c_algo = &cxusb_i2c_algo,
1688
1689 .rc.legacy = {
1690 .rc_interval = 100,
1691 .rc_map_table = rc_map_dvico_portable_table,
1692 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1693 .rc_query = cxusb_rc_query,
1694 },
1695
1696 .generic_bulk_ctrl_endpoint = 0x01,
1697
1698 .num_device_descs = 1,
1699 .devices = {
1700 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1701 { &cxusb_table[7], NULL },
1702 { &cxusb_table[8], NULL },
1703 },
1704 }
1705 };
1706
1707 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1708 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1709
1710 .usb_ctrl = CYPRESS_FX2,
1711
1712 .size_of_priv = sizeof(struct cxusb_state),
1713
1714 .num_adapters = 1,
1715 .adapter = {
1716 {
1717 .num_frontends = 1,
1718 .fe = {{
1719 .streaming_ctrl = cxusb_streaming_ctrl,
1720 .frontend_attach = cxusb_dualdig4_frontend_attach,
1721 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1722 /* parameter for the MPEG2-data transfer */
1723 .stream = {
1724 .type = USB_BULK,
1725 .count = 5,
1726 .endpoint = 0x02,
1727 .u = {
1728 .bulk = {
1729 .buffersize = 8192,
1730 }
1731 }
1732 },
1733 }},
1734 },
1735 },
1736
1737 .power_ctrl = cxusb_power_ctrl,
1738
1739 .i2c_algo = &cxusb_i2c_algo,
1740
1741 .generic_bulk_ctrl_endpoint = 0x01,
1742
1743 .rc.legacy = {
1744 .rc_interval = 100,
1745 .rc_map_table = rc_map_dvico_mce_table,
1746 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
1747 .rc_query = cxusb_bluebird2_rc_query,
1748 },
1749
1750 .num_device_descs = 1,
1751 .devices = {
1752 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1753 { NULL },
1754 { &cxusb_table[13], NULL },
1755 },
1756 }
1757 };
1758
1759 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1760 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1761
1762 .usb_ctrl = CYPRESS_FX2,
1763 .identify_state = bluebird_fx2_identify_state,
1764
1765 .size_of_priv = sizeof(struct cxusb_state),
1766
1767 .num_adapters = 1,
1768 .adapter = {
1769 {
1770 .num_frontends = 1,
1771 .fe = {{
1772 .streaming_ctrl = cxusb_streaming_ctrl,
1773 .frontend_attach = cxusb_nano2_frontend_attach,
1774 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1775 /* parameter for the MPEG2-data transfer */
1776 .stream = {
1777 .type = USB_BULK,
1778 .count = 5,
1779 .endpoint = 0x02,
1780 .u = {
1781 .bulk = {
1782 .buffersize = 8192,
1783 }
1784 }
1785 },
1786 }},
1787 },
1788 },
1789
1790 .power_ctrl = cxusb_nano2_power_ctrl,
1791
1792 .i2c_algo = &cxusb_i2c_algo,
1793
1794 .generic_bulk_ctrl_endpoint = 0x01,
1795
1796 .rc.legacy = {
1797 .rc_interval = 100,
1798 .rc_map_table = rc_map_dvico_portable_table,
1799 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1800 .rc_query = cxusb_bluebird2_rc_query,
1801 },
1802
1803 .num_device_descs = 1,
1804 .devices = {
1805 { "DViCO FusionHDTV DVB-T NANO2",
1806 { NULL },
1807 { &cxusb_table[14], NULL },
1808 },
1809 }
1810 };
1811
1812 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1813 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1814
1815 .usb_ctrl = DEVICE_SPECIFIC,
1816 .firmware = "dvb-usb-bluebird-02.fw",
1817 .download_firmware = bluebird_patch_dvico_firmware_download,
1818 .identify_state = bluebird_fx2_identify_state,
1819
1820 .size_of_priv = sizeof(struct cxusb_state),
1821
1822 .num_adapters = 1,
1823 .adapter = {
1824 {
1825 .num_frontends = 1,
1826 .fe = {{
1827 .streaming_ctrl = cxusb_streaming_ctrl,
1828 .frontend_attach = cxusb_nano2_frontend_attach,
1829 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1830 /* parameter for the MPEG2-data transfer */
1831 .stream = {
1832 .type = USB_BULK,
1833 .count = 5,
1834 .endpoint = 0x02,
1835 .u = {
1836 .bulk = {
1837 .buffersize = 8192,
1838 }
1839 }
1840 },
1841 }},
1842 },
1843 },
1844
1845 .power_ctrl = cxusb_nano2_power_ctrl,
1846
1847 .i2c_algo = &cxusb_i2c_algo,
1848
1849 .generic_bulk_ctrl_endpoint = 0x01,
1850
1851 .rc.legacy = {
1852 .rc_interval = 100,
1853 .rc_map_table = rc_map_dvico_portable_table,
1854 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
1855 .rc_query = cxusb_rc_query,
1856 },
1857
1858 .num_device_descs = 1,
1859 .devices = {
1860 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1861 { &cxusb_table[14], NULL },
1862 { &cxusb_table[15], NULL },
1863 },
1864 }
1865 };
1866
1867 static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
1868 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1869
1870 .usb_ctrl = CYPRESS_FX2,
1871
1872 .size_of_priv = sizeof(struct cxusb_state),
1873
1874 .num_adapters = 1,
1875 .adapter = {
1876 {
1877 .num_frontends = 1,
1878 .fe = {{
1879 .streaming_ctrl = cxusb_aver_streaming_ctrl,
1880 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
1881 .tuner_attach = cxusb_mxl5003s_tuner_attach,
1882 /* parameter for the MPEG2-data transfer */
1883 .stream = {
1884 .type = USB_BULK,
1885 .count = 5,
1886 .endpoint = 0x04,
1887 .u = {
1888 .bulk = {
1889 .buffersize = 8192,
1890 }
1891 }
1892 },
1893 }},
1894 },
1895 },
1896 .power_ctrl = cxusb_aver_power_ctrl,
1897
1898 .i2c_algo = &cxusb_i2c_algo,
1899
1900 .generic_bulk_ctrl_endpoint = 0x01,
1901
1902 .num_device_descs = 1,
1903 .devices = {
1904 { "AVerMedia AVerTVHD Volar (A868R)",
1905 { NULL },
1906 { &cxusb_table[16], NULL },
1907 },
1908 }
1909 };
1910
1911 static
1912 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
1913 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1914
1915 .usb_ctrl = CYPRESS_FX2,
1916
1917 .size_of_priv = sizeof(struct cxusb_state),
1918
1919 .num_adapters = 1,
1920 .adapter = {
1921 {
1922 .size_of_priv = sizeof(struct dib0700_adapter_state),
1923 .num_frontends = 1,
1924 .fe = {{
1925 .streaming_ctrl = cxusb_streaming_ctrl,
1926 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
1927 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
1928 /* parameter for the MPEG2-data transfer */
1929 .stream = {
1930 .type = USB_BULK,
1931 .count = 7,
1932 .endpoint = 0x02,
1933 .u = {
1934 .bulk = {
1935 .buffersize = 4096,
1936 }
1937 }
1938 },
1939 }},
1940 },
1941 },
1942
1943 .power_ctrl = cxusb_bluebird_power_ctrl,
1944
1945 .i2c_algo = &cxusb_i2c_algo,
1946
1947 .generic_bulk_ctrl_endpoint = 0x01,
1948
1949 .rc.legacy = {
1950 .rc_interval = 100,
1951 .rc_map_table = rc_map_dvico_mce_table,
1952 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
1953 .rc_query = cxusb_rc_query,
1954 },
1955
1956 .num_device_descs = 1,
1957 .devices = {
1958 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
1959 { NULL },
1960 { &cxusb_table[17], NULL },
1961 },
1962 }
1963 };
1964
1965 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
1966 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1967
1968 .usb_ctrl = CYPRESS_FX2,
1969
1970 .size_of_priv = sizeof(struct cxusb_state),
1971
1972 .num_adapters = 1,
1973 .adapter = {
1974 {
1975 .num_frontends = 1,
1976 .fe = {{
1977 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
1978 .frontend_attach = cxusb_d680_dmb_frontend_attach,
1979 .tuner_attach = cxusb_d680_dmb_tuner_attach,
1980
1981 /* parameter for the MPEG2-data transfer */
1982 .stream = {
1983 .type = USB_BULK,
1984 .count = 5,
1985 .endpoint = 0x02,
1986 .u = {
1987 .bulk = {
1988 .buffersize = 8192,
1989 }
1990 }
1991 },
1992 }},
1993 },
1994 },
1995
1996 .power_ctrl = cxusb_d680_dmb_power_ctrl,
1997
1998 .i2c_algo = &cxusb_i2c_algo,
1999
2000 .generic_bulk_ctrl_endpoint = 0x01,
2001
2002 .rc.legacy = {
2003 .rc_interval = 100,
2004 .rc_map_table = rc_map_d680_dmb_table,
2005 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2006 .rc_query = cxusb_d680_dmb_rc_query,
2007 },
2008
2009 .num_device_descs = 1,
2010 .devices = {
2011 {
2012 "Conexant DMB-TH Stick",
2013 { NULL },
2014 { &cxusb_table[18], NULL },
2015 },
2016 }
2017 };
2018
2019 static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
2020 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2021
2022 .usb_ctrl = CYPRESS_FX2,
2023
2024 .size_of_priv = sizeof(struct cxusb_state),
2025
2026 .num_adapters = 1,
2027 .adapter = {
2028 {
2029 .num_frontends = 1,
2030 .fe = {{
2031 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
2032 .frontend_attach = cxusb_mygica_d689_frontend_attach,
2033 .tuner_attach = cxusb_mygica_d689_tuner_attach,
2034
2035 /* parameter for the MPEG2-data transfer */
2036 .stream = {
2037 .type = USB_BULK,
2038 .count = 5,
2039 .endpoint = 0x02,
2040 .u = {
2041 .bulk = {
2042 .buffersize = 8192,
2043 }
2044 }
2045 },
2046 }},
2047 },
2048 },
2049
2050 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2051
2052 .i2c_algo = &cxusb_i2c_algo,
2053
2054 .generic_bulk_ctrl_endpoint = 0x01,
2055
2056 .rc.legacy = {
2057 .rc_interval = 100,
2058 .rc_map_table = rc_map_d680_dmb_table,
2059 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
2060 .rc_query = cxusb_d680_dmb_rc_query,
2061 },
2062
2063 .num_device_descs = 1,
2064 .devices = {
2065 {
2066 "Mygica D689 DMB-TH",
2067 { NULL },
2068 { &cxusb_table[19], NULL },
2069 },
2070 }
2071 };
2072
2073 static struct usb_driver cxusb_driver = {
2074 .name = "dvb_usb_cxusb",
2075 .probe = cxusb_probe,
2076 .disconnect = dvb_usb_device_exit,
2077 .id_table = cxusb_table,
2078 };
2079
2080 module_usb_driver(cxusb_driver);
2081
2082 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
2083 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
2084 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
2085 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2086 MODULE_VERSION("1.0-alpha");
2087 MODULE_LICENSE("GPL");
Linux with added FPC-III support