projects / deliverable / linux.git / blob
? search:


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