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