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 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 "cxusb.h"
  27
  28 #include "cx22702.h"
  29 #include "lgdt330x.h"
  30 #include "mt352.h"
  31 #include "mt352_priv.h"
  32 #include "zl10353.h"
  33
  34 /* debug */
  35 static int dvb_usb_cxusb_debug;
  36 module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
  37 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
  38 #define deb_info(args...)   dprintk(dvb_usb_cxusb_debug,0x01,args)
  39 #define deb_i2c(args...)    if (d->udev->descriptor.idVendor == USB_VID_MEDION) \
  40                                 dprintk(dvb_usb_cxusb_debug,0x01,args)
  41
  42 static int cxusb_ctrl_msg(struct dvb_usb_device *d,
  43                           u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
  44 {
  45         int wo = (rbuf == NULL || rlen == 0); /* write-only */
  46         u8 sndbuf[1+wlen];
  47         memset(sndbuf, 0, 1+wlen);
  48
  49         sndbuf[0] = cmd;
  50         memcpy(&sndbuf[1], wbuf, wlen);
  51         if (wo)
  52                 return dvb_usb_generic_write(d, sndbuf, 1+wlen);
  53         else
  54                 return dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0);
  55 }
  56
  57 /* GPIO */
  58 static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
  59 {
  60         struct cxusb_state *st = d->priv;
  61         u8 o[2], i;
  62
  63         if (st->gpio_write_state[GPIO_TUNER] == onoff)
  64                 return;
  65
  66         o[0] = GPIO_TUNER;
  67         o[1] = onoff;
  68         cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
  69
  70         if (i != 0x01)
  71                 deb_info("gpio_write failed.\n");
  72
  73         st->gpio_write_state[GPIO_TUNER] = onoff;
  74 }
  75
  76 /* I2C */
  77 static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
  78                           int num)
  79 {
  80         struct dvb_usb_device *d = i2c_get_adapdata(adap);
  81         int i;
  82
  83         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
  84                 return -EAGAIN;
  85
  86         for (i = 0; i < num; i++) {
  87
  88                 if (d->udev->descriptor.idVendor == USB_VID_MEDION)
  89                         switch (msg[i].addr) {
  90                         case 0x63:
  91                                 cxusb_gpio_tuner(d, 0);
  92                                 break;
  93                         default:
  94                                 cxusb_gpio_tuner(d, 1);
  95                                 break;
  96                         }
  97
  98                 if (msg[i].flags & I2C_M_RD) {
  99                         /* read only */
 100                         u8 obuf[3], ibuf[1+msg[i].len];
 101                         obuf[0] = 0;
 102                         obuf[1] = msg[i].len;
 103                         obuf[2] = msg[i].addr;
 104                         if (cxusb_ctrl_msg(d, CMD_I2C_READ,
 105                                            obuf, 3,
 106                                            ibuf, 1+msg[i].len) < 0) {
 107                                 warn("i2c read failed");
 108                                 break;
 109                         }
 110                         memcpy(msg[i].buf, &ibuf[1], msg[i].len);
 111                 } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) &&
 112                            msg[i].addr == msg[i+1].addr) {
 113                         /* write to then read from same address */
 114                         u8 obuf[3+msg[i].len], ibuf[1+msg[i+1].len];
 115                         obuf[0] = msg[i].len;
 116                         obuf[1] = msg[i+1].len;
 117                         obuf[2] = msg[i].addr;
 118                         memcpy(&obuf[3], msg[i].buf, msg[i].len);
 119
 120                         if (cxusb_ctrl_msg(d, CMD_I2C_READ,
 121                                            obuf, 3+msg[i].len,
 122                                            ibuf, 1+msg[i+1].len) < 0)
 123                                 break;
 124
 125                         if (ibuf[0] != 0x08)
 126                                 deb_i2c("i2c read may have failed\n");
 127
 128                         memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
 129
 130                         i++;
 131                 } else {
 132                         /* write only */
 133                         u8 obuf[2+msg[i].len], ibuf;
 134                         obuf[0] = msg[i].addr;
 135                         obuf[1] = msg[i].len;
 136                         memcpy(&obuf[2], msg[i].buf, msg[i].len);
 137
 138                         if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
 139                                            2+msg[i].len, &ibuf,1) < 0)
 140                                 break;
 141                         if (ibuf != 0x08)
 142                                 deb_i2c("i2c write may have failed\n");
 143                 }
 144         }
 145
 146         mutex_unlock(&d->i2c_mutex);
 147         return i == num ? num : -EREMOTEIO;
 148 }
 149
 150 static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
 151 {
 152         return I2C_FUNC_I2C;
 153 }
 154
 155 static struct i2c_algorithm cxusb_i2c_algo = {
 156         .master_xfer   = cxusb_i2c_xfer,
 157         .functionality = cxusb_i2c_func,
 158 };
 159
 160 static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
 161 {
 162         u8 b = 0;
 163         if (onoff)
 164                 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
 165         else
 166                 return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0);
 167 }
 168
 169 static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
 170 {
 171         u8 b = 0;
 172         if (onoff)
 173                 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
 174         else
 175                 return 0;
 176 }
 177
 178 static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
 179 {
 180         u8 buf[2] = { 0x03, 0x00 };
 181         if (onoff)
 182                 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
 183         else
 184                 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
 185
 186         return 0;
 187 }
 188
 189 static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
 190 {
 191         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
 192         u8 ircode[4];
 193         int i;
 194
 195         cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
 196
 197         *event = 0;
 198         *state = REMOTE_NO_KEY_PRESSED;
 199
 200         for (i = 0; i < d->props.rc_key_map_size; i++) {
 201                 if (keymap[i].custom == ircode[2] &&
 202                     keymap[i].data == ircode[3]) {
 203                         *event = keymap[i].event;
 204                         *state = REMOTE_KEY_PRESSED;
 205
 206                         return 0;
 207                 }
 208         }
 209
 210         return 0;
 211 }
 212
 213 static struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
 214         { 0xfe, 0x02, KEY_TV },
 215         { 0xfe, 0x0e, KEY_MP3 },
 216         { 0xfe, 0x1a, KEY_DVD },
 217         { 0xfe, 0x1e, KEY_FAVORITES },
 218         { 0xfe, 0x16, KEY_SETUP },
 219         { 0xfe, 0x46, KEY_POWER2 },
 220         { 0xfe, 0x0a, KEY_EPG },
 221         { 0xfe, 0x49, KEY_BACK },
 222         { 0xfe, 0x4d, KEY_MENU },
 223         { 0xfe, 0x51, KEY_UP },
 224         { 0xfe, 0x5b, KEY_LEFT },
 225         { 0xfe, 0x5f, KEY_RIGHT },
 226         { 0xfe, 0x53, KEY_DOWN },
 227         { 0xfe, 0x5e, KEY_OK },
 228         { 0xfe, 0x59, KEY_INFO },
 229         { 0xfe, 0x55, KEY_TAB },
 230         { 0xfe, 0x0f, KEY_PREVIOUSSONG },/* Replay */
 231         { 0xfe, 0x12, KEY_NEXTSONG },   /* Skip */
 232         { 0xfe, 0x42, KEY_ENTER  },     /* Windows/Start */
 233         { 0xfe, 0x15, KEY_VOLUMEUP },
 234         { 0xfe, 0x05, KEY_VOLUMEDOWN },
 235         { 0xfe, 0x11, KEY_CHANNELUP },
 236         { 0xfe, 0x09, KEY_CHANNELDOWN },
 237         { 0xfe, 0x52, KEY_CAMERA },
 238         { 0xfe, 0x5a, KEY_TUNER },      /* Live */
 239         { 0xfe, 0x19, KEY_OPEN },
 240         { 0xfe, 0x0b, KEY_1 },
 241         { 0xfe, 0x17, KEY_2 },
 242         { 0xfe, 0x1b, KEY_3 },
 243         { 0xfe, 0x07, KEY_4 },
 244         { 0xfe, 0x50, KEY_5 },
 245         { 0xfe, 0x54, KEY_6 },
 246         { 0xfe, 0x48, KEY_7 },
 247         { 0xfe, 0x4c, KEY_8 },
 248         { 0xfe, 0x58, KEY_9 },
 249         { 0xfe, 0x13, KEY_ANGLE },      /* Aspect */
 250         { 0xfe, 0x03, KEY_0 },
 251         { 0xfe, 0x1f, KEY_ZOOM },
 252         { 0xfe, 0x43, KEY_REWIND },
 253         { 0xfe, 0x47, KEY_PLAYPAUSE },
 254         { 0xfe, 0x4f, KEY_FASTFORWARD },
 255         { 0xfe, 0x57, KEY_MUTE },
 256         { 0xfe, 0x0d, KEY_STOP },
 257         { 0xfe, 0x01, KEY_RECORD },
 258         { 0xfe, 0x4e, KEY_POWER },
 259 };
 260
 261 static struct dvb_usb_rc_key dvico_portable_rc_keys[] = {
 262         { 0xfc, 0x02, KEY_SETUP },       /* Profile */
 263         { 0xfc, 0x43, KEY_POWER2 },
 264         { 0xfc, 0x06, KEY_EPG },
 265         { 0xfc, 0x5a, KEY_BACK },
 266         { 0xfc, 0x05, KEY_MENU },
 267         { 0xfc, 0x47, KEY_INFO },
 268         { 0xfc, 0x01, KEY_TAB },
 269         { 0xfc, 0x42, KEY_PREVIOUSSONG },/* Replay */
 270         { 0xfc, 0x49, KEY_VOLUMEUP },
 271         { 0xfc, 0x09, KEY_VOLUMEDOWN },
 272         { 0xfc, 0x54, KEY_CHANNELUP },
 273         { 0xfc, 0x0b, KEY_CHANNELDOWN },
 274         { 0xfc, 0x16, KEY_CAMERA },
 275         { 0xfc, 0x40, KEY_TUNER },      /* ATV/DTV */
 276         { 0xfc, 0x45, KEY_OPEN },
 277         { 0xfc, 0x19, KEY_1 },
 278         { 0xfc, 0x18, KEY_2 },
 279         { 0xfc, 0x1b, KEY_3 },
 280         { 0xfc, 0x1a, KEY_4 },
 281         { 0xfc, 0x58, KEY_5 },
 282         { 0xfc, 0x59, KEY_6 },
 283         { 0xfc, 0x15, KEY_7 },
 284         { 0xfc, 0x14, KEY_8 },
 285         { 0xfc, 0x17, KEY_9 },
 286         { 0xfc, 0x44, KEY_ANGLE },      /* Aspect */
 287         { 0xfc, 0x55, KEY_0 },
 288         { 0xfc, 0x07, KEY_ZOOM },
 289         { 0xfc, 0x0a, KEY_REWIND },
 290         { 0xfc, 0x08, KEY_PLAYPAUSE },
 291         { 0xfc, 0x4b, KEY_FASTFORWARD },
 292         { 0xfc, 0x5b, KEY_MUTE },
 293         { 0xfc, 0x04, KEY_STOP },
 294         { 0xfc, 0x56, KEY_RECORD },
 295         { 0xfc, 0x57, KEY_POWER },
 296         { 0xfc, 0x41, KEY_UNKNOWN },    /* INPUT */
 297         { 0xfc, 0x00, KEY_UNKNOWN },    /* HD */
 298 };
 299
 300 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
 301 {
 302         static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x28 };
 303         static u8 reset []         = { RESET,      0x80 };
 304         static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
 305         static u8 agc_cfg []       = { AGC_TARGET, 0x28, 0x20 };
 306         static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
 307         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
 308
 309         mt352_write(fe, clock_config,   sizeof(clock_config));
 310         udelay(200);
 311         mt352_write(fe, reset,          sizeof(reset));
 312         mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
 313
 314         mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
 315         mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
 316         mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
 317
 318         return 0;
 319 }
 320
 321 static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
 322 {       /* used in both lgz201 and th7579 */
 323         static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x29 };
 324         static u8 reset []         = { RESET,      0x80 };
 325         static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
 326         static u8 agc_cfg []       = { AGC_TARGET, 0x24, 0x20 };
 327         static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
 328         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
 329
 330         mt352_write(fe, clock_config,   sizeof(clock_config));
 331         udelay(200);
 332         mt352_write(fe, reset,          sizeof(reset));
 333         mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
 334
 335         mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
 336         mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
 337         mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
 338         return 0;
 339 }
 340
 341 static struct cx22702_config cxusb_cx22702_config = {
 342         .demod_address = 0x63,
 343         .output_mode = CX22702_PARALLEL_OUTPUT,
 344 };
 345
 346 static struct lgdt330x_config cxusb_lgdt3303_config = {
 347         .demod_address = 0x0e,
 348         .demod_chip    = LGDT3303,
 349 };
 350
 351 static struct mt352_config cxusb_dee1601_config = {
 352         .demod_address = 0x0f,
 353         .demod_init    = cxusb_dee1601_demod_init,
 354 };
 355
 356 static struct zl10353_config cxusb_zl10353_dee1601_config = {
 357         .demod_address = 0x0f,
 358         .parallel_ts = 1,
 359 };
 360
 361 static struct mt352_config cxusb_mt352_config = {
 362         /* used in both lgz201 and th7579 */
 363         .demod_address = 0x0f,
 364         .demod_init    = cxusb_mt352_demod_init,
 365 };
 366
 367 /* Callbacks for DVB USB */
 368 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
 369 {
 370         dvb_attach(dvb_pll_attach, adap->fe, 0x61, &adap->dev->i2c_adap,
 371                    DVB_PLL_FMD1216ME);
 372         return 0;
 373 }
 374
 375 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
 376 {
 377         dvb_attach(dvb_pll_attach, adap->fe, 0x61,
 378                    NULL, DVB_PLL_THOMSON_DTT7579);
 379         return 0;
 380 }
 381
 382 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
 383 {
 384         dvb_attach(dvb_pll_attach, adap->fe, 0x61, NULL, DVB_PLL_LG_Z201);
 385         return 0;
 386 }
 387
 388 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
 389 {
 390         dvb_attach(dvb_pll_attach, adap->fe, 0x60,
 391                    NULL, DVB_PLL_THOMSON_DTT7579);
 392         return 0;
 393 }
 394
 395 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
 396 {
 397         dvb_attach(dvb_pll_attach, adap->fe, 0x61, &adap->dev->i2c_adap,
 398                    DVB_PLL_LG_TDVS_H06XF);
 399         return 0;
 400 }
 401
 402 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
 403 {
 404         u8 b;
 405         if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
 406                 err("set interface failed");
 407
 408         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
 409
 410         if ((adap->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
 411                                    &adap->dev->i2c_adap)) != NULL)
 412                 return 0;
 413
 414         return -EIO;
 415 }
 416
 417 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
 418 {
 419         if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
 420                 err("set interface failed");
 421
 422         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
 423
 424         if ((adap->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config,
 425                                    &adap->dev->i2c_adap)) != NULL)
 426                 return 0;
 427
 428         return -EIO;
 429 }
 430
 431 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
 432 {
 433         /* used in both lgz201 and th7579 */
 434         if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
 435                 err("set interface failed");
 436
 437         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
 438
 439         if ((adap->fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
 440                                    &adap->dev->i2c_adap)) != NULL)
 441                 return 0;
 442
 443         return -EIO;
 444 }
 445
 446 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
 447 {
 448         if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
 449                 err("set interface failed");
 450
 451         cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
 452
 453         if (((adap->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
 454                                     &adap->dev->i2c_adap)) != NULL) ||
 455                 ((adap->fe = dvb_attach(zl10353_attach,
 456                                         &cxusb_zl10353_dee1601_config,
 457                                         &adap->dev->i2c_adap)) != NULL))
 458                 return 0;
 459
 460         return -EIO;
 461 }
 462
 463 /*
 464  * DViCO bluebird firmware needs the "warm" product ID to be patched into the
 465  * firmware file before download.
 466  */
 467
 468 #define BLUEBIRD_01_ID_OFFSET 6638
 469 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
 470                                                   const struct firmware *fw)
 471 {
 472         if (fw->size < BLUEBIRD_01_ID_OFFSET + 4)
 473                 return -EINVAL;
 474
 475         if (fw->data[BLUEBIRD_01_ID_OFFSET] == (USB_VID_DVICO & 0xff) &&
 476             fw->data[BLUEBIRD_01_ID_OFFSET + 1] == USB_VID_DVICO >> 8) {
 477
 478                 fw->data[BLUEBIRD_01_ID_OFFSET + 2] =
 479                         le16_to_cpu(udev->descriptor.idProduct) + 1;
 480                 fw->data[BLUEBIRD_01_ID_OFFSET + 3] =
 481                         le16_to_cpu(udev->descriptor.idProduct) >> 8;
 482
 483                 return usb_cypress_load_firmware(udev, fw, CYPRESS_FX2);
 484         }
 485
 486         return -EINVAL;
 487 }
 488
 489 /* DVB USB Driver stuff */
 490 static struct dvb_usb_device_properties cxusb_medion_properties;
 491 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
 492 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
 493 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
 494 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
 495
 496 static int cxusb_probe(struct usb_interface *intf,
 497                        const struct usb_device_id *id)
 498 {
 499         if (dvb_usb_device_init(intf,&cxusb_medion_properties,THIS_MODULE,NULL) == 0 ||
 500                 dvb_usb_device_init(intf,&cxusb_bluebird_lgh064f_properties,THIS_MODULE,NULL) == 0 ||
 501                 dvb_usb_device_init(intf,&cxusb_bluebird_dee1601_properties,THIS_MODULE,NULL) == 0 ||
 502                 dvb_usb_device_init(intf,&cxusb_bluebird_lgz201_properties,THIS_MODULE,NULL) == 0 ||
 503                 dvb_usb_device_init(intf,&cxusb_bluebird_dtt7579_properties,THIS_MODULE,NULL) == 0) {
 504                 return 0;
 505         }
 506
 507         return -EINVAL;
 508 }
 509
 510 static struct usb_device_id cxusb_table [] = {
 511         { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
 512         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
 513         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
 514         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
 515         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
 516         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
 517         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
 518         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
 519         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
 520         { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
 521         { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
 522         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
 523         { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
 524         {}              /* Terminating entry */
 525 };
 526 MODULE_DEVICE_TABLE (usb, cxusb_table);
 527
 528 static struct dvb_usb_device_properties cxusb_medion_properties = {
 529         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 530
 531         .usb_ctrl = CYPRESS_FX2,
 532
 533         .size_of_priv     = sizeof(struct cxusb_state),
 534
 535         .num_adapters = 1,
 536         .adapter = {
 537                 {
 538                         .streaming_ctrl   = cxusb_streaming_ctrl,
 539                         .frontend_attach  = cxusb_cx22702_frontend_attach,
 540                         .tuner_attach     = cxusb_fmd1216me_tuner_attach,
 541                         /* parameter for the MPEG2-data transfer */
 542                                         .stream = {
 543                                                 .type = USB_BULK,
 544                                 .count = 5,
 545                                 .endpoint = 0x02,
 546                                 .u = {
 547                                         .bulk = {
 548                                                 .buffersize = 8192,
 549                                         }
 550                                 }
 551                         },
 552
 553                 },
 554         },
 555         .power_ctrl       = cxusb_power_ctrl,
 556
 557         .i2c_algo         = &cxusb_i2c_algo,
 558
 559         .generic_bulk_ctrl_endpoint = 0x01,
 560
 561         .num_device_descs = 1,
 562         .devices = {
 563                 {   "Medion MD95700 (MDUSBTV-HYBRID)",
 564                         { NULL },
 565                         { &cxusb_table[0], NULL },
 566                 },
 567         }
 568 };
 569
 570 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
 571         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 572
 573         .usb_ctrl          = DEVICE_SPECIFIC,
 574         .firmware          = "dvb-usb-bluebird-01.fw",
 575         .download_firmware = bluebird_patch_dvico_firmware_download,
 576         /* use usb alt setting 0 for EP4 transfer (dvb-t),
 577            use usb alt setting 7 for EP2 transfer (atsc) */
 578
 579         .size_of_priv     = sizeof(struct cxusb_state),
 580
 581         .num_adapters = 1,
 582         .adapter = {
 583                 {
 584                         .streaming_ctrl   = cxusb_streaming_ctrl,
 585                         .frontend_attach  = cxusb_lgdt3303_frontend_attach,
 586                         .tuner_attach     = cxusb_lgh064f_tuner_attach,
 587
 588                         /* parameter for the MPEG2-data transfer */
 589                                         .stream = {
 590                                                 .type = USB_BULK,
 591                                 .count = 5,
 592                                 .endpoint = 0x02,
 593                                 .u = {
 594                                         .bulk = {
 595                                                 .buffersize = 8192,
 596                                         }
 597                                 }
 598                         },
 599                 },
 600         },
 601
 602         .power_ctrl       = cxusb_bluebird_power_ctrl,
 603
 604         .i2c_algo         = &cxusb_i2c_algo,
 605
 606         .rc_interval      = 100,
 607         .rc_key_map       = dvico_portable_rc_keys,
 608         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
 609         .rc_query         = cxusb_rc_query,
 610
 611         .generic_bulk_ctrl_endpoint = 0x01,
 612
 613         .num_device_descs = 1,
 614         .devices = {
 615                 {   "DViCO FusionHDTV5 USB Gold",
 616                         { &cxusb_table[1], NULL },
 617                         { &cxusb_table[2], NULL },
 618                 },
 619         }
 620 };
 621
 622 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
 623         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 624
 625         .usb_ctrl          = DEVICE_SPECIFIC,
 626         .firmware          = "dvb-usb-bluebird-01.fw",
 627         .download_firmware = bluebird_patch_dvico_firmware_download,
 628         /* use usb alt setting 0 for EP4 transfer (dvb-t),
 629            use usb alt setting 7 for EP2 transfer (atsc) */
 630
 631         .size_of_priv     = sizeof(struct cxusb_state),
 632
 633         .num_adapters = 1,
 634         .adapter = {
 635                 {
 636                         .streaming_ctrl   = cxusb_streaming_ctrl,
 637                         .frontend_attach  = cxusb_dee1601_frontend_attach,
 638                         .tuner_attach     = cxusb_dee1601_tuner_attach,
 639                         /* parameter for the MPEG2-data transfer */
 640                         .stream = {
 641                                 .type = USB_BULK,
 642                                 .count = 5,
 643                                 .endpoint = 0x04,
 644                                 .u = {
 645                                         .bulk = {
 646                                                 .buffersize = 8192,
 647                                         }
 648                                 }
 649                         },
 650                 },
 651         },
 652
 653         .power_ctrl       = cxusb_bluebird_power_ctrl,
 654
 655         .i2c_algo         = &cxusb_i2c_algo,
 656
 657         .rc_interval      = 150,
 658         .rc_key_map       = dvico_mce_rc_keys,
 659         .rc_key_map_size  = ARRAY_SIZE(dvico_mce_rc_keys),
 660         .rc_query         = cxusb_rc_query,
 661
 662         .generic_bulk_ctrl_endpoint = 0x01,
 663
 664         .num_device_descs = 3,
 665         .devices = {
 666                 {   "DViCO FusionHDTV DVB-T Dual USB",
 667                         { &cxusb_table[3], NULL },
 668                         { &cxusb_table[4], NULL },
 669                 },
 670                 {   "DigitalNow DVB-T Dual USB",
 671                         { &cxusb_table[9],  NULL },
 672                         { &cxusb_table[10], NULL },
 673                 },
 674                 {   "DViCO FusionHDTV DVB-T Dual Digital 2",
 675                         { &cxusb_table[11], NULL },
 676                         { &cxusb_table[12], NULL },
 677                 },
 678         }
 679 };
 680
 681 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
 682         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 683
 684         .usb_ctrl          = DEVICE_SPECIFIC,
 685         .firmware          = "dvb-usb-bluebird-01.fw",
 686         .download_firmware = bluebird_patch_dvico_firmware_download,
 687         /* use usb alt setting 0 for EP4 transfer (dvb-t),
 688            use usb alt setting 7 for EP2 transfer (atsc) */
 689
 690         .size_of_priv     = sizeof(struct cxusb_state),
 691
 692         .num_adapters = 2,
 693         .adapter = {
 694                 {
 695                         .streaming_ctrl   = cxusb_streaming_ctrl,
 696                         .frontend_attach  = cxusb_mt352_frontend_attach,
 697                         .tuner_attach     = cxusb_lgz201_tuner_attach,
 698
 699                         /* parameter for the MPEG2-data transfer */
 700                         .stream = {
 701                                 .type = USB_BULK,
 702                                 .count = 5,
 703                                 .endpoint = 0x04,
 704                                 .u = {
 705                                         .bulk = {
 706                                                 .buffersize = 8192,
 707                                         }
 708                                 }
 709                         },
 710                 },
 711         },
 712         .power_ctrl       = cxusb_bluebird_power_ctrl,
 713
 714         .i2c_algo         = &cxusb_i2c_algo,
 715
 716         .rc_interval      = 100,
 717         .rc_key_map       = dvico_portable_rc_keys,
 718         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
 719         .rc_query         = cxusb_rc_query,
 720
 721         .generic_bulk_ctrl_endpoint = 0x01,
 722         .num_device_descs = 1,
 723         .devices = {
 724                 {   "DViCO FusionHDTV DVB-T USB (LGZ201)",
 725                         { &cxusb_table[5], NULL },
 726                         { &cxusb_table[6], NULL },
 727                 },
 728         }
 729 };
 730
 731 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
 732         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 733
 734         .usb_ctrl          = DEVICE_SPECIFIC,
 735         .firmware          = "dvb-usb-bluebird-01.fw",
 736         .download_firmware = bluebird_patch_dvico_firmware_download,
 737         /* use usb alt setting 0 for EP4 transfer (dvb-t),
 738            use usb alt setting 7 for EP2 transfer (atsc) */
 739
 740         .size_of_priv     = sizeof(struct cxusb_state),
 741
 742         .num_adapters = 1,
 743         .adapter = {
 744                 {
 745                         .streaming_ctrl   = cxusb_streaming_ctrl,
 746                         .frontend_attach  = cxusb_mt352_frontend_attach,
 747                         .tuner_attach     = cxusb_dtt7579_tuner_attach,
 748
 749                         /* parameter for the MPEG2-data transfer */
 750                         .stream = {
 751                                 .type = USB_BULK,
 752                                 .count = 5,
 753                                 .endpoint = 0x04,
 754                                 .u = {
 755                                         .bulk = {
 756                                                 .buffersize = 8192,
 757                                         }
 758                                 }
 759                         },
 760                 },
 761         },
 762         .power_ctrl       = cxusb_bluebird_power_ctrl,
 763
 764         .i2c_algo         = &cxusb_i2c_algo,
 765
 766         .rc_interval      = 100,
 767         .rc_key_map       = dvico_portable_rc_keys,
 768         .rc_key_map_size  = ARRAY_SIZE(dvico_portable_rc_keys),
 769         .rc_query         = cxusb_rc_query,
 770
 771         .generic_bulk_ctrl_endpoint = 0x01,
 772
 773         .num_device_descs = 1,
 774         .devices = {
 775                 {   "DViCO FusionHDTV DVB-T USB (TH7579)",
 776                         { &cxusb_table[7], NULL },
 777                         { &cxusb_table[8], NULL },
 778                 },
 779         }
 780 };
 781
 782 static struct usb_driver cxusb_driver = {
 783         .name           = "dvb_usb_cxusb",
 784         .probe          = cxusb_probe,
 785         .disconnect     = dvb_usb_device_exit,
 786         .id_table       = cxusb_table,
 787 };
 788
 789 /* module stuff */
 790 static int __init cxusb_module_init(void)
 791 {
 792         int result;
 793         if ((result = usb_register(&cxusb_driver))) {
 794                 err("usb_register failed. Error number %d",result);
 795                 return result;
 796         }
 797
 798         return 0;
 799 }
 800
 801 static void __exit cxusb_module_exit(void)
 802 {
 803         /* deregister this driver from the USB subsystem */
 804         usb_deregister(&cxusb_driver);
 805 }
 806
 807 module_init (cxusb_module_init);
 808 module_exit (cxusb_module_exit);
 809
 810 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
 811 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
 812 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
 813 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
 814 MODULE_VERSION("1.0-alpha");
 815 MODULE_LICENSE("GPL");