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