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