2 * Copyright (C) 2010-2014 Michael Krufky (mkrufky@linuxtv.org)
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.
8 * see Documentation/dvb/README.dvb-usb for more information
11 #include <linux/vmalloc.h>
12 #include <linux/i2c.h>
15 #include "mxl111sf-reg.h"
16 #include "mxl111sf-phy.h"
17 #include "mxl111sf-i2c.h"
18 #include "mxl111sf-gpio.h"
20 #include "mxl111sf-demod.h"
21 #include "mxl111sf-tuner.h"
26 /* Max transfer size done by I2C transfer functions */
27 #define MAX_XFER_SIZE 64
29 int dvb_usb_mxl111sf_debug;
30 module_param_named(debug, dvb_usb_mxl111sf_debug, int, 0644);
31 MODULE_PARM_DESC(debug, "set debugging level "
32 "(1=info, 2=xfer, 4=i2c, 8=reg, 16=adv (or-able)).");
34 static int dvb_usb_mxl111sf_isoc;
35 module_param_named(isoc, dvb_usb_mxl111sf_isoc, int, 0644);
36 MODULE_PARM_DESC(isoc, "enable usb isoc xfer (0=bulk, 1=isoc).");
38 static int dvb_usb_mxl111sf_spi;
39 module_param_named(spi, dvb_usb_mxl111sf_spi, int, 0644);
40 MODULE_PARM_DESC(spi, "use spi rather than tp for data xfer (0=tp, 1=spi).");
42 #define ANT_PATH_AUTO 0
43 #define ANT_PATH_EXTERNAL 1
44 #define ANT_PATH_INTERNAL 2
46 static int dvb_usb_mxl111sf_rfswitch =
53 module_param_named(rfswitch, dvb_usb_mxl111sf_rfswitch, int, 0644);
54 MODULE_PARM_DESC(rfswitch, "force rf switch position (0=auto, 1=ext, 2=int).");
56 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
58 int mxl111sf_ctrl_msg(struct dvb_usb_device *d,
59 u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
61 int wo = (rbuf == NULL || rlen == 0); /* write-only */
63 u8 sndbuf[MAX_XFER_SIZE];
65 if (1 + wlen > sizeof(sndbuf)) {
66 pr_warn("%s: len=%d is too big!\n", __func__, wlen);
70 pr_debug("%s(wlen = %d, rlen = %d)\n", __func__, wlen, rlen);
72 memset(sndbuf, 0, 1+wlen);
75 memcpy(&sndbuf[1], wbuf, wlen);
77 ret = (wo) ? dvb_usbv2_generic_write(d, sndbuf, 1+wlen) :
78 dvb_usbv2_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen);
84 /* ------------------------------------------------------------------------ */
86 #define MXL_CMD_REG_READ 0xaa
87 #define MXL_CMD_REG_WRITE 0x55
89 int mxl111sf_read_reg(struct mxl111sf_state *state, u8 addr, u8 *data)
94 ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_READ, &addr, 1, buf, 2);
96 mxl_debug("error reading reg: 0x%02x", addr);
103 pr_err("invalid response reading reg: 0x%02x != 0x%02x, 0x%02x",
104 addr, buf[0], buf[1]);
108 pr_debug("R: (0x%02x, 0x%02x)\n", addr, buf[1]);
113 int mxl111sf_write_reg(struct mxl111sf_state *state, u8 addr, u8 data)
115 u8 buf[] = { addr, data };
118 pr_debug("W: (0x%02x, 0x%02x)\n", addr, data);
120 ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_WRITE, buf, 2, NULL, 0);
122 pr_err("error writing reg: 0x%02x, val: 0x%02x", addr, data);
126 /* ------------------------------------------------------------------------ */
128 int mxl111sf_write_reg_mask(struct mxl111sf_state *state,
129 u8 addr, u8 mask, u8 data)
135 ret = mxl111sf_read_reg(state, addr, &val);
137 /* dont know why this usually errors out on the first try */
139 pr_err("error writing addr: 0x%02x, mask: 0x%02x, "
140 "data: 0x%02x, retrying...", addr, mask, data);
142 ret = mxl111sf_read_reg(state, addr, &val);
150 ret = mxl111sf_write_reg(state, addr, val);
156 /* ------------------------------------------------------------------------ */
158 int mxl111sf_ctrl_program_regs(struct mxl111sf_state *state,
159 struct mxl111sf_reg_ctrl_info *ctrl_reg_info)
163 for (i = 0; ctrl_reg_info[i].addr |
164 ctrl_reg_info[i].mask |
165 ctrl_reg_info[i].data; i++) {
167 ret = mxl111sf_write_reg_mask(state,
168 ctrl_reg_info[i].addr,
169 ctrl_reg_info[i].mask,
170 ctrl_reg_info[i].data);
172 pr_err("failed on reg #%d (0x%02x)", i,
173 ctrl_reg_info[i].addr);
180 /* ------------------------------------------------------------------------ */
182 static int mxl1x1sf_get_chip_info(struct mxl111sf_state *state)
186 char *mxl_chip, *mxl_rev;
188 if ((state->chip_id) && (state->chip_ver))
191 ret = mxl111sf_read_reg(state, CHIP_ID_REG, &id);
196 ret = mxl111sf_read_reg(state, TOP_CHIP_REV_ID_REG, &ver);
199 state->chip_ver = ver;
203 mxl_chip = "MxL101SF";
206 mxl_chip = "MxL111SF";
209 mxl_chip = "UNKNOWN MxL1X1";
214 state->chip_rev = MXL111SF_V6;
218 state->chip_rev = MXL111SF_V8_100;
222 state->chip_rev = MXL111SF_V8_200;
227 mxl_rev = "UNKNOWN REVISION";
230 pr_info("%s detected, %s (0x%x)", mxl_chip, mxl_rev, ver);
235 #define get_chip_info(state) \
238 ___ret = mxl1x1sf_get_chip_info(state); \
239 if (mxl_fail(___ret)) { \
240 mxl_debug("failed to get chip info" \
241 " on first probe attempt"); \
242 ___ret = mxl1x1sf_get_chip_info(state); \
243 if (mxl_fail(___ret)) \
244 pr_err("failed to get chip info during probe"); \
246 mxl_debug("probe needed a retry " \
247 "in order to succeed."); \
252 /* ------------------------------------------------------------------------ */
254 static int mxl111sf_power_ctrl(struct dvb_usb_device *d, int onoff)
256 /* power control depends on which adapter is being woken:
257 * save this for init, instead, via mxl111sf_adap_fe_init */
262 static int mxl111sf_adap_fe_init(struct dvb_frontend *fe)
264 struct dvb_usb_device *d = fe_to_d(fe);
265 struct mxl111sf_state *state = fe_to_priv(fe);
266 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
269 /* exit if we didn't initialize the driver yet */
270 if (!state->chip_id) {
271 mxl_debug("driver not yet initialized, exit.");
275 pr_debug("%s()\n", __func__);
277 mutex_lock(&state->fe_lock);
279 state->alt_mode = adap_state->alt_mode;
281 if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
282 pr_err("set interface failed");
284 err = mxl1x1sf_soft_reset(state);
286 err = mxl111sf_init_tuner_demod(state);
288 err = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
291 mxl111sf_enable_usb_output(state);
293 mxl1x1sf_top_master_ctrl(state, 1);
296 if ((MXL111SF_GPIO_MOD_DVBT != adap_state->gpio_mode) &&
297 (state->chip_rev > MXL111SF_V6)) {
298 mxl111sf_config_pin_mux_modes(state,
299 PIN_MUX_TS_SPI_IN_MODE_1);
302 err = mxl111sf_init_port_expander(state);
303 if (!mxl_fail(err)) {
304 state->gpio_mode = adap_state->gpio_mode;
305 err = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
308 err = fe->ops.init(fe);
310 msleep(100); /* add short delay after enabling
311 * the demod before touching it */
314 return (adap_state->fe_init) ? adap_state->fe_init(fe) : 0;
319 static int mxl111sf_adap_fe_sleep(struct dvb_frontend *fe)
321 struct mxl111sf_state *state = fe_to_priv(fe);
322 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
325 /* exit if we didn't initialize the driver yet */
326 if (!state->chip_id) {
327 mxl_debug("driver not yet initialized, exit.");
331 pr_debug("%s()\n", __func__);
333 err = (adap_state->fe_sleep) ? adap_state->fe_sleep(fe) : 0;
335 mutex_unlock(&state->fe_lock);
343 static int mxl111sf_ep6_streaming_ctrl(struct dvb_frontend *fe, int onoff)
345 struct mxl111sf_state *state = fe_to_priv(fe);
346 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe->id];
349 pr_debug("%s(%d)\n", __func__, onoff);
352 ret = mxl111sf_enable_usb_output(state);
354 ret = mxl111sf_config_mpeg_in(state, 1, 1,
355 adap_state->ep6_clockphase,
360 ret = mxl111sf_disable_656_port(state);
368 static int mxl111sf_ep5_streaming_ctrl(struct dvb_frontend *fe, int onoff)
370 struct mxl111sf_state *state = fe_to_priv(fe);
373 pr_debug("%s(%d)\n", __func__, onoff);
376 ret = mxl111sf_enable_usb_output(state);
379 ret = mxl111sf_init_i2s_port(state, 200);
381 ret = mxl111sf_config_i2s(state, 0, 15);
384 ret = mxl111sf_disable_i2s_port(state);
387 if (state->chip_rev > MXL111SF_V6)
388 ret = mxl111sf_config_spi(state, onoff);
394 static int mxl111sf_ep4_streaming_ctrl(struct dvb_frontend *fe, int onoff)
396 struct mxl111sf_state *state = fe_to_priv(fe);
399 pr_debug("%s(%d)\n", __func__, onoff);
402 ret = mxl111sf_enable_usb_output(state);
409 /* ------------------------------------------------------------------------ */
411 static struct lgdt3305_config hauppauge_lgdt3305_config = {
412 .i2c_addr = 0xb2 >> 1,
413 .mpeg_mode = LGDT3305_MPEG_SERIAL,
414 .tpclk_edge = LGDT3305_TPCLK_RISING_EDGE,
415 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH,
417 .spectral_inversion = 0,
422 static int mxl111sf_lgdt3305_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
424 struct dvb_usb_device *d = adap_to_d(adap);
425 struct mxl111sf_state *state = d_to_priv(d);
426 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
429 pr_debug("%s()\n", __func__);
431 /* save a pointer to the dvb_usb_device in device state */
433 adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
434 state->alt_mode = adap_state->alt_mode;
436 if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
437 pr_err("set interface failed");
439 state->gpio_mode = MXL111SF_GPIO_MOD_ATSC;
440 adap_state->gpio_mode = state->gpio_mode;
441 adap_state->device_mode = MXL_TUNER_MODE;
442 adap_state->ep6_clockphase = 1;
444 ret = mxl1x1sf_soft_reset(state);
447 ret = mxl111sf_init_tuner_demod(state);
451 ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
455 ret = mxl111sf_enable_usb_output(state);
458 ret = mxl1x1sf_top_master_ctrl(state, 1);
462 ret = mxl111sf_init_port_expander(state);
465 ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
469 adap->fe[fe_id] = dvb_attach(lgdt3305_attach,
470 &hauppauge_lgdt3305_config,
472 if (adap->fe[fe_id]) {
473 state->num_frontends++;
474 adap_state->fe_init = adap->fe[fe_id]->ops.init;
475 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
476 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
477 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
485 static struct lg2160_config hauppauge_lg2160_config = {
487 .i2c_addr = 0x1c >> 1,
489 .spectral_inversion = 0,
493 static int mxl111sf_lg2160_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
495 struct dvb_usb_device *d = adap_to_d(adap);
496 struct mxl111sf_state *state = d_to_priv(d);
497 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
500 pr_debug("%s()\n", __func__);
502 /* save a pointer to the dvb_usb_device in device state */
504 adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
505 state->alt_mode = adap_state->alt_mode;
507 if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
508 pr_err("set interface failed");
510 state->gpio_mode = MXL111SF_GPIO_MOD_MH;
511 adap_state->gpio_mode = state->gpio_mode;
512 adap_state->device_mode = MXL_TUNER_MODE;
513 adap_state->ep6_clockphase = 1;
515 ret = mxl1x1sf_soft_reset(state);
518 ret = mxl111sf_init_tuner_demod(state);
522 ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
526 ret = mxl111sf_enable_usb_output(state);
529 ret = mxl1x1sf_top_master_ctrl(state, 1);
533 ret = mxl111sf_init_port_expander(state);
536 ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
540 ret = get_chip_info(state);
544 adap->fe[fe_id] = dvb_attach(lg2160_attach,
545 &hauppauge_lg2160_config,
547 if (adap->fe[fe_id]) {
548 state->num_frontends++;
549 adap_state->fe_init = adap->fe[fe_id]->ops.init;
550 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
551 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
552 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
560 static struct lg2160_config hauppauge_lg2161_1019_config = {
561 .lg_chip = LG2161_1019,
562 .i2c_addr = 0x1c >> 1,
564 .spectral_inversion = 0,
566 .output_if = 2, /* LG2161_OIF_SPI_MAS */
569 static struct lg2160_config hauppauge_lg2161_1040_config = {
570 .lg_chip = LG2161_1040,
571 .i2c_addr = 0x1c >> 1,
573 .spectral_inversion = 0,
575 .output_if = 4, /* LG2161_OIF_SPI_MAS */
578 static int mxl111sf_lg2161_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
580 struct dvb_usb_device *d = adap_to_d(adap);
581 struct mxl111sf_state *state = d_to_priv(d);
582 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
585 pr_debug("%s()\n", __func__);
587 /* save a pointer to the dvb_usb_device in device state */
589 adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
590 state->alt_mode = adap_state->alt_mode;
592 if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
593 pr_err("set interface failed");
595 state->gpio_mode = MXL111SF_GPIO_MOD_MH;
596 adap_state->gpio_mode = state->gpio_mode;
597 adap_state->device_mode = MXL_TUNER_MODE;
598 adap_state->ep6_clockphase = 1;
600 ret = mxl1x1sf_soft_reset(state);
603 ret = mxl111sf_init_tuner_demod(state);
607 ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
611 ret = mxl111sf_enable_usb_output(state);
614 ret = mxl1x1sf_top_master_ctrl(state, 1);
618 ret = mxl111sf_init_port_expander(state);
621 ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
625 ret = get_chip_info(state);
629 adap->fe[fe_id] = dvb_attach(lg2160_attach,
630 (MXL111SF_V8_200 == state->chip_rev) ?
631 &hauppauge_lg2161_1040_config :
632 &hauppauge_lg2161_1019_config,
634 if (adap->fe[fe_id]) {
635 state->num_frontends++;
636 adap_state->fe_init = adap->fe[fe_id]->ops.init;
637 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
638 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
639 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
647 static struct lg2160_config hauppauge_lg2161_1019_ep6_config = {
648 .lg_chip = LG2161_1019,
649 .i2c_addr = 0x1c >> 1,
651 .spectral_inversion = 0,
653 .output_if = 1, /* LG2161_OIF_SERIAL_TS */
656 static struct lg2160_config hauppauge_lg2161_1040_ep6_config = {
657 .lg_chip = LG2161_1040,
658 .i2c_addr = 0x1c >> 1,
660 .spectral_inversion = 0,
662 .output_if = 7, /* LG2161_OIF_SERIAL_TS */
665 static int mxl111sf_lg2161_ep6_frontend_attach(struct dvb_usb_adapter *adap, u8 fe_id)
667 struct dvb_usb_device *d = adap_to_d(adap);
668 struct mxl111sf_state *state = d_to_priv(d);
669 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
672 pr_debug("%s()\n", __func__);
674 /* save a pointer to the dvb_usb_device in device state */
676 adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1;
677 state->alt_mode = adap_state->alt_mode;
679 if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
680 pr_err("set interface failed");
682 state->gpio_mode = MXL111SF_GPIO_MOD_MH;
683 adap_state->gpio_mode = state->gpio_mode;
684 adap_state->device_mode = MXL_TUNER_MODE;
685 adap_state->ep6_clockphase = 0;
687 ret = mxl1x1sf_soft_reset(state);
690 ret = mxl111sf_init_tuner_demod(state);
694 ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
698 ret = mxl111sf_enable_usb_output(state);
701 ret = mxl1x1sf_top_master_ctrl(state, 1);
705 ret = mxl111sf_init_port_expander(state);
708 ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode);
712 ret = get_chip_info(state);
716 adap->fe[fe_id] = dvb_attach(lg2160_attach,
717 (MXL111SF_V8_200 == state->chip_rev) ?
718 &hauppauge_lg2161_1040_ep6_config :
719 &hauppauge_lg2161_1019_ep6_config,
721 if (adap->fe[fe_id]) {
722 state->num_frontends++;
723 adap_state->fe_init = adap->fe[fe_id]->ops.init;
724 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
725 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
726 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
734 static struct mxl111sf_demod_config mxl_demod_config = {
735 .read_reg = mxl111sf_read_reg,
736 .write_reg = mxl111sf_write_reg,
737 .program_regs = mxl111sf_ctrl_program_regs,
740 static int mxl111sf_attach_demod(struct dvb_usb_adapter *adap, u8 fe_id)
742 struct dvb_usb_device *d = adap_to_d(adap);
743 struct mxl111sf_state *state = d_to_priv(d);
744 struct mxl111sf_adap_state *adap_state = &state->adap_state[fe_id];
747 pr_debug("%s()\n", __func__);
749 /* save a pointer to the dvb_usb_device in device state */
751 adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 1 : 2;
752 state->alt_mode = adap_state->alt_mode;
754 if (usb_set_interface(d->udev, 0, state->alt_mode) < 0)
755 pr_err("set interface failed");
757 state->gpio_mode = MXL111SF_GPIO_MOD_DVBT;
758 adap_state->gpio_mode = state->gpio_mode;
759 adap_state->device_mode = MXL_SOC_MODE;
760 adap_state->ep6_clockphase = 1;
762 ret = mxl1x1sf_soft_reset(state);
765 ret = mxl111sf_init_tuner_demod(state);
769 ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode);
773 ret = mxl111sf_enable_usb_output(state);
776 ret = mxl1x1sf_top_master_ctrl(state, 1);
780 /* dont care if this fails */
781 mxl111sf_init_port_expander(state);
783 adap->fe[fe_id] = dvb_attach(mxl111sf_demod_attach, state,
785 if (adap->fe[fe_id]) {
786 state->num_frontends++;
787 adap_state->fe_init = adap->fe[fe_id]->ops.init;
788 adap->fe[fe_id]->ops.init = mxl111sf_adap_fe_init;
789 adap_state->fe_sleep = adap->fe[fe_id]->ops.sleep;
790 adap->fe[fe_id]->ops.sleep = mxl111sf_adap_fe_sleep;
798 static inline int mxl111sf_set_ant_path(struct mxl111sf_state *state,
801 return mxl111sf_idac_config(state, 1, 1,
802 (antpath == ANT_PATH_INTERNAL) ?
806 #define DbgAntHunt(x, pwr0, pwr1, pwr2, pwr3) \
807 pr_err("%s(%d) FINAL input set to %s rxPwr:%d|%d|%d|%d\n", \
808 __func__, __LINE__, \
809 (ANT_PATH_EXTERNAL == x) ? "EXTERNAL" : "INTERNAL", \
810 pwr0, pwr1, pwr2, pwr3)
812 #define ANT_HUNT_SLEEP 90
813 #define ANT_EXT_TWEAK 0
815 static int mxl111sf_ant_hunt(struct dvb_frontend *fe)
817 struct mxl111sf_state *state = fe_to_priv(fe);
818 int antctrl = dvb_usb_mxl111sf_rfswitch;
820 u16 rxPwrA, rxPwr0, rxPwr1, rxPwr2;
822 /* FIXME: must force EXTERNAL for QAM - done elsewhere */
823 mxl111sf_set_ant_path(state, antctrl == ANT_PATH_AUTO ?
824 ANT_PATH_EXTERNAL : antctrl);
826 if (antctrl == ANT_PATH_AUTO) {
828 msleep(ANT_HUNT_SLEEP);
830 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwrA);
832 mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
833 msleep(ANT_HUNT_SLEEP);
834 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr0);
836 mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
837 msleep(ANT_HUNT_SLEEP);
838 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr1);
840 mxl111sf_set_ant_path(state, ANT_PATH_INTERNAL);
841 msleep(ANT_HUNT_SLEEP);
842 fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr2);
844 if (rxPwr1+ANT_EXT_TWEAK >= rxPwr2) {
845 /* return with EXTERNAL enabled */
846 mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL);
847 DbgAntHunt(ANT_PATH_EXTERNAL, rxPwrA,
848 rxPwr0, rxPwr1, rxPwr2);
850 /* return with INTERNAL enabled */
851 DbgAntHunt(ANT_PATH_INTERNAL, rxPwrA,
852 rxPwr0, rxPwr1, rxPwr2);
858 static struct mxl111sf_tuner_config mxl_tuner_config = {
859 .if_freq = MXL_IF_6_0, /* applies to external IF output, only */
860 .invert_spectrum = 0,
861 .read_reg = mxl111sf_read_reg,
862 .write_reg = mxl111sf_write_reg,
863 .program_regs = mxl111sf_ctrl_program_regs,
864 .top_master_ctrl = mxl1x1sf_top_master_ctrl,
865 .ant_hunt = mxl111sf_ant_hunt,
868 static int mxl111sf_attach_tuner(struct dvb_usb_adapter *adap)
870 struct mxl111sf_state *state = adap_to_priv(adap);
873 pr_debug("%s()\n", __func__);
875 for (i = 0; i < state->num_frontends; i++) {
876 if (dvb_attach(mxl111sf_tuner_attach, adap->fe[i], state,
877 &mxl_tuner_config) == NULL)
879 adap->fe[i]->ops.read_signal_strength = adap->fe[i]->ops.tuner_ops.get_rf_strength;
885 static u32 mxl111sf_i2c_func(struct i2c_adapter *adapter)
890 static struct i2c_algorithm mxl111sf_i2c_algo = {
891 .master_xfer = mxl111sf_i2c_xfer,
892 .functionality = mxl111sf_i2c_func,
893 #ifdef NEED_ALGO_CONTROL
894 .algo_control = dummy_algo_control,
898 static int mxl111sf_init(struct dvb_usb_device *d)
900 struct mxl111sf_state *state = d_to_priv(d);
902 static u8 eeprom[256];
905 ret = get_chip_info(state);
907 pr_err("failed to get chip info during probe");
909 mutex_init(&state->fe_lock);
911 if (state->chip_rev > MXL111SF_V6)
912 mxl111sf_config_pin_mux_modes(state, PIN_MUX_TS_SPI_IN_MODE_1);
914 c.adapter = &d->i2c_adap;
917 ret = tveeprom_read(&c, eeprom, sizeof(eeprom));
920 tveeprom_hauppauge_analog(&c, &state->tv, (0x84 == eeprom[0xa0]) ?
921 eeprom + 0xa0 : eeprom + 0x80);
923 switch (state->tv.model) {
929 printk(KERN_WARNING "%s: warning: "
930 "unknown hauppauge model #%d\n",
931 __func__, state->tv.model);
937 static int mxl111sf_frontend_attach_dvbt(struct dvb_usb_adapter *adap)
939 return mxl111sf_attach_demod(adap, 0);
942 static int mxl111sf_frontend_attach_atsc(struct dvb_usb_adapter *adap)
944 return mxl111sf_lgdt3305_frontend_attach(adap, 0);
947 static int mxl111sf_frontend_attach_mh(struct dvb_usb_adapter *adap)
949 return mxl111sf_lg2160_frontend_attach(adap, 0);
952 static int mxl111sf_frontend_attach_atsc_mh(struct dvb_usb_adapter *adap)
955 pr_debug("%s\n", __func__);
957 ret = mxl111sf_lgdt3305_frontend_attach(adap, 0);
961 ret = mxl111sf_attach_demod(adap, 1);
965 ret = mxl111sf_lg2160_frontend_attach(adap, 2);
972 static int mxl111sf_frontend_attach_mercury(struct dvb_usb_adapter *adap)
975 pr_debug("%s\n", __func__);
977 ret = mxl111sf_lgdt3305_frontend_attach(adap, 0);
981 ret = mxl111sf_attach_demod(adap, 1);
985 ret = mxl111sf_lg2161_ep6_frontend_attach(adap, 2);
992 static int mxl111sf_frontend_attach_mercury_mh(struct dvb_usb_adapter *adap)
995 pr_debug("%s\n", __func__);
997 ret = mxl111sf_attach_demod(adap, 0);
1001 if (dvb_usb_mxl111sf_spi)
1002 ret = mxl111sf_lg2161_frontend_attach(adap, 1);
1004 ret = mxl111sf_lg2161_ep6_frontend_attach(adap, 1);
1009 static void mxl111sf_stream_config_bulk(struct usb_data_stream_properties *stream, u8 endpoint)
1011 pr_debug("%s: endpoint=%d size=8192\n", __func__, endpoint);
1012 stream->type = USB_BULK;
1014 stream->endpoint = endpoint;
1015 stream->u.bulk.buffersize = 8192;
1018 static void mxl111sf_stream_config_isoc(struct usb_data_stream_properties *stream,
1019 u8 endpoint, int framesperurb, int framesize)
1021 pr_debug("%s: endpoint=%d size=%d\n", __func__, endpoint,
1022 framesperurb * framesize);
1023 stream->type = USB_ISOC;
1025 stream->endpoint = endpoint;
1026 stream->u.isoc.framesperurb = framesperurb;
1027 stream->u.isoc.framesize = framesize;
1028 stream->u.isoc.interval = 1;
1031 /* DVB USB Driver stuff */
1034 * bulk EP4/BULK/5/8192
1035 * isoc EP4/ISOC/5/96/564
1037 static int mxl111sf_get_stream_config_dvbt(struct dvb_frontend *fe,
1038 u8 *ts_type, struct usb_data_stream_properties *stream)
1040 pr_debug("%s: fe=%d\n", __func__, fe->id);
1042 *ts_type = DVB_USB_FE_TS_TYPE_188;
1043 if (dvb_usb_mxl111sf_isoc)
1044 mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1046 mxl111sf_stream_config_bulk(stream, 4);
1050 static struct dvb_usb_device_properties mxl111sf_props_dvbt = {
1051 .driver_name = KBUILD_MODNAME,
1052 .owner = THIS_MODULE,
1053 .adapter_nr = adapter_nr,
1054 .size_of_priv = sizeof(struct mxl111sf_state),
1056 .generic_bulk_ctrl_endpoint = 0x02,
1057 .generic_bulk_ctrl_endpoint_response = 0x81,
1059 .i2c_algo = &mxl111sf_i2c_algo,
1060 .frontend_attach = mxl111sf_frontend_attach_dvbt,
1061 .tuner_attach = mxl111sf_attach_tuner,
1062 .init = mxl111sf_init,
1063 .streaming_ctrl = mxl111sf_ep4_streaming_ctrl,
1064 .get_stream_config = mxl111sf_get_stream_config_dvbt,
1069 .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1075 * bulk EP6/BULK/5/8192
1076 * isoc EP6/ISOC/5/24/3072
1078 static int mxl111sf_get_stream_config_atsc(struct dvb_frontend *fe,
1079 u8 *ts_type, struct usb_data_stream_properties *stream)
1081 pr_debug("%s: fe=%d\n", __func__, fe->id);
1083 *ts_type = DVB_USB_FE_TS_TYPE_188;
1084 if (dvb_usb_mxl111sf_isoc)
1085 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1087 mxl111sf_stream_config_bulk(stream, 6);
1091 static struct dvb_usb_device_properties mxl111sf_props_atsc = {
1092 .driver_name = KBUILD_MODNAME,
1093 .owner = THIS_MODULE,
1094 .adapter_nr = adapter_nr,
1095 .size_of_priv = sizeof(struct mxl111sf_state),
1097 .generic_bulk_ctrl_endpoint = 0x02,
1098 .generic_bulk_ctrl_endpoint_response = 0x81,
1100 .i2c_algo = &mxl111sf_i2c_algo,
1101 .frontend_attach = mxl111sf_frontend_attach_atsc,
1102 .tuner_attach = mxl111sf_attach_tuner,
1103 .init = mxl111sf_init,
1104 .streaming_ctrl = mxl111sf_ep6_streaming_ctrl,
1105 .get_stream_config = mxl111sf_get_stream_config_atsc,
1110 .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1116 * bulk EP5/BULK/5/8192/RAW
1117 * isoc EP5/ISOC/5/96/200/RAW
1119 static int mxl111sf_get_stream_config_mh(struct dvb_frontend *fe,
1120 u8 *ts_type, struct usb_data_stream_properties *stream)
1122 pr_debug("%s: fe=%d\n", __func__, fe->id);
1124 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1125 if (dvb_usb_mxl111sf_isoc)
1126 mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1128 mxl111sf_stream_config_bulk(stream, 5);
1132 static struct dvb_usb_device_properties mxl111sf_props_mh = {
1133 .driver_name = KBUILD_MODNAME,
1134 .owner = THIS_MODULE,
1135 .adapter_nr = adapter_nr,
1136 .size_of_priv = sizeof(struct mxl111sf_state),
1138 .generic_bulk_ctrl_endpoint = 0x02,
1139 .generic_bulk_ctrl_endpoint_response = 0x81,
1141 .i2c_algo = &mxl111sf_i2c_algo,
1142 .frontend_attach = mxl111sf_frontend_attach_mh,
1143 .tuner_attach = mxl111sf_attach_tuner,
1144 .init = mxl111sf_init,
1145 .streaming_ctrl = mxl111sf_ep5_streaming_ctrl,
1146 .get_stream_config = mxl111sf_get_stream_config_mh,
1151 .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1156 /* atsc mh lgdt3305 mxl111sf lg2160
1157 * bulk EP6/BULK/5/8192 EP4/BULK/5/8192 EP5/BULK/5/8192/RAW
1158 * isoc EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1160 static int mxl111sf_get_stream_config_atsc_mh(struct dvb_frontend *fe,
1161 u8 *ts_type, struct usb_data_stream_properties *stream)
1163 pr_debug("%s: fe=%d\n", __func__, fe->id);
1166 *ts_type = DVB_USB_FE_TS_TYPE_188;
1167 if (dvb_usb_mxl111sf_isoc)
1168 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1170 mxl111sf_stream_config_bulk(stream, 6);
1171 } else if (fe->id == 1) {
1172 *ts_type = DVB_USB_FE_TS_TYPE_188;
1173 if (dvb_usb_mxl111sf_isoc)
1174 mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1176 mxl111sf_stream_config_bulk(stream, 4);
1177 } else if (fe->id == 2) {
1178 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1179 if (dvb_usb_mxl111sf_isoc)
1180 mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1182 mxl111sf_stream_config_bulk(stream, 5);
1187 static int mxl111sf_streaming_ctrl_atsc_mh(struct dvb_frontend *fe, int onoff)
1189 pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1192 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1193 else if (fe->id == 1)
1194 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1195 else if (fe->id == 2)
1196 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1200 static struct dvb_usb_device_properties mxl111sf_props_atsc_mh = {
1201 .driver_name = KBUILD_MODNAME,
1202 .owner = THIS_MODULE,
1203 .adapter_nr = adapter_nr,
1204 .size_of_priv = sizeof(struct mxl111sf_state),
1206 .generic_bulk_ctrl_endpoint = 0x02,
1207 .generic_bulk_ctrl_endpoint_response = 0x81,
1209 .i2c_algo = &mxl111sf_i2c_algo,
1210 .frontend_attach = mxl111sf_frontend_attach_atsc_mh,
1211 .tuner_attach = mxl111sf_attach_tuner,
1212 .init = mxl111sf_init,
1213 .streaming_ctrl = mxl111sf_streaming_ctrl_atsc_mh,
1214 .get_stream_config = mxl111sf_get_stream_config_atsc_mh,
1219 .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1224 /* mercury lgdt3305 mxl111sf lg2161
1225 * tp bulk EP6/BULK/5/8192 EP4/BULK/5/8192 EP6/BULK/5/8192/RAW
1226 * tp isoc EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1227 * spi bulk EP6/BULK/5/8192 EP4/BULK/5/8192 EP5/BULK/5/8192/RAW
1228 * spi isoc EP6/ISOC/5/24/3072 EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1230 static int mxl111sf_get_stream_config_mercury(struct dvb_frontend *fe,
1231 u8 *ts_type, struct usb_data_stream_properties *stream)
1233 pr_debug("%s: fe=%d\n", __func__, fe->id);
1236 *ts_type = DVB_USB_FE_TS_TYPE_188;
1237 if (dvb_usb_mxl111sf_isoc)
1238 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1240 mxl111sf_stream_config_bulk(stream, 6);
1241 } else if (fe->id == 1) {
1242 *ts_type = DVB_USB_FE_TS_TYPE_188;
1243 if (dvb_usb_mxl111sf_isoc)
1244 mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1246 mxl111sf_stream_config_bulk(stream, 4);
1247 } else if (fe->id == 2 && dvb_usb_mxl111sf_spi) {
1248 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1249 if (dvb_usb_mxl111sf_isoc)
1250 mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1252 mxl111sf_stream_config_bulk(stream, 5);
1253 } else if (fe->id == 2 && !dvb_usb_mxl111sf_spi) {
1254 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1255 if (dvb_usb_mxl111sf_isoc)
1256 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1258 mxl111sf_stream_config_bulk(stream, 6);
1263 static int mxl111sf_streaming_ctrl_mercury(struct dvb_frontend *fe, int onoff)
1265 pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1268 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1269 else if (fe->id == 1)
1270 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1271 else if (fe->id == 2 && dvb_usb_mxl111sf_spi)
1272 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1273 else if (fe->id == 2 && !dvb_usb_mxl111sf_spi)
1274 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1278 static struct dvb_usb_device_properties mxl111sf_props_mercury = {
1279 .driver_name = KBUILD_MODNAME,
1280 .owner = THIS_MODULE,
1281 .adapter_nr = adapter_nr,
1282 .size_of_priv = sizeof(struct mxl111sf_state),
1284 .generic_bulk_ctrl_endpoint = 0x02,
1285 .generic_bulk_ctrl_endpoint_response = 0x81,
1287 .i2c_algo = &mxl111sf_i2c_algo,
1288 .frontend_attach = mxl111sf_frontend_attach_mercury,
1289 .tuner_attach = mxl111sf_attach_tuner,
1290 .init = mxl111sf_init,
1291 .streaming_ctrl = mxl111sf_streaming_ctrl_mercury,
1292 .get_stream_config = mxl111sf_get_stream_config_mercury,
1297 .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1302 /* mercury mh mxl111sf lg2161
1303 * tp bulk EP4/BULK/5/8192 EP6/BULK/5/8192/RAW
1304 * tp isoc EP4/ISOC/5/96/564 EP6/ISOC/5/24/3072/RAW
1305 * spi bulk EP4/BULK/5/8192 EP5/BULK/5/8192/RAW
1306 * spi isoc EP4/ISOC/5/96/564 EP5/ISOC/5/96/200/RAW
1308 static int mxl111sf_get_stream_config_mercury_mh(struct dvb_frontend *fe,
1309 u8 *ts_type, struct usb_data_stream_properties *stream)
1311 pr_debug("%s: fe=%d\n", __func__, fe->id);
1314 *ts_type = DVB_USB_FE_TS_TYPE_188;
1315 if (dvb_usb_mxl111sf_isoc)
1316 mxl111sf_stream_config_isoc(stream, 4, 96, 564);
1318 mxl111sf_stream_config_bulk(stream, 4);
1319 } else if (fe->id == 1 && dvb_usb_mxl111sf_spi) {
1320 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1321 if (dvb_usb_mxl111sf_isoc)
1322 mxl111sf_stream_config_isoc(stream, 5, 96, 200);
1324 mxl111sf_stream_config_bulk(stream, 5);
1325 } else if (fe->id == 1 && !dvb_usb_mxl111sf_spi) {
1326 *ts_type = DVB_USB_FE_TS_TYPE_RAW;
1327 if (dvb_usb_mxl111sf_isoc)
1328 mxl111sf_stream_config_isoc(stream, 6, 24, 3072);
1330 mxl111sf_stream_config_bulk(stream, 6);
1335 static int mxl111sf_streaming_ctrl_mercury_mh(struct dvb_frontend *fe, int onoff)
1337 pr_debug("%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
1340 return mxl111sf_ep4_streaming_ctrl(fe, onoff);
1341 else if (fe->id == 1 && dvb_usb_mxl111sf_spi)
1342 return mxl111sf_ep5_streaming_ctrl(fe, onoff);
1343 else if (fe->id == 1 && !dvb_usb_mxl111sf_spi)
1344 return mxl111sf_ep6_streaming_ctrl(fe, onoff);
1348 static struct dvb_usb_device_properties mxl111sf_props_mercury_mh = {
1349 .driver_name = KBUILD_MODNAME,
1350 .owner = THIS_MODULE,
1351 .adapter_nr = adapter_nr,
1352 .size_of_priv = sizeof(struct mxl111sf_state),
1354 .generic_bulk_ctrl_endpoint = 0x02,
1355 .generic_bulk_ctrl_endpoint_response = 0x81,
1357 .i2c_algo = &mxl111sf_i2c_algo,
1358 .frontend_attach = mxl111sf_frontend_attach_mercury_mh,
1359 .tuner_attach = mxl111sf_attach_tuner,
1360 .init = mxl111sf_init,
1361 .streaming_ctrl = mxl111sf_streaming_ctrl_mercury_mh,
1362 .get_stream_config = mxl111sf_get_stream_config_mercury_mh,
1367 .stream = DVB_USB_STREAM_ISOC(6, 5, 24, 3072, 1),
1372 static const struct usb_device_id mxl111sf_id_table[] = {
1373 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc600, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1374 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc601, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1375 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc602, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1376 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc603, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1377 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc604, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1378 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc609, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1379 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60a, &mxl111sf_props_mh, "HCW 126xxx", NULL) },
1380 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1381 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60c, &mxl111sf_props_dvbt, "Hauppauge 126xxx DVBT", NULL) },
1382 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc653, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1383 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc65b, &mxl111sf_props_atsc_mh, "Hauppauge 126xxx ATSC+", NULL) },
1384 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb700, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1385 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb701, &mxl111sf_props_atsc, "Hauppauge 126xxx ATSC", NULL) },
1386 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb702, &mxl111sf_props_mh, "HCW 117xxx", NULL) },
1387 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb703, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1388 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb704, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1389 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb753, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1390 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb763, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1391 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb764, &mxl111sf_props_dvbt, "Hauppauge 117xxx DVBT", NULL) },
1392 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd853, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1393 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd854, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1394 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd863, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1395 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd864, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1396 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1397 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1398 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e3, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1399 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e4, &mxl111sf_props_dvbt, "Hauppauge 138xxx DVBT", NULL) },
1400 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8ff, &mxl111sf_props_mercury, "Hauppauge Mercury", NULL) },
1401 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc612, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1402 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc613, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1403 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61a, &mxl111sf_props_mercury_mh, "Hauppauge 126xxx", NULL) },
1404 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61b, &mxl111sf_props_mercury, "Hauppauge WinTV-Aero-M", NULL) },
1405 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb757, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1406 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xb767, &mxl111sf_props_atsc_mh, "Hauppauge 117xxx ATSC+", NULL) },
1409 MODULE_DEVICE_TABLE(usb, mxl111sf_id_table);
1411 static struct usb_driver mxl111sf_usb_driver = {
1412 .name = KBUILD_MODNAME,
1413 .id_table = mxl111sf_id_table,
1414 .probe = dvb_usbv2_probe,
1415 .disconnect = dvb_usbv2_disconnect,
1416 .suspend = dvb_usbv2_suspend,
1417 .resume = dvb_usbv2_resume,
1422 module_usb_driver(mxl111sf_usb_driver);
1424 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1425 MODULE_DESCRIPTION("Driver for MaxLinear MxL111SF");
1426 MODULE_VERSION("1.0");
1427 MODULE_LICENSE("GPL");