git.oblomov.eu Git - linux-2.6/blob - drivers/media/dvb/dvb-usb/cxusb.c

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