drivers/media/usb/dvb-usb-v2/mxl111sf.c

   1 /*
   2  * Copyright (C) 2010-2014 Michael Krufky (mkrufky@linuxtv.org)
   3  *
   4  *   This program is free software; you can redistribute it and/or modify it
   5  *   under the terms of the GNU General Public License as published by the Free
   6  *   Software Foundation, version 2.
   7  *
   8  * see Documentation/dvb/README.dvb-usb for more information
   9  */
  10
  11 #include <linux/vmalloc.h>
  12 #include <linux/i2c.h>
  13 #include <media/tuner.h>
  14
  15 #include "mxl111sf.h"
  16 #include "mxl111sf-reg.h"
  17 #include "mxl111sf-phy.h"
  18 #include "mxl111sf-i2c.h"
  19 #include "mxl111sf-gpio.h"
  20
  21 #include "mxl111sf-demod.h"
  22 #include "mxl111sf-tuner.h"
  23
  24 #include "lgdt3305.h"
  25 #include "lg2160.h"
  26
  27 /* Max transfer size done by I2C transfer functions */
  28 #define MAX_XFER_SIZE  64
  29
  30 int dvb_usb_mxl111sf_debug;
  31 module_param_named(debug, dvb_usb_mxl111sf_debug, int, 0644);
  32 MODULE_PARM_DESC(debug, "set debugging level "
  33                  "(1=info, 2=xfer, 4=i2c, 8=reg, 16=adv (or-able)).");
  34
  35 static int dvb_usb_mxl111sf_isoc;
  36 module_param_named(isoc, dvb_usb_mxl111sf_isoc, int, 0644);
  37 MODULE_PARM_DESC(isoc, "enable usb isoc xfer (0=bulk, 1=isoc).");
  38
  39 static int dvb_usb_mxl111sf_spi;
  40 module_param_named(spi, dvb_usb_mxl111sf_spi, int, 0644);
  41 MODULE_PARM_DESC(spi, "use spi rather than tp for data xfer (0=tp, 1=spi).");
  42
  43 #define ANT_PATH_AUTO 0
  44 #define ANT_PATH_EXTERNAL 1
  45 #define ANT_PATH_INTERNAL 2
  46
  47 static int dvb_usb_mxl111sf_rfswitch =
  48 #if 0
  49                 ANT_PATH_AUTO;
  50 #else
  51                 ANT_PATH_EXTERNAL;
  52 #endif
  53
  54 module_param_named(rfswitch, dvb_usb_mxl111sf_rfswitch, int, 0644);
  55 MODULE_PARM_DESC(rfswitch, "force rf switch position (0=auto, 1=ext, 2=int).");
  56
  57 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  58
  59 int mxl111sf_ctrl_msg(struct dvb_usb_device *d,
  60                       u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
  61 {
  62         int wo = (rbuf == NULL || rlen == 0); /* write-only */
  63         int ret;
  64         u8 sndbuf[MAX_XFER_SIZE];
  65
  66         if (1 + wlen > sizeof(sndbuf)) {
  67                 pr_warn("%s: len=%d is too big!\n", __func__, wlen);
  68                 return -EOPNOTSUPP;
  69         }
  70
  71         pr_debug("%s(wlen = %d, rlen = %d)\n", __func__, wlen, rlen);
  72
  73         memset(sndbuf, 0, 1+wlen);
  74
  75         sndbuf[0] = cmd;
  76         memcpy(&sndbuf[1], wbuf, wlen);
  77
  78         ret = (wo) ? dvb_usbv2_generic_write(d, sndbuf, 1+wlen) :
  79                 dvb_usbv2_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen);
  80         mxl_fail(ret);
  81
  82         return ret;
  83 }
  84
  85 /* ------------------------------------------------------------------------ */
  86
  87 #define MXL_CMD_REG_READ        0xaa
  88 #define MXL_CMD_REG_WRITE       0x55
  89
  90 int mxl111sf_read_reg(struct mxl111sf_state *state, u8 addr, u8 *data)
  91 {
  92         u8 buf[2];
  93         int ret;
  94
  95         ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_READ, &addr, 1, buf, 2);
  96         if (mxl_fail(ret)) {
  97                 mxl_debug("error reading reg: 0x%02x", addr);
  98                 goto fail;
  99         }
 100
 101         if (buf[0] == addr)
 102                 *data = buf[1];
 103         else {
 104                 pr_err("invalid response reading reg: 0x%02x != 0x%02x, 0x%02x",
 105                     addr, buf[0], buf[1]);
 106                 ret = -EINVAL;
 107         }
 108
 109         pr_debug("R: (0x%02x, 0x%02x)\n", addr, buf[1]);
 110 fail:
 111         return ret;
 112 }
 113
 114 int mxl111sf_write_reg(struct mxl111sf_state *state, u8 addr, u8 data)
 115 {
 116         u8 buf[] = { addr, data };
 117         int ret;
 118
 119         pr_debug("W: (0x%02x, 0x%02x)\n", addr, data);
 120
 121         ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_WRITE, buf, 2, NULL, 0);
 122         if (mxl_fail(ret))
 123                 pr_err("error writing reg: 0x%02x, val: 0x%02x", addr, data);
 124         return ret;
 125 }
 126
 127 /* ------------------------------------------------------------------------ */
 128
 129 int mxl111sf_write_reg_mask(struct mxl111sf_state *state,
 130                                    u8 addr, u8 mask, u8 data)
 131 {
 132         int ret;
 133         u8 val = 0;
 134
 135         if (mask != 0xff) {
 136                 ret = mxl111sf_read_reg(state, addr, &val);
 137 #if 1
 138                 /* dont know why this usually errors out on the first try */
 139                 if (mxl_fail(ret))
 140                         pr_err("error writing addr: 0x%02x, mask: 0x%02x, "
 141                             "data: 0x%02x, retrying...", addr, mask, data);
 142
 143                 ret = mxl111sf_read_reg(state, addr, &val);
 144 #endif
 145                 if (mxl_fail(ret))
 146                         goto fail;
 147         }
 148         val &= ~mask;
 149         val |= data;
 150
 151         ret = mxl111sf_write_reg(state, addr, val);
 152         mxl_fail(ret);
 153 fail:
 154         return ret;
 155 }
 156
 157 /* ------------------------------------------------------------------------ */
 158
 159 int mxl111sf_ctrl_program_regs(struct mxl111sf_state *state,
 160                                struct mxl111sf_reg_ctrl_info *ctrl_reg_info)
 161 {
 162         int i, ret = 0;
 163
 164         for (i = 0;  ctrl_reg_info[i].addr |
 165                      ctrl_reg_info[i].mask |
 166                      ctrl_reg_info[i].data;  i++) {
 167
 168                 ret = mxl111sf_write_reg_mask(state,
 169                                               ctrl_reg_info[i].addr,
 170                                               ctrl_reg_info[i].mask,
 171                                               ctrl_reg_info[i].data);
 172                 if (mxl_fail(ret)) {
 173                         pr_err("failed on reg #%d (0x%02x)", i,
 174                             ctrl_reg_info[i].addr);
 175                         break;
 176                 }
 177         }
 178         return ret;
 179 }
 180
 181 /* ------------------------------------------------------------------------ */
 182
 183 static int mxl1x1sf_get_chip_info(struct mxl111sf_state *state)
 184 {
 185         int ret;
 186         u8 id, ver;
 187         char *mxl_chip, *mxl_rev;
 188
 189         if ((state->chip_id) && (state->chip_ver))
 190                 return 0;
 191
 192         ret = mxl111sf_read_reg(state, CHIP_ID_REG, &id);
 193         if (mxl_fail(ret))
 194                 goto fail;
 195         state->chip_id = id;
 196
 197         ret = mxl111sf_read_reg(state, TOP_CHIP_REV_ID_REG, &ver);
 198         if (mxl_fail(ret))
 199                 goto fail;
 200         state->chip_ver = ver;
 201
 202         switch (id) {
 203         case 0x61:
 204                 mxl_chip = "MxL101SF";
 205                 break;
 206         case 0x63:
 207                 mxl_chip = "MxL111SF";
 208                 break;
 209         default:
 210                 mxl_chip = "UNKNOWN MxL1X1";
 211                 break;
 212         }
 213         switch (ver) {
 214         case 0x36:
 215                 state->chip_rev = MXL111SF_V6;
 216                 mxl_rev = "v6";
 217                 break;
 218         case 0x08:
 219                 state->chip_rev = MXL111SF_V8_100;
 220                 mxl_rev = "v8_100";
 221                 break;
 222         case 0x18:
 223                 state->chip_rev = MXL111SF_V8_200;
 224                 mxl_rev = "v8_200";
 225                 break;
 226         default:
 227                 state->chip_rev = 0;
 228                 mxl_rev = "UNKNOWN REVISION";
 229                 break;
 230         }
 231         pr_info("%s detected, %s (0x%x)", mxl_chip, mxl_rev, ver);
 232 fail:
 233         return ret;
 234 }
 235
 236 #define get_chip_info(state)                                            \
 237 ({                                                                      \
 238         int ___ret;                                                     \
 239         ___ret = mxl1x1sf_get_chip_info(state);                         \
 240         if (mxl_fail(___ret)) {                                         \
 241                 mxl_debug("failed to get chip info"                     \
 242                           " on first probe attempt");                   \
 243                 ___ret = mxl1x1sf_get_chip_info(state);                 \
 244                 if (mxl_fail(___ret))                                   \
 245                         pr_err("failed to get chip info during probe"); \
 246                 else                                                    \
 247                         mxl_debug("probe needed a retry "               \
 248                                   "in order to succeed.");              \
 249         }                                                               \
 250         ___ret;                                                         \
 251 })
 252
 253 /* ------------------------------------------------------------------------ */
 254 #if 0
 255 static int mxl111sf_power_ctrl(struct dvb_usb_device *d, int onoff)
 256 {
 257         /* power control depends on which adapter is being woken:
 258          * save this for init, instead, via mxl111sf_adap_fe_init */
 259         return 0;
 260 }
 261 #endif
 262
 263 static int mxl111sf_adap_fe_init(struct dvb_frontend *fe)
 264 {
 265         struct dvb_usb_device *d = fe_to_d(fe);
 266         struct mxl111sf_state *state = fe_to_priv(fe);
 267         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
 268         int err;
 269
 270         /* exit if we didn't initialize the driver yet */
 271         if (!state->chip_id) {
 272                 mxl_debug("driver not yet initialized, exit.");
 273                 goto fail;
 274         }
 275
 276         pr_debug("%s()\n", __func__);
 277
 278         mutex_lock(&state->fe_lock);
 279
 280         state->alt_mode = adap_state->alt_mode;
 281
 282         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
 283                 pr_err("set interface failed");
 284
 285         err = mxl1x1sf_soft_reset(state);
 286         mxl_fail(err);
 287         err = mxl111sf_init_tuner_demod(state);
 288         mxl_fail(err);
 289         err = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
 290
 291         mxl_fail(err);
 292         err = mxl111sf_enable_usb_output(state);
 293         mxl_fail(err);
 294         err = mxl1x1sf_top_master_ctrl(state, 1);
 295         mxl_fail(err);
 296
 297         if ((MXL111SF_GPIO_MOD_DVBT != adap_state->gpio_mode) &&
 298             (state->chip_rev > MXL111SF_V6)) {
 299                 mxl111sf_config_pin_mux_modes(state,
 300                                               PIN_MUX_TS_SPI_IN_MODE_1);
 301                 mxl_fail(err);
 302         }
 303         err = mxl111sf_init_port_expander(state);
 304         if (!mxl_fail(err)) {
 305                 state->gpio_mode = adap_state->gpio_mode;
 306                 err = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
 307                 mxl_fail(err);
 308 #if 0
 309                 err = fe->ops.init(fe);
 310 #endif
 311                 msleep(100); /* add short delay after enabling
 312                               * the demod before touching it */
 313         }
 314
 315         return (adap_state->fe_init) ? adap_state->fe_init(fe) : 0;
 316 fail:
 317         return -ENODEV;
 318 }
 319
 320 static int mxl111sf_adap_fe_sleep(struct dvb_frontend *fe)
 321 {
 322         struct mxl111sf_state *state = fe_to_priv(fe);
 323         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
 324         int err;
 325
 326         /* exit if we didn't initialize the driver yet */
 327         if (!state->chip_id) {
 328                 mxl_debug("driver not yet initialized, exit.");
 329                 goto fail;
 330         }
 331
 332         pr_debug("%s()\n", __func__);
 333
 334         err = (adap_state->fe_sleep) ? adap_state->fe_sleep(fe) : 0;
 335
 336         mutex_unlock(&state->fe_lock);
 337
 338         return err;
 339 fail:
 340         return -ENODEV;
 341 }
 342
 343
 344 static int mxl111sf_ep6_streaming_ctrl(struct dvb_frontend *fe, int onoff)
 345 {
 346         struct mxl111sf_state *state = fe_to_priv(fe);
 347         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
 348         int ret = 0;
 349
 350         pr_debug("%s(%d)\n", __func__, onoff);
 351
 352         if (onoff) {
 353                 ret = mxl111sf_enable_usb_output(state);
 354                 mxl_fail(ret);
 355                 ret = mxl111sf_config_mpeg_in(state, 1, 1,
 356                                               adap_state->ep6_clockphase,
 357                                               0, 0);
 358                 mxl_fail(ret);
 359 #if 0
 360         } else {
 361                 ret = mxl111sf_disable_656_port(state);
 362                 mxl_fail(ret);
 363 #endif
 364         }
 365
 366         return ret;
 367 }
 368
 369 static int mxl111sf_ep5_streaming_ctrl(struct dvb_frontend *fe, int onoff)
 370 {
 371         struct mxl111sf_state *state = fe_to_priv(fe);
 372         int ret = 0;
 373
 374         pr_debug("%s(%d)\n", __func__, onoff);
 375
 376         if (onoff) {
 377                 ret = mxl111sf_enable_usb_output(state);
 378                 mxl_fail(ret);
 379
 380                 ret = mxl111sf_init_i2s_port(state, 200);
 381                 mxl_fail(ret);
 382                 ret = mxl111sf_config_i2s(state, 0, 15);
 383                 mxl_fail(ret);
 384         } else {
 385                 ret = mxl111sf_disable_i2s_port(state);
 386                 mxl_fail(ret);
 387         }
 388         if (state->chip_rev > MXL111SF_V6)
 389                 ret = mxl111sf_config_spi(state, onoff);
 390         mxl_fail(ret);
 391
 392         return ret;
 393 }
 394
 395 static int mxl111sf_ep4_streaming_ctrl(struct dvb_frontend *fe, int onoff)
 396 {
 397         struct mxl111sf_state *state = fe_to_priv(fe);
 398         int ret = 0;
 399
 400         pr_debug("%s(%d)\n", __func__, onoff);
 401
 402         if (onoff) {
 403                 ret = mxl111sf_enable_usb_output(state);
 404                 mxl_fail(ret);
 405         }
 406
 407         return ret;
 408 }
 409
 410 /* ------------------------------------------------------------------------ */
 411
 412 static struct lgdt3305_config hauppauge_lgdt3305_config = {
 413         .i2c_addr           = 0xb2 >> 1,
 414         .mpeg_mode          = LGDT3305_MPEG_SERIAL,
 415         .tpclk_edge         = LGDT3305_TPCLK_RISING_EDGE,
 416         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
 417         .deny_i2c_rptr      = 1,
 418         .spectral_inversion = 0,
 419         .qam_if_khz         = 6000,
 420         .vsb_if_khz         = 6000,
 421 };
 422
 423 static int mxl111sf_lgdt3305_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
 424 {
 425         struct dvb_usb_device *d = adap_to_d(adap);
 426         struct mxl111sf_state *state = d_to_priv(d);
 427         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
 428         int ret;
 429
 430         pr_debug("%s()\n", __func__);
 431
 432         /* save a pointer to the dvb_usb_device in device state */
 433         state->d = d;
 434         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
 435         state->alt_mode = adap_state->alt_mode;
 436
 437         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
 438                 pr_err("set interface failed");
 439
 440         state->gpio_mode = MXL111SF_GPIO_MOD_ATSC;
 441         adap_state->gpio_mode = state->gpio_mode;
 442         adap_state->device_mode = MXL_TUNER_MODE;
 443         adap_state->ep6_clockphase = 1;
 444
 445         ret = mxl1x1sf_soft_reset(state);
 446         if (mxl_fail(ret))
 447                 goto fail;
 448         ret = mxl111sf_init_tuner_demod(state);
 449         if (mxl_fail(ret))
 450                 goto fail;
 451
 452         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
 453         if (mxl_fail(ret))
 454                 goto fail;
 455
 456         ret = mxl111sf_enable_usb_output(state);
 457         if (mxl_fail(ret))
 458                 goto fail;
 459         ret = mxl1x1sf_top_master_ctrl(state, 1);
 460         if (mxl_fail(ret))
 461                 goto fail;
 462
 463         ret = mxl111sf_init_port_expander(state);
 464         if (mxl_fail(ret))
 465                 goto fail;
 466         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
 467         if (mxl_fail(ret))
 468                 goto fail;
 469
 470         adap->fe[fe_id] = dvb_attach(lgdt3305_attach,
 471                                  &hauppauge_lgdt3305_config,
 472                                  &d->i2c_adap);
 473         if (adap->fe[fe_id]) {
 474                 state->num_frontends++;
 475                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
 476                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
 477                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
 478                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
 479                 return 0;
 480         }
 481         ret = -EIO;
 482 fail:
 483         return ret;
 484 }
 485
 486 static struct lg2160_config hauppauge_lg2160_config = {
 487         .lg_chip            = LG2160,
 488         .i2c_addr           = 0x1c >> 1,
 489         .deny_i2c_rptr      = 1,
 490         .spectral_inversion = 0,
 491         .if_khz             = 6000,
 492 };
 493
 494 static int mxl111sf_lg2160_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
 495 {
 496         struct dvb_usb_device *d = adap_to_d(adap);
 497         struct mxl111sf_state *state = d_to_priv(d);
 498         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
 499         int ret;
 500
 501         pr_debug("%s()\n", __func__);
 502
 503         /* save a pointer to the dvb_usb_device in device state */
 504         state->d = d;
 505         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
 506         state->alt_mode = adap_state->alt_mode;
 507
 508         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
 509                 pr_err("set interface failed");
 510
 511         state->gpio_mode = MXL111SF_GPIO_MOD_MH;
 512         adap_state->gpio_mode = state->gpio_mode;
 513         adap_state->device_mode = MXL_TUNER_MODE;
 514         adap_state->ep6_clockphase = 1;
 515
 516         ret = mxl1x1sf_soft_reset(state);
 517         if (mxl_fail(ret))
 518                 goto fail;
 519         ret = mxl111sf_init_tuner_demod(state);
 520         if (mxl_fail(ret))
 521                 goto fail;
 522
 523         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
 524         if (mxl_fail(ret))
 525                 goto fail;
 526
 527         ret = mxl111sf_enable_usb_output(state);
 528         if (mxl_fail(ret))
 529                 goto fail;
 530         ret = mxl1x1sf_top_master_ctrl(state, 1);
 531         if (mxl_fail(ret))
 532                 goto fail;
 533
 534         ret = mxl111sf_init_port_expander(state);
 535         if (mxl_fail(ret))
 536                 goto fail;
 537         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
 538         if (mxl_fail(ret))
 539                 goto fail;
 540
 541         ret = get_chip_info(state);
 542         if (mxl_fail(ret))
 543                 goto fail;
 544
 545         adap->fe[fe_id] = dvb_attach(lg2160_attach,
 546                               &hauppauge_lg2160_config,
 547                               &d->i2c_adap);
 548         if (adap->fe[fe_id]) {
 549                 state->num_frontends++;
 550                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
 551                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
 552                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
 553                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
 554                 return 0;
 555         }
 556         ret = -EIO;
 557 fail:
 558         return ret;
 559 }
 560
 561 static struct lg2160_config hauppauge_lg2161_1019_config = {
 562         .lg_chip            = LG2161_1019,
 563         .i2c_addr           = 0x1c >> 1,
 564         .deny_i2c_rptr      = 1,
 565         .spectral_inversion = 0,
 566         .if_khz             = 6000,
 567         .output_if          = 2, /* LG2161_OIF_SPI_MAS */
 568 };
 569
 570 static struct lg2160_config hauppauge_lg2161_1040_config = {
 571         .lg_chip            = LG2161_1040,
 572         .i2c_addr           = 0x1c >> 1,
 573         .deny_i2c_rptr      = 1,
 574         .spectral_inversion = 0,
 575         .if_khz             = 6000,
 576         .output_if          = 4, /* LG2161_OIF_SPI_MAS */
 577 };
 578
 579 static int mxl111sf_lg2161_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
 580 {
 581         struct dvb_usb_device *d = adap_to_d(adap);
 582         struct mxl111sf_state *state = d_to_priv(d);
 583         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
 584         int ret;
 585
 586         pr_debug("%s()\n", __func__);
 587
 588         /* save a pointer to the dvb_usb_device in device state */
 589         state->d = d;
 590         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
 591         state->alt_mode = adap_state->alt_mode;
 592
 593         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
 594                 pr_err("set interface failed");
 595
 596         state->gpio_mode = MXL111SF_GPIO_MOD_MH;
 597         adap_state->gpio_mode = state->gpio_mode;
 598         adap_state->device_mode = MXL_TUNER_MODE;
 599         adap_state->ep6_clockphase = 1;
 600
 601         ret = mxl1x1sf_soft_reset(state);
 602         if (mxl_fail(ret))
 603                 goto fail;
 604         ret = mxl111sf_init_tuner_demod(state);
 605         if (mxl_fail(ret))
 606                 goto fail;
 607
 608         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
 609         if (mxl_fail(ret))
 610                 goto fail;
 611
 612         ret = mxl111sf_enable_usb_output(state);
 613         if (mxl_fail(ret))
 614                 goto fail;
 615         ret = mxl1x1sf_top_master_ctrl(state, 1);
 616         if (mxl_fail(ret))
 617                 goto fail;
 618
 619         ret = mxl111sf_init_port_expander(state);
 620         if (mxl_fail(ret))
 621                 goto fail;
 622         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
 623         if (mxl_fail(ret))
 624                 goto fail;
 625
 626         ret = get_chip_info(state);
 627         if (mxl_fail(ret))
 628                 goto fail;
 629
 630         adap->fe[fe_id] = dvb_attach(lg2160_attach,
 631                               (MXL111SF_V8_200 == state->chip_rev) ?
 632                               &hauppauge_lg2161_1040_config :
 633                               &hauppauge_lg2161_1019_config,
 634                               &d->i2c_adap);
 635         if (adap->fe[fe_id]) {
 636                 state->num_frontends++;
 637                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
 638                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
 639                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
 640                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
 641                 return 0;
 642         }
 643         ret = -EIO;
 644 fail:
 645         return ret;
 646 }
 647
 648 static struct lg2160_config hauppauge_lg2161_1019_ep6_config = {
 649         .lg_chip            = LG2161_1019,
 650         .i2c_addr           = 0x1c >> 1,
 651         .deny_i2c_rptr      = 1,
 652         .spectral_inversion = 0,
 653         .if_khz             = 6000,
 654         .output_if          = 1, /* LG2161_OIF_SERIAL_TS */
 655 };
 656
 657 static struct lg2160_config hauppauge_lg2161_1040_ep6_config = {
 658         .lg_chip            = LG2161_1040,
 659         .i2c_addr           = 0x1c >> 1,
 660         .deny_i2c_rptr      = 1,
 661         .spectral_inversion = 0,
 662         .if_khz             = 6000,
 663         .output_if          = 7, /* LG2161_OIF_SERIAL_TS */
 664 };
 665
 666 static int mxl111sf_lg2161_ep6_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
 667 {
 668         struct dvb_usb_device *d = adap_to_d(adap);
 669         struct mxl111sf_state *state = d_to_priv(d);
 670         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
 671         int ret;
 672
 673         pr_debug("%s()\n", __func__);
 674
 675         /* save a pointer to the dvb_usb_device in device state */
 676         state->d = d;
 677         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
 678         state->alt_mode = adap_state->alt_mode;
 679
 680         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
 681                 pr_err("set interface failed");
 682
 683         state->gpio_mode = MXL111SF_GPIO_MOD_MH;
 684         adap_state->gpio_mode = state->gpio_mode;
 685         adap_state->device_mode = MXL_TUNER_MODE;
 686         adap_state->ep6_clockphase = 0;
 687
 688         ret = mxl1x1sf_soft_reset(state);
 689         if (mxl_fail(ret))
 690                 goto fail;
 691         ret = mxl111sf_init_tuner_demod(state);
 692         if (mxl_fail(ret))
 693                 goto fail;
 694
 695         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
 696         if (mxl_fail(ret))
 697                 goto fail;
 698
 699         ret = mxl111sf_enable_usb_output(state);
 700         if (mxl_fail(ret))
 701                 goto fail;
 702         ret = mxl1x1sf_top_master_ctrl(state, 1);
 703         if (mxl_fail(ret))
 704                 goto fail;
 705
 706         ret = mxl111sf_init_port_expander(state);
 707         if (mxl_fail(ret))
 708                 goto fail;
 709         ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
 710         if (mxl_fail(ret))
 711                 goto fail;
 712
 713         ret = get_chip_info(state);
 714         if (mxl_fail(ret))
 715                 goto fail;
 716
 717         adap->fe[fe_id] = dvb_attach(lg2160_attach,
 718                               (MXL111SF_V8_200 == state->chip_rev) ?
 719                               &hauppauge_lg2161_1040_ep6_config :
 720                               &hauppauge_lg2161_1019_ep6_config,
 721                               &d->i2c_adap);
 722         if (adap->fe[fe_id]) {
 723                 state->num_frontends++;
 724                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
 725                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
 726                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
 727                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
 728                 return 0;
 729         }
 730         ret = -EIO;
 731 fail:
 732         return ret;
 733 }
 734
 735 static const struct mxl111sf_demod_config mxl_demod_config = {
 736         .read_reg        = mxl111sf_read_reg,
 737         .write_reg       = mxl111sf_write_reg,
 738         .program_regs    = mxl111sf_ctrl_program_regs,
 739 };
 740
 741 static int mxl111sf_attach_demod(struct dvb_usb_adapter *adap, u8 fe_id)
 742 {
 743         struct dvb_usb_device *d = adap_to_d(adap);
 744         struct mxl111sf_state *state = d_to_priv(d);
 745         struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
 746         int ret;
 747
 748         pr_debug("%s()\n", __func__);
 749
 750         /* save a pointer to the dvb_usb_device in device state */
 751         state->d = d;
 752         adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 1 : 2;
 753         state->alt_mode = adap_state->alt_mode;
 754
 755         if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
 756                 pr_err("set interface failed");
 757
 758         state->gpio_mode = MXL111SF_GPIO_MOD_DVBT;
 759         adap_state->gpio_mode = state->gpio_mode;
 760         adap_state->device_mode = MXL_SOC_MODE;
 761         adap_state->ep6_clockphase = 1;
 762
 763         ret = mxl1x1sf_soft_reset(state);
 764         if (mxl_fail(ret))
 765                 goto fail;
 766         ret = mxl111sf_init_tuner_demod(state);
 767         if (mxl_fail(ret))
 768                 goto fail;
 769
 770         ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
 771         if (mxl_fail(ret))
 772                 goto fail;
 773
 774         ret = mxl111sf_enable_usb_output(state);
 775         if (mxl_fail(ret))
 776                 goto fail;
 777         ret = mxl1x1sf_top_master_ctrl(state, 1);
 778         if (mxl_fail(ret))
 779                 goto fail;
 780
 781         /* dont care if this fails */
 782         mxl111sf_init_port_expander(state);
 783
 784         adap->fe[fe_id] = dvb_attach(mxl111sf_demod_attach, state,
 785                               &mxl_demod_config);
 786         if (adap->fe[fe_id]) {
 787                 state->num_frontends++;
 788                 adap_state->fe_init = adap->fe[fe_id]->ops.init;
 789                 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
 790                 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
 791                 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
 792                 return 0;
 793         }
 794         ret = -EIO;
 795 fail:
 796         return ret;
 797 }
 798
 799 static inline int mxl111sf_set_ant_path(struct mxl111sf_state *state,
 800                                         int antpath)
 801 {
 802         return mxl111sf_idac_config(state, 1, 1,
 803                                     (antpath == ANT_PATH_INTERNAL) ?
 804                                     0x3f : 0x00, 0);
 805 }
 806
 807 #define DbgAntHunt(x, pwr0, pwr1, pwr2, pwr3) \
 808         pr_err("%s(%d) FINAL input set to %s rxPwr:%d|%d|%d|%d\n", \
 809             __func__, __LINE__, \
 810             (ANT_PATH_EXTERNAL == x) ? "EXTERNAL" : "INTERNAL", \
 811             pwr0, pwr1, pwr2, pwr3)
 812
 813 #define ANT_HUNT_SLEEP 90
 814 #define ANT_EXT_TWEAK 0
 815
 816 static int mxl111sf_ant_hunt(struct dvb_frontend *fe)
 817 {
 818         struct mxl111sf_state *state = fe_to_priv(fe);
 819         int antctrl = dvb_usb_mxl111sf_rfswitch;
 820
 821         u16 rxPwrA, rxPwr0, rxPwr1, rxPwr2;
 822
 823         /* FIXME: must force EXTERNAL for QAM - done elsewhere */
 824         mxl111sf_set_ant_path(state, antctrl == ANT_PATH_AUTO ?
 825                               ANT_PATH_EXTERNAL : antctrl);
 826
 827         if (antctrl == ANT_PATH_AUTO) {
 828 #if 0
 829                 msleep(ANT_HUNT_SLEEP);
 830 #endif
 831                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwrA);
 832
 833                 mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
 834                 msleep(ANT_HUNT_SLEEP);
 835                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr0);
 836
 837                 mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
 838                 msleep(ANT_HUNT_SLEEP);
 839                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr1);
 840
 841                 mxl111sf_set_ant_path(state, ANT_PATH_INTERNAL);
 842                 msleep(ANT_HUNT_SLEEP);
 843                 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr2);
 844
 845                 if (rxPwr1+ANT_EXT_TWEAK >= rxPwr2) {
 846                         /* return with EXTERNAL enabled */
 847                         mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
 848                         DbgAntHunt(ANT_PATH_EXTERNAL, rxPwrA,
 849                                    rxPwr0, rxPwr1, rxPwr2);
 850                 } else {
 851                         /* return with INTERNAL enabled */
 852                         DbgAntHunt(ANT_PATH_INTERNAL, rxPwrA,
 853                                    rxPwr0, rxPwr1, rxPwr2);
 854                 }
 855         }
 856         return 0;
 857 }
 858
 859 static const struct mxl111sf_tuner_config mxl_tuner_config = {
 860         .if_freq         = MXL_IF_6_0, /* applies to external IF output, only */
 861         .invert_spectrum = 0,
 862         .read_reg        = mxl111sf_read_reg,
 863         .write_reg       = mxl111sf_write_reg,
 864         .program_regs    = mxl111sf_ctrl_program_regs,
 865         .top_master_ctrl = mxl1x1sf_top_master_ctrl,
 866         .ant_hunt        = mxl111sf_ant_hunt,
 867 };
 868
 869 static int mxl111sf_attach_tuner(struct dvb_usb_adapter *adap)
 870 {
 871         struct mxl111sf_state *state = adap_to_priv(adap);
 872 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 873         struct media_device *mdev = dvb_get_media_controller(&adap->dvb_adap);
 874         int ret;
 875 #endif
 876         int i;
 877
 878         pr_debug("%s()\n", __func__);
 879
 880         for (i = 0; i < state->num_frontends; i++) {
 881                 if (dvb_attach(mxl111sf_tuner_attach, adap->fe[i], state,
 882                                 &mxl_tuner_config) == NULL)
 883                         return -EIO;
 884                 adap->fe[i]->ops.read_signal_strength = adap->fe[i]->ops.tuner_ops.get_rf_strength;
 885         }
 886
 887 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 888         state->tuner.function = MEDIA_ENT_F_TUNER;
 889         state->tuner.name = "mxl111sf tuner";
 890         state->tuner_pads[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
 891         state->tuner_pads[TUNER_PAD_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
 892
 893         ret = media_entity_pads_init(&state->tuner,
 894                                      TUNER_NUM_PADS, state->tuner_pads);
 895         if (ret)
 896                 return ret;
 897
 898         ret = media_device_register_entity(mdev, &state->tuner);
 899         if (ret)
 900                 return ret;
 901 #endif
 902         return 0;
 903 }
 904
 905 static u32 mxl111sf_i2c_func(struct i2c_adapter *adapter)
 906 {
 907         return I2C_FUNC_I2C;
 908 }
 909
 910 static struct i2c_algorithm mxl111sf_i2c_algo = {
 911         .master_xfer   = mxl111sf_i2c_xfer,
 912         .functionality = mxl111sf_i2c_func,
 913 #ifdef NEED_ALGO_CONTROL
 914         .algo_control = dummy_algo_control,
 915 #endif
 916 };
 917
 918 static int mxl111sf_init(struct dvb_usb_device *d)
 919 {
 920         struct mxl111sf_state *state = d_to_priv(d);
 921         int ret;
 922         static u8 eeprom[256];
 923         struct i2c_client c;
 924
 925         ret = get_chip_info(state);
 926         if (mxl_fail(ret))
 927                 pr_err("failed to get chip info during probe");
 928
 929         mutex_init(&state->fe_lock);
 930
 931         if (state->chip_rev > MXL111SF_V6)
 932                 mxl111sf_config_pin_mux_modes(state, PIN_MUX_TS_SPI_IN_MODE_1);
 933
 934         c.adapter = &d->i2c_adap;
 935         c.addr = 0xa0 >> 1;
 936
 937         ret = tveeprom_read(&c, eeprom, sizeof(eeprom));
 938         if (mxl_fail(ret))
 939                 return 0;
 940         tveeprom_hauppauge_analog(&c, &state->tv, (0x84 == eeprom[0xa0]) ?
 941                         eeprom + 0xa0 : eeprom + 0x80);
 942 #if 0
 943         switch (state->tv.model) {
 944         case 117001:
 945         case 126001:
 946         case 138001:
 947                 break;
 948         default:
 949                 printk(KERN_WARNING "%s: warning: "
 950                        "unknown hauppauge model #%d\n",
 951                        __func__, state->tv.model);
 952         }
 953 #endif
 954         return 0;
 955 }
 956
 957 static int mxl111sf_frontend_attach_dvbt(struct dvb_usb_adapter *adap)
 958 {
 959         return mxl111sf_attach_demod(adap, 0);
 960 }
 961
 962 static int mxl111sf_frontend_attach_atsc(struct dvb_usb_adapter *adap)
 963 {
 964         return mxl111sf_lgdt3305_frontend_attach(adap, 0);
 965 }
 966
 967 static int mxl111sf_frontend_attach_mh(struct dvb_usb_adapter *adap)
 968 {
 969         return mxl111sf_lg2160_frontend_attach(adap, 0);
 970 }
 971
 972 static int mxl111sf_frontend_attach_atsc_mh(struct dvb_usb_adapter *adap)
 973 {
 974         int ret;
 975         pr_debug("%s\n", __func__);
 976
 977         ret = mxl111sf_lgdt3305_frontend_attach(adap, 0);
 978         if (ret < 0)
 979                 return ret;
 980
 981         ret = mxl111sf_attach_demod(adap, 1);
 982         if (ret < 0)
 983                 return ret;
 984
 985         ret = mxl111sf_lg2160_frontend_attach(adap, 2);
 986         if (ret < 0)
 987                 return ret;
 988
 989         return ret;
 990 }
 991
 992 static int mxl111sf_frontend_attach_mercury(struct dvb_usb_adapter *adap)
 993 {
 994         int ret;
 995         pr_debug("%s\n", __func__);
 996
 997         ret = mxl111sf_lgdt3305_frontend_attach(adap, 0);
 998         if (ret < 0)
 999                 return ret;
1000
1001         ret = mxl111sf_attach_demod(adap, 1);
1002         if (ret < 0)
1003                 return ret;
1004
1005         ret = mxl111sf_lg2161_ep6_frontend_attach(adap, 2);
1006         if (ret < 0)
1007                 return ret;
1008
1009         return ret;
1010 }
1011
1012 static int mxl111sf_frontend_attach_mercury_mh(struct dvb_usb_adapter *adap)
1013 {
1014         int ret;
1015         pr_debug("%s\n", __func__);
1016
1017         ret = mxl111sf_attach_demod(adap, 0);
1018         if (ret < 0)
1019                 return ret;
1020
1021         if (dvb_usb_mxl111sf_spi)
1022                 ret = mxl111sf_lg2161_frontend_attach(adap, 1);
1023         else
1024                 ret = mxl111sf_lg2161_ep6_frontend_attach(adap, 1);
1025
1026         return ret;
1027 }
1028
1029 static void mxl111sf_stream_config_bulk(struct usb_data_stream_properties *stream, u8 endpoint)
1030 {
1031         pr_debug("%s: endpoint=%d size=8192\n", __func__, endpoint);
1032         stream->type = USB_BULK;
1033         stream->count = 5;
1034         stream->endpoint = endpoint;
1035         stream->u.bulk.buffersize = 8192;
1036 }
1037
1038 static void mxl111sf_stream_config_isoc(struct usb_data_stream_properties *stream,
1039                 u8 endpoint, int framesperurb, int framesize)
1040 {
1041         pr_debug("%s: endpoint=%d size=%d\n", __func__, endpoint,
1042                         framesperurb * framesize);
1043         stream->type = USB_ISOC;
1044         stream->count = 5;
1045         stream->endpoint = endpoint;
1046         stream->u.isoc.framesperurb = framesperurb;
1047         stream->u.isoc.framesize = framesize;
1048         stream->u.isoc.interval = 1;
1049 }
1050
1051 /* DVB USB Driver stuff */
1052
1053 /* dvbt       mxl111sf
1054  * bulk       EP4/BULK/5/8192
1055  * isoc       EP4/ISOC/5/96/564
1056  */
1057 static int mxl111sf_get_stream_config_dvbt(struct dvb_frontend *fe,
1058                 u8 *ts_type, struct usb_data_stream_properties *stream)
1059 {
1060         pr_debug("%s: fe=%d\n", __func__, fe->id);
1061
1062         *ts_type = DVB_USB_FE_TS_TYPE_188;
1063         if (dvb_usb_mxl111sf_isoc)
1064                 mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1065         else
1066                 mxl111sf_stream_config_bulk(stream, 4);
1067         return 0;
1068 }
1069
1070 static struct dvb_usb_device_properties mxl111sf_props_dvbt = {
1071         .driver_name = KBUILD_MODNAME,
1072         .owner = THIS_MODULE,
1073         .adapter_nr = adapter_nr,
1074         .size_of_priv = sizeof(struct mxl111sf_state),
1075
1076         .generic_bulk_ctrl_endpoint = 0x02,
1077         .generic_bulk_ctrl_endpoint_response = 0x81,
1078
1079         .i2c_algo          = &mxl111sf_i2c_algo,
1080         .frontend_attach   = mxl111sf_frontend_attach_dvbt,
1081         .tuner_attach      = mxl111sf_attach_tuner,
1082         .init              = mxl111sf_init,
1083         .streaming_ctrl    = mxl111sf_ep4_streaming_ctrl,
1084         .get_stream_config = mxl111sf_get_stream_config_dvbt,
1085
1086         .num_adapters = 1,
1087         .adapter = {
1088                 {
1089                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1090                 }
1091         }
1092 };
1093
1094 /* atsc       lgdt3305
1095  * bulk       EP6/BULK/5/8192
1096  * isoc       EP6/ISOC/5/24/3072
1097  */
1098 static int mxl111sf_get_stream_config_atsc(struct dvb_frontend *fe,
1099                 u8 *ts_type, struct usb_data_stream_properties *stream)
1100 {
1101         pr_debug("%s: fe=%d\n", __func__, fe->id);
1102
1103         *ts_type = DVB_USB_FE_TS_TYPE_188;
1104         if (dvb_usb_mxl111sf_isoc)
1105                 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1106         else
1107                 mxl111sf_stream_config_bulk(stream, 6);
1108         return 0;
1109 }
1110
1111 static struct dvb_usb_device_properties mxl111sf_props_atsc = {
1112         .driver_name = KBUILD_MODNAME,
1113         .owner = THIS_MODULE,
1114         .adapter_nr = adapter_nr,
1115         .size_of_priv = sizeof(struct mxl111sf_state),
1116
1117         .generic_bulk_ctrl_endpoint = 0x02,
1118         .generic_bulk_ctrl_endpoint_response = 0x81,
1119
1120         .i2c_algo          = &mxl111sf_i2c_algo,
1121         .frontend_attach   = mxl111sf_frontend_attach_atsc,
1122         .tuner_attach      = mxl111sf_attach_tuner,
1123         .init              = mxl111sf_init,
1124         .streaming_ctrl    = mxl111sf_ep6_streaming_ctrl,
1125         .get_stream_config = mxl111sf_get_stream_config_atsc,
1126
1127         .num_adapters = 1,
1128         .adapter = {
1129                 {
1130                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1131                 }
1132         }
1133 };
1134
1135 /* mh         lg2160
1136  * bulk       EP5/BULK/5/8192/RAW
1137  * isoc       EP5/ISOC/5/96/200/RAW
1138  */
1139 static int mxl111sf_get_stream_config_mh(struct dvb_frontend *fe,
1140                 u8 *ts_type, struct usb_data_stream_properties *stream)
1141 {
1142         pr_debug("%s: fe=%d\n", __func__, fe->id);
1143
1144         *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1145         if (dvb_usb_mxl111sf_isoc)
1146                 mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1147         else
1148                 mxl111sf_stream_config_bulk(stream, 5);
1149         return 0;
1150 }
1151
1152 static struct dvb_usb_device_properties mxl111sf_props_mh = {
1153         .driver_name = KBUILD_MODNAME,
1154         .owner = THIS_MODULE,
1155         .adapter_nr = adapter_nr,
1156         .size_of_priv = sizeof(struct mxl111sf_state),
1157
1158         .generic_bulk_ctrl_endpoint = 0x02,
1159         .generic_bulk_ctrl_endpoint_response = 0x81,
1160
1161         .i2c_algo          = &mxl111sf_i2c_algo,
1162         .frontend_attach   = mxl111sf_frontend_attach_mh,
1163         .tuner_attach      = mxl111sf_attach_tuner,
1164         .init              = mxl111sf_init,
1165         .streaming_ctrl    = mxl111sf_ep5_streaming_ctrl,
1166         .get_stream_config = mxl111sf_get_stream_config_mh,
1167
1168         .num_adapters = 1,
1169         .adapter = {
1170                 {
1171                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1172                 }
1173         }
1174 };
1175
1176 /* atsc mh    lgdt3305           mxl111sf          lg2160
1177  * bulk       EP6/BULK/5/8192    EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1178  * isoc       EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1179  */
1180 static int mxl111sf_get_stream_config_atsc_mh(struct dvb_frontend *fe,
1181                 u8 *ts_type, struct usb_data_stream_properties *stream)
1182 {
1183         pr_debug("%s: fe=%d\n", __func__, fe->id);
1184
1185         if (fe->id == 0) {
1186                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1187                 if (dvb_usb_mxl111sf_isoc)
1188                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1189                 else
1190                         mxl111sf_stream_config_bulk(stream, 6);
1191         } else if (fe->id == 1) {
1192                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1193                 if (dvb_usb_mxl111sf_isoc)
1194                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1195                 else
1196                         mxl111sf_stream_config_bulk(stream, 4);
1197         } else if (fe->id == 2) {
1198                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1199                 if (dvb_usb_mxl111sf_isoc)
1200                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1201                 else
1202                         mxl111sf_stream_config_bulk(stream, 5);
1203         }
1204         return 0;
1205 }
1206
1207 static int mxl111sf_streaming_ctrl_atsc_mh(struct dvb_frontend *fe, int onoff)
1208 {
1209         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1210
1211         if (fe->id == 0)
1212                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1213         else if (fe->id == 1)
1214                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1215         else if (fe->id == 2)
1216                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1217         return 0;
1218 }
1219
1220 static struct dvb_usb_device_properties mxl111sf_props_atsc_mh = {
1221         .driver_name = KBUILD_MODNAME,
1222         .owner = THIS_MODULE,
1223         .adapter_nr = adapter_nr,
1224         .size_of_priv = sizeof(struct mxl111sf_state),
1225
1226         .generic_bulk_ctrl_endpoint = 0x02,
1227         .generic_bulk_ctrl_endpoint_response = 0x81,
1228
1229         .i2c_algo          = &mxl111sf_i2c_algo,
1230         .frontend_attach   = mxl111sf_frontend_attach_atsc_mh,
1231         .tuner_attach      = mxl111sf_attach_tuner,
1232         .init              = mxl111sf_init,
1233         .streaming_ctrl    = mxl111sf_streaming_ctrl_atsc_mh,
1234         .get_stream_config = mxl111sf_get_stream_config_atsc_mh,
1235
1236         .num_adapters = 1,
1237         .adapter = {
1238                 {
1239                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1240                 }
1241         }
1242 };
1243
1244 /* mercury    lgdt3305           mxl111sf          lg2161
1245  * tp bulk    EP6/BULK/5/8192    EP4/BULK/5/8192   EP6/BULK/5/8192/RAW
1246  * tp isoc    EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1247  * spi bulk   EP6/BULK/5/8192    EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1248  * spi isoc   EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1249  */
1250 static int mxl111sf_get_stream_config_mercury(struct dvb_frontend *fe,
1251                 u8 *ts_type, struct usb_data_stream_properties *stream)
1252 {
1253         pr_debug("%s: fe=%d\n", __func__, fe->id);
1254
1255         if (fe->id == 0) {
1256                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1257                 if (dvb_usb_mxl111sf_isoc)
1258                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1259                 else
1260                         mxl111sf_stream_config_bulk(stream, 6);
1261         } else if (fe->id == 1) {
1262                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1263                 if (dvb_usb_mxl111sf_isoc)
1264                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1265                 else
1266                         mxl111sf_stream_config_bulk(stream, 4);
1267         } else if (fe->id == 2 && dvb_usb_mxl111sf_spi) {
1268                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1269                 if (dvb_usb_mxl111sf_isoc)
1270                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1271                 else
1272                         mxl111sf_stream_config_bulk(stream, 5);
1273         } else if (fe->id == 2 && !dvb_usb_mxl111sf_spi) {
1274                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1275                 if (dvb_usb_mxl111sf_isoc)
1276                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1277                 else
1278                         mxl111sf_stream_config_bulk(stream, 6);
1279         }
1280         return 0;
1281 }
1282
1283 static int mxl111sf_streaming_ctrl_mercury(struct dvb_frontend *fe, int onoff)
1284 {
1285         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1286
1287         if (fe->id == 0)
1288                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1289         else if (fe->id == 1)
1290                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1291         else if (fe->id == 2 && dvb_usb_mxl111sf_spi)
1292                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1293         else if (fe->id == 2 && !dvb_usb_mxl111sf_spi)
1294                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1295         return 0;
1296 }
1297
1298 static struct dvb_usb_device_properties mxl111sf_props_mercury = {
1299         .driver_name = KBUILD_MODNAME,
1300         .owner = THIS_MODULE,
1301         .adapter_nr = adapter_nr,
1302         .size_of_priv = sizeof(struct mxl111sf_state),
1303
1304         .generic_bulk_ctrl_endpoint = 0x02,
1305         .generic_bulk_ctrl_endpoint_response = 0x81,
1306
1307         .i2c_algo          = &mxl111sf_i2c_algo,
1308         .frontend_attach   = mxl111sf_frontend_attach_mercury,
1309         .tuner_attach      = mxl111sf_attach_tuner,
1310         .init              = mxl111sf_init,
1311         .streaming_ctrl    = mxl111sf_streaming_ctrl_mercury,
1312         .get_stream_config = mxl111sf_get_stream_config_mercury,
1313
1314         .num_adapters = 1,
1315         .adapter = {
1316                 {
1317                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1318                 }
1319         }
1320 };
1321
1322 /* mercury mh mxl111sf          lg2161
1323  * tp bulk    EP4/BULK/5/8192   EP6/BULK/5/8192/RAW
1324  * tp isoc    EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1325  * spi bulk   EP4/BULK/5/8192   EP5/BULK/5/8192/RAW
1326  * spi isoc   EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1327  */
1328 static int mxl111sf_get_stream_config_mercury_mh(struct dvb_frontend *fe,
1329                 u8 *ts_type, struct usb_data_stream_properties *stream)
1330 {
1331         pr_debug("%s: fe=%d\n", __func__, fe->id);
1332
1333         if (fe->id == 0) {
1334                 *ts_type = DVB_USB_FE_TS_TYPE_188;
1335                 if (dvb_usb_mxl111sf_isoc)
1336                         mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1337                 else
1338                         mxl111sf_stream_config_bulk(stream, 4);
1339         } else if (fe->id == 1 && dvb_usb_mxl111sf_spi) {
1340                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1341                 if (dvb_usb_mxl111sf_isoc)
1342                         mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1343                 else
1344                         mxl111sf_stream_config_bulk(stream, 5);
1345         } else if (fe->id == 1 && !dvb_usb_mxl111sf_spi) {
1346                 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1347                 if (dvb_usb_mxl111sf_isoc)
1348                         mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1349                 else
1350                         mxl111sf_stream_config_bulk(stream, 6);
1351         }
1352         return 0;
1353 }
1354
1355 static int mxl111sf_streaming_ctrl_mercury_mh(struct dvb_frontend *fe, int onoff)
1356 {
1357         pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1358
1359         if (fe->id == 0)
1360                 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1361         else if (fe->id == 1  && dvb_usb_mxl111sf_spi)
1362                 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1363         else if (fe->id == 1 && !dvb_usb_mxl111sf_spi)
1364                 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1365         return 0;
1366 }
1367
1368 static struct dvb_usb_device_properties mxl111sf_props_mercury_mh = {
1369         .driver_name = KBUILD_MODNAME,
1370         .owner = THIS_MODULE,
1371         .adapter_nr = adapter_nr,
1372         .size_of_priv = sizeof(struct mxl111sf_state),
1373
1374         .generic_bulk_ctrl_endpoint = 0x02,
1375         .generic_bulk_ctrl_endpoint_response = 0x81,
1376
1377         .i2c_algo          = &mxl111sf_i2c_algo,
1378         .frontend_attach   = mxl111sf_frontend_attach_mercury_mh,
1379         .tuner_attach      = mxl111sf_attach_tuner,
1380         .init              = mxl111sf_init,
1381         .streaming_ctrl    = mxl111sf_streaming_ctrl_mercury_mh,
1382         .get_stream_config = mxl111sf_get_stream_config_mercury_mh,
1383
1384         .num_adapters = 1,
1385         .adapter = {
1386                 {
1387                         .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1388                 }
1389         }
1390 };
1391
1392 static const struct usb_device_id mxl111sf_id_table[] = {
1393         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc600, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1394         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc601, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1395         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc602, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1396         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc603, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1397         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc604, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1398         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc609, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1399         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60a, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1400         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1401         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60c, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1402         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc653, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1403         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc65b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1404         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb700, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1405         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb701, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1406         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb702, &mxl111sf_props_mh, "HCW 117xxx", NULL) },
1407         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb703, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1408         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb704, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1409         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb753, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1410         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb763, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1411         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb764, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1412         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd853, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1413         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd854, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1414         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd863, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1415         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd864, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1416         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1417         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1418         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1419         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1420         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8ff, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1421         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc612, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1422         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc613, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1423         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61a, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1424         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61b, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1425         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb757, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1426         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb767, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1427         { }
1428 };
1429 MODULE_DEVICE_TABLE(usb, mxl111sf_id_table);
1430
1431 static struct usb_driver mxl111sf_usb_driver = {
1432         .name = KBUILD_MODNAME,
1433         .id_table = mxl111sf_id_table,
1434         .probe = dvb_usbv2_probe,
1435         .disconnect = dvb_usbv2_disconnect,
1436         .suspend = dvb_usbv2_suspend,
1437         .resume = dvb_usbv2_resume,
1438         .no_dynamic_id = 1,
1439         .soft_unbind = 1,
1440 };
1441
1442 module_usb_driver(mxl111sf_usb_driver);
1443
1444 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1445 MODULE_DESCRIPTION("Driver for MaxLinear MxL111SF");
1446 MODULE_VERSION("1.0");
1447 MODULE_LICENSE("GPL");