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