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 = ® }, 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"); 1456