Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/media/usb/dvb-usb/cxusb.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us