Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kaber/nf-next-2.6
[linux-2.6.git] / drivers / media / dvb / dvb-usb / cxusb.c
1 /* DVB USB compliant linux driver for Conexant USB reference design.
2  *
3  * The Conexant reference design I saw on their website was only for analogue
4  * capturing (using the cx25842). The box I took to write this driver (reverse
5  * engineered) is the one labeled Medion MD95700. In addition to the cx25842
6  * for analogue capturing it also has a cx22702 DVB-T demodulator on the main
7  * board. Besides it has a atiremote (X10) and a USB2.0 hub onboard.
8  *
9  * Maybe it is a little bit premature to call this driver cxusb, but I assume
10  * the USB protocol is identical or at least inherited from the reference
11  * design, so it can be reused for the "analogue-only" device (if it will
12  * appear at all).
13  *
14  * TODO: Use the cx25840-driver for the analogue part
15  *
16  * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de)
17  * Copyright (C) 2006 Michael Krufky (mkrufky@linuxtv.org)
18  * Copyright (C) 2006, 2007 Chris Pascoe (c.pascoe@itee.uq.edu.au)
19  *
20  *   This program is free software; you can redistribute it and/or modify it
21  *   under the terms of the GNU General Public License as published by the Free
22  *   Software Foundation, version 2.
23  *
24  * see Documentation/dvb/README.dvb-usb for more information
25  */
26 #include <media/tuner.h>
27 #include <linux/vmalloc.h>
28
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 "lgs8gxx.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 (rc5_custom(&keymap[i]) == ircode[2] &&
396                     rc5_data(&keymap[i]) == 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 (rc5_custom(&keymap[i]) == ircode[1] &&
424                     rc5_data(&keymap[i]) == 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 (rc5_custom(&keymap[i]) == ircode[0] &&
450                     rc5_data(&keymap[i]) == 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         { 0xfe02, KEY_TV },
463         { 0xfe0e, KEY_MP3 },
464         { 0xfe1a, KEY_DVD },
465         { 0xfe1e, KEY_FAVORITES },
466         { 0xfe16, KEY_SETUP },
467         { 0xfe46, KEY_POWER2 },
468         { 0xfe0a, KEY_EPG },
469         { 0xfe49, KEY_BACK },
470         { 0xfe4d, KEY_MENU },
471         { 0xfe51, KEY_UP },
472         { 0xfe5b, KEY_LEFT },
473         { 0xfe5f, KEY_RIGHT },
474         { 0xfe53, KEY_DOWN },
475         { 0xfe5e, KEY_OK },
476         { 0xfe59, KEY_INFO },
477         { 0xfe55, KEY_TAB },
478         { 0xfe0f, KEY_PREVIOUSSONG },/* Replay */
479         { 0xfe12, KEY_NEXTSONG },       /* Skip */
480         { 0xfe42, KEY_ENTER      },     /* Windows/Start */
481         { 0xfe15, KEY_VOLUMEUP },
482         { 0xfe05, KEY_VOLUMEDOWN },
483         { 0xfe11, KEY_CHANNELUP },
484         { 0xfe09, KEY_CHANNELDOWN },
485         { 0xfe52, KEY_CAMERA },
486         { 0xfe5a, KEY_TUNER },  /* Live */
487         { 0xfe19, KEY_OPEN },
488         { 0xfe0b, KEY_1 },
489         { 0xfe17, KEY_2 },
490         { 0xfe1b, KEY_3 },
491         { 0xfe07, KEY_4 },
492         { 0xfe50, KEY_5 },
493         { 0xfe54, KEY_6 },
494         { 0xfe48, KEY_7 },
495         { 0xfe4c, KEY_8 },
496         { 0xfe58, KEY_9 },
497         { 0xfe13, KEY_ANGLE },  /* Aspect */
498         { 0xfe03, KEY_0 },
499         { 0xfe1f, KEY_ZOOM },
500         { 0xfe43, KEY_REWIND },
501         { 0xfe47, KEY_PLAYPAUSE },
502         { 0xfe4f, KEY_FASTFORWARD },
503         { 0xfe57, KEY_MUTE },
504         { 0xfe0d, KEY_STOP },
505         { 0xfe01, KEY_RECORD },
506         { 0xfe4e, KEY_POWER },
507 };
508
509 static struct dvb_usb_rc_key dvico_portable_rc_keys[] = {
510         { 0xfc02, KEY_SETUP },       /* Profile */
511         { 0xfc43, KEY_POWER2 },
512         { 0xfc06, KEY_EPG },
513         { 0xfc5a, KEY_BACK },
514         { 0xfc05, KEY_MENU },
515         { 0xfc47, KEY_INFO },
516         { 0xfc01, KEY_TAB },
517         { 0xfc42, KEY_PREVIOUSSONG },/* Replay */
518         { 0xfc49, KEY_VOLUMEUP },
519         { 0xfc09, KEY_VOLUMEDOWN },
520         { 0xfc54, KEY_CHANNELUP },
521         { 0xfc0b, KEY_CHANNELDOWN },
522         { 0xfc16, KEY_CAMERA },
523         { 0xfc40, KEY_TUNER },  /* ATV/DTV */
524         { 0xfc45, KEY_OPEN },
525         { 0xfc19, KEY_1 },
526         { 0xfc18, KEY_2 },
527         { 0xfc1b, KEY_3 },
528         { 0xfc1a, KEY_4 },
529         { 0xfc58, KEY_5 },
530         { 0xfc59, KEY_6 },
531         { 0xfc15, KEY_7 },
532         { 0xfc14, KEY_8 },
533         { 0xfc17, KEY_9 },
534         { 0xfc44, KEY_ANGLE },  /* Aspect */
535         { 0xfc55, KEY_0 },
536         { 0xfc07, KEY_ZOOM },
537         { 0xfc0a, KEY_REWIND },
538         { 0xfc08, KEY_PLAYPAUSE },
539         { 0xfc4b, KEY_FASTFORWARD },
540         { 0xfc5b, KEY_MUTE },
541         { 0xfc04, KEY_STOP },
542         { 0xfc56, KEY_RECORD },
543         { 0xfc57, KEY_POWER },
544         { 0xfc41, KEY_UNKNOWN },    /* INPUT */
545         { 0xfc00, KEY_UNKNOWN },    /* HD */
546 };
547
548 static struct dvb_usb_rc_key d680_dmb_rc_keys[] = {
549         { 0x0038, KEY_UNKNOWN },        /* TV/AV */
550         { 0x080c, KEY_ZOOM },
551         { 0x0800, KEY_0 },
552         { 0x0001, KEY_1 },
553         { 0x0802, KEY_2 },
554         { 0x0003, KEY_3 },
555         { 0x0804, KEY_4 },
556         { 0x0005, KEY_5 },
557         { 0x0806, KEY_6 },
558         { 0x0007, KEY_7 },
559         { 0x0808, KEY_8 },
560         { 0x0009, KEY_9 },
561         { 0x000a, KEY_MUTE },
562         { 0x0829, KEY_BACK },
563         { 0x0012, KEY_CHANNELUP },
564         { 0x0813, KEY_CHANNELDOWN },
565         { 0x002b, KEY_VOLUMEUP },
566         { 0x082c, KEY_VOLUMEDOWN },
567         { 0x0020, KEY_UP },
568         { 0x0821, KEY_DOWN },
569         { 0x0011, KEY_LEFT },
570         { 0x0810, KEY_RIGHT },
571         { 0x000d, KEY_OK },
572         { 0x081f, KEY_RECORD },
573         { 0x0017, KEY_PLAYPAUSE },
574         { 0x0816, KEY_PLAYPAUSE },
575         { 0x000b, KEY_STOP },
576         { 0x0827, KEY_FASTFORWARD },
577         { 0x0026, KEY_REWIND },
578         { 0x081e, KEY_UNKNOWN },    /* Time Shift */
579         { 0x000e, KEY_UNKNOWN },    /* Snapshot */
580         { 0x082d, KEY_UNKNOWN },    /* Mouse Cursor */
581         { 0x000f, KEY_UNKNOWN },    /* Minimize/Maximize */
582         { 0x0814, KEY_UNKNOWN },    /* Shuffle */
583         { 0x0025, 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 zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
667         .demod_address = 0x0f,
668         .if2 = 45600,
669         .no_tuner = 1,
670         .parallel_ts = 1,
671         .disable_i2c_gate_ctrl = 1,
672 };
673
674 static struct mt352_config cxusb_mt352_xc3028_config = {
675         .demod_address = 0x0f,
676         .if2 = 4560,
677         .no_tuner = 1,
678         .demod_init = cxusb_mt352_demod_init,
679 };
680
681 /* FIXME: needs tweaking */
682 static struct mxl5005s_config aver_a868r_tuner = {
683         .i2c_address     = 0x63,
684         .if_freq         = 6000000UL,
685         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
686         .agc_mode        = MXL_SINGLE_AGC,
687         .tracking_filter = MXL_TF_C,
688         .rssi_enable     = MXL_RSSI_ENABLE,
689         .cap_select      = MXL_CAP_SEL_ENABLE,
690         .div_out         = MXL_DIV_OUT_4,
691         .clock_out       = MXL_CLOCK_OUT_DISABLE,
692         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
693         .top             = MXL5005S_TOP_25P2,
694         .mod_mode        = MXL_DIGITAL_MODE,
695         .if_mode         = MXL_ZERO_IF,
696         .AgcMasterByte   = 0x00,
697 };
698
699 /* FIXME: needs tweaking */
700 static struct mxl5005s_config d680_dmb_tuner = {
701         .i2c_address     = 0x63,
702         .if_freq         = 36125000UL,
703         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
704         .agc_mode        = MXL_SINGLE_AGC,
705         .tracking_filter = MXL_TF_C,
706         .rssi_enable     = MXL_RSSI_ENABLE,
707         .cap_select      = MXL_CAP_SEL_ENABLE,
708         .div_out         = MXL_DIV_OUT_4,
709         .clock_out       = MXL_CLOCK_OUT_DISABLE,
710         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
711         .top             = MXL5005S_TOP_25P2,
712         .mod_mode        = MXL_DIGITAL_MODE,
713         .if_mode         = MXL_ZERO_IF,
714         .AgcMasterByte   = 0x00,
715 };
716
717 /* Callbacks for DVB USB */
718 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
719 {
720         dvb_attach(simple_tuner_attach, adap->fe,
721                    &adap->dev->i2c_adap, 0x61,
722                    TUNER_PHILIPS_FMD1216ME_MK3);
723         return 0;
724 }
725
726 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
727 {
728         dvb_attach(dvb_pll_attach, adap->fe, 0x61,
729                    NULL, DVB_PLL_THOMSON_DTT7579);
730         return 0;
731 }
732
733 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
734 {
735         dvb_attach(dvb_pll_attach, adap->fe, 0x61, NULL, DVB_PLL_LG_Z201);
736         return 0;
737 }
738
739 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
740 {
741         dvb_attach(dvb_pll_attach, adap->fe, 0x60,
742                    NULL, DVB_PLL_THOMSON_DTT7579);
743         return 0;
744 }
745
746 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
747 {
748         dvb_attach(simple_tuner_attach, adap->fe,
749                    &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
750         return 0;
751 }
752
753 static int dvico_bluebird_xc2028_callback(void *ptr, int component,
754                                           int command, int arg)
755 {
756         struct dvb_usb_adapter *adap = ptr;
757         struct dvb_usb_device *d = adap->dev;
758
759         switch (command) {
760         case XC2028_TUNER_RESET:
761                 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
762                 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
763                 break;
764         case XC2028_RESET_CLK:
765                 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
766                 break;
767         default:
768                 deb_info("%s: unknown command %d, arg %d\n", __func__,
769                          command, arg);
770                 return -EINVAL;
771         }
772
773         return 0;
774 }
775
776 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
777 {
778         struct dvb_frontend      *fe;
779         struct xc2028_config      cfg = {
780                 .i2c_adap  = &adap->dev->i2c_adap,
781                 .i2c_addr  = 0x61,
782         };
783         static struct xc2028_ctrl ctl = {
784                 .fname       = XC2028_DEFAULT_FIRMWARE,
785                 .max_len     = 64,
786                 .demod       = XC3028_FE_ZARLINK456,
787         };
788
789         /* FIXME: generalize & move to common area */
790         adap->fe->callback = dvico_bluebird_xc2028_callback;
791
792         fe = dvb_attach(xc2028_attach, adap->fe, &cfg);
793         if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
794                 return -EIO;
795
796         fe->ops.tuner_ops.set_config(fe, &ctl);
797
798         return 0;
799 }
800
801 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
802 {
803         dvb_attach(mxl5005s_attach, adap->fe,
804                    &adap->dev->i2c_adap, &aver_a868r_tuner);
805         return 0;
806 }
807
808 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
809 {
810         struct dvb_frontend *fe;
811         fe = dvb_attach(mxl5005s_attach, adap->fe,
812                         &adap->dev->i2c_adap, &d680_dmb_tuner);
813         return (fe == NULL) ? -EIO : 0;
814 }
815
816 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
817 {
818         u8 b;
819         if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
820                 err("set interface failed");
821
822         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
823
824         if ((adap->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
825                                    &adap->dev->i2c_adap)) != NULL)
826                 return 0;
827
828         return -EIO;
829 }
830
831 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
832 {
833         if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
834                 err("set interface failed");
835
836         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
837
838         if ((adap->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config,
839                                    &adap->dev->i2c_adap)) != NULL)
840                 return 0;
841
842         return -EIO;
843 }
844
845 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
846 {
847         adap->fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
848                               &adap->dev->i2c_adap);
849         if (adap->fe != NULL)
850                 return 0;
851
852         return -EIO;
853 }
854
855 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
856 {
857         /* used in both lgz201 and th7579 */
858         if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
859                 err("set interface failed");
860
861         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
862
863         if ((adap->fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
864                                    &adap->dev->i2c_adap)) != NULL)
865                 return 0;
866
867         return -EIO;
868 }
869
870 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
871 {
872         if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
873                 err("set interface failed");
874
875         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
876
877         if (((adap->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
878                                     &adap->dev->i2c_adap)) != NULL) ||
879                 ((adap->fe = dvb_attach(zl10353_attach,
880                                         &cxusb_zl10353_dee1601_config,
881                                         &adap->dev->i2c_adap)) != NULL))
882                 return 0;
883
884         return -EIO;
885 }
886
887 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
888 {
889         u8 ircode[4];
890         int i;
891         struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
892                                .buf = ircode, .len = 4 };
893
894         if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
895                 err("set interface failed");
896
897         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
898
899         /* reset the tuner and demodulator */
900         cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
901         cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
902         cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
903
904         if ((adap->fe = dvb_attach(zl10353_attach,
905                                    &cxusb_zl10353_xc3028_config_no_i2c_gate,
906                                    &adap->dev->i2c_adap)) == NULL)
907                 return -EIO;
908
909         /* try to determine if there is no IR decoder on the I2C bus */
910         for (i = 0; adap->dev->props.rc_key_map != NULL && i < 5; i++) {
911                 msleep(20);
912                 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
913                         goto no_IR;
914                 if (ircode[0] == 0 && ircode[1] == 0)
915                         continue;
916                 if (ircode[2] + ircode[3] != 0xff) {
917 no_IR:
918                         adap->dev->props.rc_key_map = NULL;
919                         info("No IR receiver detected on this device.");
920                         break;
921                 }
922         }
923
924         return 0;
925 }
926
927 static struct dibx000_agc_config dib7070_agc_config = {
928         .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
929
930         /*
931          * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
932          * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
933          * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
934          */
935         .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
936                  (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
937         .inv_gain = 600,
938         .time_stabiliz = 10,
939         .alpha_level = 0,
940         .thlock = 118,
941         .wbd_inv = 0,
942         .wbd_ref = 3530,
943         .wbd_sel = 1,
944         .wbd_alpha = 5,
945         .agc1_max = 65535,
946         .agc1_min = 0,
947         .agc2_max = 65535,
948         .agc2_min = 0,
949         .agc1_pt1 = 0,
950         .agc1_pt2 = 40,
951         .agc1_pt3 = 183,
952         .agc1_slope1 = 206,
953         .agc1_slope2 = 255,
954         .agc2_pt1 = 72,
955         .agc2_pt2 = 152,
956         .agc2_slope1 = 88,
957         .agc2_slope2 = 90,
958         .alpha_mant = 17,
959         .alpha_exp = 27,
960         .beta_mant = 23,
961         .beta_exp = 51,
962         .perform_agc_softsplit = 0,
963 };
964
965 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
966         .internal = 60000,
967         .sampling = 15000,
968         .pll_prediv = 1,
969         .pll_ratio = 20,
970         .pll_range = 3,
971         .pll_reset = 1,
972         .pll_bypass = 0,
973         .enable_refdiv = 0,
974         .bypclk_div = 0,
975         .IO_CLK_en_core = 1,
976         .ADClkSrc = 1,
977         .modulo = 2,
978         /* refsel, sel, freq_15k */
979         .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
980         .ifreq = (0 << 25) | 0,
981         .timf = 20452225,
982         .xtal_hz = 12000000,
983 };
984
985 static struct dib7000p_config cxusb_dualdig4_rev2_config = {
986         .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
987         .output_mpeg2_in_188_bytes = 1,
988
989         .agc_config_count = 1,
990         .agc = &dib7070_agc_config,
991         .bw  = &dib7070_bw_config_12_mhz,
992         .tuner_is_baseband = 1,
993         .spur_protect = 1,
994
995         .gpio_dir = 0xfcef,
996         .gpio_val = 0x0110,
997
998         .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
999
1000         .hostbus_diversity = 1,
1001 };
1002
1003 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1004 {
1005         if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1006                 err("set interface failed");
1007
1008         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1009
1010         cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1011
1012         dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1013                                  &cxusb_dualdig4_rev2_config);
1014
1015         adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1016                               &cxusb_dualdig4_rev2_config);
1017         if (adap->fe == NULL)
1018                 return -EIO;
1019
1020         return 0;
1021 }
1022
1023 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1024 {
1025         return dib7000p_set_gpio(fe, 8, 0, !onoff);
1026 }
1027
1028 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1029 {
1030         return 0;
1031 }
1032
1033 static struct dib0070_config dib7070p_dib0070_config = {
1034         .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1035         .reset = dib7070_tuner_reset,
1036         .sleep = dib7070_tuner_sleep,
1037         .clock_khz = 12000,
1038 };
1039
1040 struct dib0700_adapter_state {
1041         int (*set_param_save) (struct dvb_frontend *,
1042                                struct dvb_frontend_parameters *);
1043 };
1044
1045 static int dib7070_set_param_override(struct dvb_frontend *fe,
1046                                       struct dvb_frontend_parameters *fep)
1047 {
1048         struct dvb_usb_adapter *adap = fe->dvb->priv;
1049         struct dib0700_adapter_state *state = adap->priv;
1050
1051         u16 offset;
1052         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1053         switch (band) {
1054         case BAND_VHF: offset = 950; break;
1055         default:
1056         case BAND_UHF: offset = 550; break;
1057         }
1058
1059         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1060
1061         return state->set_param_save(fe, fep);
1062 }
1063
1064 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1065 {
1066         struct dib0700_adapter_state *st = adap->priv;
1067         struct i2c_adapter *tun_i2c =
1068                 dib7000p_get_i2c_master(adap->fe,
1069                                         DIBX000_I2C_INTERFACE_TUNER, 1);
1070
1071         if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1072             &dib7070p_dib0070_config) == NULL)
1073                 return -ENODEV;
1074
1075         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1076         adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1077         return 0;
1078 }
1079
1080 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1081 {
1082         if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1083                 err("set interface failed");
1084
1085         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1086
1087         /* reset the tuner and demodulator */
1088         cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1089         cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1090         cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1091
1092         if ((adap->fe = dvb_attach(zl10353_attach,
1093                                    &cxusb_zl10353_xc3028_config,
1094                                    &adap->dev->i2c_adap)) != NULL)
1095                 return 0;
1096
1097         if ((adap->fe = dvb_attach(mt352_attach,
1098                                    &cxusb_mt352_xc3028_config,
1099                                    &adap->dev->i2c_adap)) != NULL)
1100                 return 0;
1101
1102         return -EIO;
1103 }
1104
1105 static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1106         .prod = LGS8GXX_PROD_LGS8GL5,
1107         .demod_address = 0x19,
1108         .serial_ts = 0,
1109         .ts_clk_pol = 0,
1110         .ts_clk_gated = 1,
1111         .if_clk_freq = 30400, /* 30.4 MHz */
1112         .if_freq = 5725, /* 5.725 MHz */
1113         .if_neg_center = 0,
1114         .ext_adc = 0,
1115         .adc_signed = 0,
1116         .if_neg_edge = 0,
1117 };
1118
1119 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1120 {
1121         struct dvb_usb_device *d = adap->dev;
1122         int n;
1123
1124         /* Select required USB configuration */
1125         if (usb_set_interface(d->udev, 0, 0) < 0)
1126                 err("set interface failed");
1127
1128         /* Unblock all USB pipes */
1129         usb_clear_halt(d->udev,
1130                 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1131         usb_clear_halt(d->udev,
1132                 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1133         usb_clear_halt(d->udev,
1134                 usb_rcvbulkpipe(d->udev, d->props.adapter[0].stream.endpoint));
1135
1136         /* Drain USB pipes to avoid hang after reboot */
1137         for (n = 0;  n < 5;  n++) {
1138                 cxusb_d680_dmb_drain_message(d);
1139                 cxusb_d680_dmb_drain_video(d);
1140                 msleep(200);
1141         }
1142
1143         /* Reset the tuner */
1144         if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1145                 err("clear tuner gpio failed");
1146                 return -EIO;
1147         }
1148         msleep(100);
1149         if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1150                 err("set tuner gpio failed");
1151                 return -EIO;
1152         }
1153         msleep(100);
1154
1155         /* Attach frontend */
1156         adap->fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
1157         if (adap->fe == NULL)
1158                 return -EIO;
1159
1160         return 0;
1161 }
1162
1163 /*
1164  * DViCO has shipped two devices with the same USB ID, but only one of them
1165  * needs a firmware download.  Check the device class details to see if they
1166  * have non-default values to decide whether the device is actually cold or
1167  * not, and forget a match if it turns out we selected the wrong device.
1168  */
1169 static int bluebird_fx2_identify_state(struct usb_device *udev,
1170                                        struct dvb_usb_device_properties *props,
1171                                        struct dvb_usb_device_description **desc,
1172                                        int *cold)
1173 {
1174         int wascold = *cold;
1175
1176         *cold = udev->descriptor.bDeviceClass == 0xff &&
1177                 udev->descriptor.bDeviceSubClass == 0xff &&
1178                 udev->descriptor.bDeviceProtocol == 0xff;
1179
1180         if (*cold && !wascold)
1181                 *desc = NULL;
1182
1183         return 0;
1184 }
1185
1186 /*
1187  * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1188  * firmware file before download.
1189  */
1190
1191 static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1192 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1193                                                   const struct firmware *fw)
1194 {
1195         int pos;
1196
1197         for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1198                 int idoff = dvico_firmware_id_offsets[pos];
1199
1200                 if (fw->size < idoff + 4)
1201                         continue;
1202
1203                 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1204                     fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1205                         struct firmware new_fw;
1206                         u8 *new_fw_data = vmalloc(fw->size);
1207                         int ret;
1208
1209                         if (!new_fw_data)
1210                                 return -ENOMEM;
1211
1212                         memcpy(new_fw_data, fw->data, fw->size);
1213                         new_fw.size = fw->size;
1214                         new_fw.data = new_fw_data;
1215
1216                         new_fw_data[idoff + 2] =
1217                                 le16_to_cpu(udev->descriptor.idProduct) + 1;
1218                         new_fw_data[idoff + 3] =
1219                                 le16_to_cpu(udev->descriptor.idProduct) >> 8;
1220
1221                         ret = usb_cypress_load_firmware(udev, &new_fw,
1222                                                         CYPRESS_FX2);
1223                         vfree(new_fw_data);
1224                         return ret;
1225                 }
1226         }
1227
1228         return -EINVAL;
1229 }
1230
1231 /* DVB USB Driver stuff */
1232 static struct dvb_usb_device_properties cxusb_medion_properties;
1233 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1234 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1235 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1236 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1237 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1238 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1239 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1240 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1241 static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1242 static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1243
1244 static int cxusb_probe(struct usb_interface *intf,
1245                        const struct usb_device_id *id)
1246 {
1247         if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1248                                      THIS_MODULE, NULL, adapter_nr) ||
1249             0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1250                                      THIS_MODULE, NULL, adapter_nr) ||
1251             0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1252                                      THIS_MODULE, NULL, adapter_nr) ||
1253             0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1254                                      THIS_MODULE, NULL, adapter_nr) ||
1255             0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1256                                      THIS_MODULE, NULL, adapter_nr) ||
1257             0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1258                                      THIS_MODULE, NULL, adapter_nr) ||
1259             0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1260                                      THIS_MODULE, NULL, adapter_nr) ||
1261             0 == dvb_usb_device_init(intf,
1262                                 &cxusb_bluebird_nano2_needsfirmware_properties,
1263                                      THIS_MODULE, NULL, adapter_nr) ||
1264             0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1265                                      THIS_MODULE, NULL, adapter_nr) ||
1266             0 == dvb_usb_device_init(intf,
1267                                      &cxusb_bluebird_dualdig4_rev2_properties,
1268                                      THIS_MODULE, NULL, adapter_nr) ||
1269             0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1270                                      THIS_MODULE, NULL, adapter_nr) ||
1271             0)
1272                 return 0;
1273
1274         return -EINVAL;
1275 }
1276
1277 static struct usb_device_id cxusb_table [] = {
1278         { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
1279         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
1280         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
1281         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
1282         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
1283         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
1284         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
1285         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
1286         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
1287         { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
1288         { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
1289         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
1290         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
1291         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
1292         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
1293         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
1294         { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
1295         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
1296         { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
1297         {}              /* Terminating entry */
1298 };
1299 MODULE_DEVICE_TABLE (usb, cxusb_table);
1300
1301 static struct dvb_usb_device_properties cxusb_medion_properties = {
1302         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1303
1304         .usb_ctrl = CYPRESS_FX2,
1305
1306         .size_of_priv     = sizeof(struct cxusb_state),
1307
1308         .num_adapters = 1,
1309         .adapter = {
1310                 {
1311                         .streaming_ctrl   = cxusb_streaming_ctrl,
1312                         .frontend_attach  = cxusb_cx22702_frontend_attach,
1313                         .tuner_attach     = cxusb_fmd1216me_tuner_attach,
1314                         /* parameter for the MPEG2-data transfer */
1315                                         .stream = {
1316                                                 .type = USB_BULK,
1317                                 .count = 5,
1318                                 .endpoint = 0x02,
1319                                 .u = {
1320                                         .bulk = {
1321                                                 .buffersize = 8192,
1322                                         }
1323                                 }
1324                         },
1325
1326                 },
1327         },
1328         .power_ctrl       = cxusb_power_ctrl,
1329
1330         .i2c_algo         = &cxusb_i2c_algo,
1331
1332         .generic_bulk_ctrl_endpoint = 0x01,
1333
1334         .num_device_descs = 1,
1335         .devices = {
1336                 {   "Medion MD95700 (MDUSBTV-HYBRID)",
1337                         { NULL },
1338                         { &cxusb_table[0], NULL },
1339                 },
1340         }
1341 };
1342
1343 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1344         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1345
1346         .usb_ctrl          = DEVICE_SPECIFIC,
1347         .firmware          = "dvb-usb-bluebird-01.fw",
1348         .download_firmware = bluebird_patch_dvico_firmware_download,
1349         /* use usb alt setting 0 for EP4 transfer (dvb-t),
1350            use usb alt setting 7 for EP2 transfer (atsc) */
1351
1352         .size_of_priv     = sizeof(struct cxusb_state),
1353
1354         .num_adapters = 1,
1355         .adapter = {
1356                 {
1357                         .streaming_ctrl   = cxusb_streaming_ctrl,
1358                         .frontend_attach  = cxusb_lgdt3303_frontend_attach,
1359                         .tuner_attach     = cxusb_lgh064f_tuner_attach,
1360
1361                         /* parameter for the MPEG2-data transfer */
1362                                         .stream = {
1363                                                 .type = USB_BULK,
1364                                 .count = 5,
1365                                 .endpoint = 0x02,
1366                                 .u = {
1367                                         .bulk = {
1368                                                 .buffersize = 8192,
1369                                         }
1370                                 }
1371                         },
1372                 },
1373         },
1374
1375         .power_ctrl       = cxusb_bluebird_power_ctrl,
1376
1377         .i2c_algo         = &cxusb_i2c_algo,
1378
1379         .rc_interval      = 100,
1380         .rc_key_map       = dvico_portable_rc_keys,
1381         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
1382         .rc_query         = cxusb_rc_query,
1383
1384         .generic_bulk_ctrl_endpoint = 0x01,
1385
1386         .num_device_descs = 1,
1387         .devices = {
1388                 {   "DViCO FusionHDTV5 USB Gold",
1389                         { &cxusb_table[1], NULL },
1390                         { &cxusb_table[2], NULL },
1391                 },
1392         }
1393 };
1394
1395 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1396         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1397
1398         .usb_ctrl          = DEVICE_SPECIFIC,
1399         .firmware          = "dvb-usb-bluebird-01.fw",
1400         .download_firmware = bluebird_patch_dvico_firmware_download,
1401         /* use usb alt setting 0 for EP4 transfer (dvb-t),
1402            use usb alt setting 7 for EP2 transfer (atsc) */
1403
1404         .size_of_priv     = sizeof(struct cxusb_state),
1405
1406         .num_adapters = 1,
1407         .adapter = {
1408                 {
1409                         .streaming_ctrl   = cxusb_streaming_ctrl,
1410                         .frontend_attach  = cxusb_dee1601_frontend_attach,
1411                         .tuner_attach     = cxusb_dee1601_tuner_attach,
1412                         /* parameter for the MPEG2-data transfer */
1413                         .stream = {
1414                                 .type = USB_BULK,
1415                                 .count = 5,
1416                                 .endpoint = 0x04,
1417                                 .u = {
1418                                         .bulk = {
1419                                                 .buffersize = 8192,
1420                                         }
1421                                 }
1422                         },
1423                 },
1424         },
1425
1426         .power_ctrl       = cxusb_bluebird_power_ctrl,
1427
1428         .i2c_algo         = &cxusb_i2c_algo,
1429
1430         .rc_interval      = 150,
1431         .rc_key_map       = dvico_mce_rc_keys,
1432         .rc_key_map_size  = ARRAY_SIZE(dvico_mce_rc_keys),
1433         .rc_query         = cxusb_rc_query,
1434
1435         .generic_bulk_ctrl_endpoint = 0x01,
1436
1437         .num_device_descs = 3,
1438         .devices = {
1439                 {   "DViCO FusionHDTV DVB-T Dual USB",
1440                         { &cxusb_table[3], NULL },
1441                         { &cxusb_table[4], NULL },
1442                 },
1443                 {   "DigitalNow DVB-T Dual USB",
1444                         { &cxusb_table[9],  NULL },
1445                         { &cxusb_table[10], NULL },
1446                 },
1447                 {   "DViCO FusionHDTV DVB-T Dual Digital 2",
1448                         { &cxusb_table[11], NULL },
1449                         { &cxusb_table[12], NULL },
1450                 },
1451         }
1452 };
1453
1454 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1455         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1456
1457         .usb_ctrl          = DEVICE_SPECIFIC,
1458         .firmware          = "dvb-usb-bluebird-01.fw",
1459         .download_firmware = bluebird_patch_dvico_firmware_download,
1460         /* use usb alt setting 0 for EP4 transfer (dvb-t),
1461            use usb alt setting 7 for EP2 transfer (atsc) */
1462
1463         .size_of_priv     = sizeof(struct cxusb_state),
1464
1465         .num_adapters = 2,
1466         .adapter = {
1467                 {
1468                         .streaming_ctrl   = cxusb_streaming_ctrl,
1469                         .frontend_attach  = cxusb_mt352_frontend_attach,
1470                         .tuner_attach     = cxusb_lgz201_tuner_attach,
1471
1472                         /* parameter for the MPEG2-data transfer */
1473                         .stream = {
1474                                 .type = USB_BULK,
1475                                 .count = 5,
1476                                 .endpoint = 0x04,
1477                                 .u = {
1478                                         .bulk = {
1479                                                 .buffersize = 8192,
1480                                         }
1481                                 }
1482                         },
1483                 },
1484         },
1485         .power_ctrl       = cxusb_bluebird_power_ctrl,
1486
1487         .i2c_algo         = &cxusb_i2c_algo,
1488
1489         .rc_interval      = 100,
1490         .rc_key_map       = dvico_portable_rc_keys,
1491         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
1492         .rc_query         = cxusb_rc_query,
1493
1494         .generic_bulk_ctrl_endpoint = 0x01,
1495         .num_device_descs = 1,
1496         .devices = {
1497                 {   "DViCO FusionHDTV DVB-T USB (LGZ201)",
1498                         { &cxusb_table[5], NULL },
1499                         { &cxusb_table[6], NULL },
1500                 },
1501         }
1502 };
1503
1504 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1505         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1506
1507         .usb_ctrl          = DEVICE_SPECIFIC,
1508         .firmware          = "dvb-usb-bluebird-01.fw",
1509         .download_firmware = bluebird_patch_dvico_firmware_download,
1510         /* use usb alt setting 0 for EP4 transfer (dvb-t),
1511            use usb alt setting 7 for EP2 transfer (atsc) */
1512
1513         .size_of_priv     = sizeof(struct cxusb_state),
1514
1515         .num_adapters = 1,
1516         .adapter = {
1517                 {
1518                         .streaming_ctrl   = cxusb_streaming_ctrl,
1519                         .frontend_attach  = cxusb_mt352_frontend_attach,
1520                         .tuner_attach     = cxusb_dtt7579_tuner_attach,
1521
1522                         /* parameter for the MPEG2-data transfer */
1523                         .stream = {
1524                                 .type = USB_BULK,
1525                                 .count = 5,
1526                                 .endpoint = 0x04,
1527                                 .u = {
1528                                         .bulk = {
1529                                                 .buffersize = 8192,
1530                                         }
1531                                 }
1532                         },
1533                 },
1534         },
1535         .power_ctrl       = cxusb_bluebird_power_ctrl,
1536
1537         .i2c_algo         = &cxusb_i2c_algo,
1538
1539         .rc_interval      = 100,
1540         .rc_key_map       = dvico_portable_rc_keys,
1541         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
1542         .rc_query         = cxusb_rc_query,
1543
1544         .generic_bulk_ctrl_endpoint = 0x01,
1545
1546         .num_device_descs = 1,
1547         .devices = {
1548                 {   "DViCO FusionHDTV DVB-T USB (TH7579)",
1549                         { &cxusb_table[7], NULL },
1550                         { &cxusb_table[8], NULL },
1551                 },
1552         }
1553 };
1554
1555 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1556         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1557
1558         .usb_ctrl         = CYPRESS_FX2,
1559
1560         .size_of_priv     = sizeof(struct cxusb_state),
1561
1562         .num_adapters = 1,
1563         .adapter = {
1564                 {
1565                         .streaming_ctrl   = cxusb_streaming_ctrl,
1566                         .frontend_attach  = cxusb_dualdig4_frontend_attach,
1567                         .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
1568                         /* parameter for the MPEG2-data transfer */
1569                         .stream = {
1570                                 .type = USB_BULK,
1571                                 .count = 5,
1572                                 .endpoint = 0x02,
1573                                 .u = {
1574                                         .bulk = {
1575                                                 .buffersize = 8192,
1576                                         }
1577                                 }
1578                         },
1579                 },
1580         },
1581
1582         .power_ctrl       = cxusb_power_ctrl,
1583
1584         .i2c_algo         = &cxusb_i2c_algo,
1585
1586         .generic_bulk_ctrl_endpoint = 0x01,
1587
1588         .rc_interval      = 100,
1589         .rc_key_map       = dvico_mce_rc_keys,
1590         .rc_key_map_size  = ARRAY_SIZE(dvico_mce_rc_keys),
1591         .rc_query         = cxusb_bluebird2_rc_query,
1592
1593         .num_device_descs = 1,
1594         .devices = {
1595                 {   "DViCO FusionHDTV DVB-T Dual Digital 4",
1596                         { NULL },
1597                         { &cxusb_table[13], NULL },
1598                 },
1599         }
1600 };
1601
1602 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1603         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1604
1605         .usb_ctrl         = CYPRESS_FX2,
1606         .identify_state   = bluebird_fx2_identify_state,
1607
1608         .size_of_priv     = sizeof(struct cxusb_state),
1609
1610         .num_adapters = 1,
1611         .adapter = {
1612                 {
1613                         .streaming_ctrl   = cxusb_streaming_ctrl,
1614                         .frontend_attach  = cxusb_nano2_frontend_attach,
1615                         .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
1616                         /* parameter for the MPEG2-data transfer */
1617                         .stream = {
1618                                 .type = USB_BULK,
1619                                 .count = 5,
1620                                 .endpoint = 0x02,
1621                                 .u = {
1622                                         .bulk = {
1623                                                 .buffersize = 8192,
1624                                         }
1625                                 }
1626                         },
1627                 },
1628         },
1629
1630         .power_ctrl       = cxusb_nano2_power_ctrl,
1631
1632         .i2c_algo         = &cxusb_i2c_algo,
1633
1634         .generic_bulk_ctrl_endpoint = 0x01,
1635
1636         .rc_interval      = 100,
1637         .rc_key_map       = dvico_portable_rc_keys,
1638         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
1639         .rc_query         = cxusb_bluebird2_rc_query,
1640
1641         .num_device_descs = 1,
1642         .devices = {
1643                 {   "DViCO FusionHDTV DVB-T NANO2",
1644                         { NULL },
1645                         { &cxusb_table[14], NULL },
1646                 },
1647         }
1648 };
1649
1650 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1651         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1652
1653         .usb_ctrl          = DEVICE_SPECIFIC,
1654         .firmware          = "dvb-usb-bluebird-02.fw",
1655         .download_firmware = bluebird_patch_dvico_firmware_download,
1656         .identify_state    = bluebird_fx2_identify_state,
1657
1658         .size_of_priv      = sizeof(struct cxusb_state),
1659
1660         .num_adapters = 1,
1661         .adapter = {
1662                 {
1663                         .streaming_ctrl   = cxusb_streaming_ctrl,
1664                         .frontend_attach  = cxusb_nano2_frontend_attach,
1665                         .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
1666                         /* parameter for the MPEG2-data transfer */
1667                         .stream = {
1668                                 .type = USB_BULK,
1669                                 .count = 5,
1670                                 .endpoint = 0x02,
1671                                 .u = {
1672                                         .bulk = {
1673                                                 .buffersize = 8192,
1674                                         }
1675                                 }
1676                         },
1677                 },
1678         },
1679
1680         .power_ctrl       = cxusb_nano2_power_ctrl,
1681
1682         .i2c_algo         = &cxusb_i2c_algo,
1683
1684         .generic_bulk_ctrl_endpoint = 0x01,
1685
1686         .rc_interval      = 100,
1687         .rc_key_map       = dvico_portable_rc_keys,
1688         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
1689         .rc_query         = cxusb_rc_query,
1690
1691         .num_device_descs = 1,
1692         .devices = {
1693                 {   "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1694                         { &cxusb_table[14], NULL },
1695                         { &cxusb_table[15], NULL },
1696                 },
1697         }
1698 };
1699
1700 static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
1701         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1702
1703         .usb_ctrl         = CYPRESS_FX2,
1704
1705         .size_of_priv     = sizeof(struct cxusb_state),
1706
1707         .num_adapters = 1,
1708         .adapter = {
1709                 {
1710                         .streaming_ctrl   = cxusb_aver_streaming_ctrl,
1711                         .frontend_attach  = cxusb_aver_lgdt3303_frontend_attach,
1712                         .tuner_attach     = cxusb_mxl5003s_tuner_attach,
1713                         /* parameter for the MPEG2-data transfer */
1714                         .stream = {
1715                                 .type = USB_BULK,
1716                                 .count = 5,
1717                                 .endpoint = 0x04,
1718                                 .u = {
1719                                         .bulk = {
1720                                                 .buffersize = 8192,
1721                                         }
1722                                 }
1723                         },
1724
1725                 },
1726         },
1727         .power_ctrl       = cxusb_aver_power_ctrl,
1728
1729         .i2c_algo         = &cxusb_i2c_algo,
1730
1731         .generic_bulk_ctrl_endpoint = 0x01,
1732
1733         .num_device_descs = 1,
1734         .devices = {
1735                 {   "AVerMedia AVerTVHD Volar (A868R)",
1736                         { NULL },
1737                         { &cxusb_table[16], NULL },
1738                 },
1739         }
1740 };
1741
1742 static
1743 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
1744         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1745
1746         .usb_ctrl         = CYPRESS_FX2,
1747
1748         .size_of_priv     = sizeof(struct cxusb_state),
1749
1750         .num_adapters = 1,
1751         .adapter = {
1752                 {
1753                         .streaming_ctrl  = cxusb_streaming_ctrl,
1754                         .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
1755                         .tuner_attach    = cxusb_dualdig4_rev2_tuner_attach,
1756                         .size_of_priv    = sizeof(struct dib0700_adapter_state),
1757                         /* parameter for the MPEG2-data transfer */
1758                         .stream = {
1759                                 .type = USB_BULK,
1760                                 .count = 7,
1761                                 .endpoint = 0x02,
1762                                 .u = {
1763                                         .bulk = {
1764                                                 .buffersize = 4096,
1765                                         }
1766                                 }
1767                         },
1768                 },
1769         },
1770
1771         .power_ctrl       = cxusb_bluebird_power_ctrl,
1772
1773         .i2c_algo         = &cxusb_i2c_algo,
1774
1775         .generic_bulk_ctrl_endpoint = 0x01,
1776
1777         .rc_interval      = 100,
1778         .rc_key_map       = dvico_mce_rc_keys,
1779         .rc_key_map_size  = ARRAY_SIZE(dvico_mce_rc_keys),
1780         .rc_query         = cxusb_rc_query,
1781
1782         .num_device_descs = 1,
1783         .devices = {
1784                 {   "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
1785                         { NULL },
1786                         { &cxusb_table[17], NULL },
1787                 },
1788         }
1789 };
1790
1791 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
1792         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1793
1794         .usb_ctrl         = CYPRESS_FX2,
1795
1796         .size_of_priv     = sizeof(struct cxusb_state),
1797
1798         .num_adapters = 1,
1799         .adapter = {
1800                 {
1801                         .streaming_ctrl   = cxusb_d680_dmb_streaming_ctrl,
1802                         .frontend_attach  = cxusb_d680_dmb_frontend_attach,
1803                         .tuner_attach     = cxusb_d680_dmb_tuner_attach,
1804
1805                         /* parameter for the MPEG2-data transfer */
1806                         .stream = {
1807                                 .type = USB_BULK,
1808                                 .count = 5,
1809                                 .endpoint = 0x02,
1810                                 .u = {
1811                                         .bulk = {
1812                                                 .buffersize = 8192,
1813                                         }
1814                                 }
1815                         },
1816                 },
1817         },
1818
1819         .power_ctrl       = cxusb_d680_dmb_power_ctrl,
1820
1821         .i2c_algo         = &cxusb_i2c_algo,
1822
1823         .generic_bulk_ctrl_endpoint = 0x01,
1824
1825         .rc_interval      = 100,
1826         .rc_key_map       = d680_dmb_rc_keys,
1827         .rc_key_map_size  = ARRAY_SIZE(d680_dmb_rc_keys),
1828         .rc_query         = cxusb_d680_dmb_rc_query,
1829
1830         .num_device_descs = 1,
1831         .devices = {
1832                 {
1833                         "Conexant DMB-TH Stick",
1834                         { NULL },
1835                         { &cxusb_table[18], NULL },
1836                 },
1837         }
1838 };
1839
1840 static struct usb_driver cxusb_driver = {
1841         .name           = "dvb_usb_cxusb",
1842         .probe          = cxusb_probe,
1843         .disconnect     = dvb_usb_device_exit,
1844         .id_table       = cxusb_table,
1845 };
1846
1847 /* module stuff */
1848 static int __init cxusb_module_init(void)
1849 {
1850         int result;
1851         if ((result = usb_register(&cxusb_driver))) {
1852                 err("usb_register failed. Error number %d",result);
1853                 return result;
1854         }
1855
1856         return 0;
1857 }
1858
1859 static void __exit cxusb_module_exit(void)
1860 {
1861         /* deregister this driver from the USB subsystem */
1862         usb_deregister(&cxusb_driver);
1863 }
1864
1865 module_init (cxusb_module_init);
1866 module_exit (cxusb_module_exit);
1867
1868 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
1869 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1870 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
1871 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
1872 MODULE_VERSION("1.0-alpha");
1873 MODULE_LICENSE("GPL");