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