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