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