/* * Copyright (C) 2010 Michael Krufky (mkrufky@kernellabs.com) * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation, version 2. * * see Documentation/dvb/README.dvb-usb for more information */ #include #include #include "mxl111sf.h" #include "mxl111sf-reg.h" #include "mxl111sf-phy.h" #include "mxl111sf-i2c.h" #include "mxl111sf-gpio.h" #include "mxl111sf-demod.h" #include "mxl111sf-tuner.h" #include "lgdt3305.h" int dvb_usb_mxl111sf_debug; module_param_named(debug, dvb_usb_mxl111sf_debug, int, 0644); MODULE_PARM_DESC(debug, "set debugging level " "(1=info, 2=xfer, 4=i2c, 8=reg, 16=adv (or-able))."); int dvb_usb_mxl111sf_isoc; module_param_named(isoc, dvb_usb_mxl111sf_isoc, int, 0644); MODULE_PARM_DESC(isoc, "enable usb isoc xfer (0=bulk, 1=isoc)."); #define ANT_PATH_AUTO 0 #define ANT_PATH_EXTERNAL 1 #define ANT_PATH_INTERNAL 2 int dvb_usb_mxl111sf_rfswitch = #if 0 ANT_PATH_AUTO; #else ANT_PATH_EXTERNAL; #endif module_param_named(rfswitch, dvb_usb_mxl111sf_rfswitch, int, 0644); MODULE_PARM_DESC(rfswitch, "force rf switch position (0=auto, 1=ext, 2=int)."); DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); #define deb_info(args...) dprintk(dvb_usb_mxl111sf_debug, 0x13, args) #define deb_reg(args...) dprintk(dvb_usb_mxl111sf_debug, 0x08, args) #define deb_adv(args...) dprintk(dvb_usb_mxl111sf_debug, MXL_ADV_DBG, args) int mxl111sf_ctrl_msg(struct dvb_usb_device *d, u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen) { int wo = (rbuf == NULL || rlen == 0); /* write-only */ int ret; u8 sndbuf[1+wlen]; deb_adv("%s(wlen = %d, rlen = %d)\n", __func__, wlen, rlen); memset(sndbuf, 0, 1+wlen); sndbuf[0] = cmd; memcpy(&sndbuf[1], wbuf, wlen); ret = (wo) ? dvb_usb_generic_write(d, sndbuf, 1+wlen) : dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0); mxl_fail(ret); return ret; } /* ------------------------------------------------------------------------ */ #define MXL_CMD_REG_READ 0xaa #define MXL_CMD_REG_WRITE 0x55 int mxl111sf_read_reg(struct mxl111sf_state *state, u8 addr, u8 *data) { u8 buf[2]; int ret; ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_READ, &addr, 1, buf, 2); if (mxl_fail(ret)) { mxl_debug("error reading reg: 0x%02x", addr); goto fail; } if (buf[0] == addr) *data = buf[1]; else { err("invalid response reading reg: 0x%02x != 0x%02x, 0x%02x", addr, buf[0], buf[1]); ret = -EINVAL; } deb_reg("R: (0x%02x, 0x%02x)\n", addr, *data); fail: return ret; } int mxl111sf_write_reg(struct mxl111sf_state *state, u8 addr, u8 data) { u8 buf[] = { addr, data }; int ret; deb_reg("W: (0x%02x, 0x%02x)\n", addr, data); ret = mxl111sf_ctrl_msg(state->d, MXL_CMD_REG_WRITE, buf, 2, NULL, 0); if (mxl_fail(ret)) err("error writing reg: 0x%02x, val: 0x%02x", addr, data); return ret; } /* ------------------------------------------------------------------------ */ int mxl111sf_write_reg_mask(struct mxl111sf_state *state, u8 addr, u8 mask, u8 data) { int ret; u8 val; if (mask != 0xff) { ret = mxl111sf_read_reg(state, addr, &val); #if 1 /* dont know why this usually errors out on the first try */ if (mxl_fail(ret)) err("error writing addr: 0x%02x, mask: 0x%02x, " "data: 0x%02x, retrying...", addr, mask, data); ret = mxl111sf_read_reg(state, addr, &val); #endif if (mxl_fail(ret)) goto fail; } val &= ~mask; val |= data; ret = mxl111sf_write_reg(state, addr, val); mxl_fail(ret); fail: return ret; } /* ------------------------------------------------------------------------ */ int mxl111sf_ctrl_program_regs(struct mxl111sf_state *state, struct mxl111sf_reg_ctrl_info *ctrl_reg_info) { int i, ret = 0; for (i = 0; ctrl_reg_info[i].addr | ctrl_reg_info[i].mask | ctrl_reg_info[i].data; i++) { ret = mxl111sf_write_reg_mask(state, ctrl_reg_info[i].addr, ctrl_reg_info[i].mask, ctrl_reg_info[i].data); if (mxl_fail(ret)) { err("failed on reg #%d (0x%02x)", i, ctrl_reg_info[i].addr); break; } } return ret; } /* ------------------------------------------------------------------------ */ static int mxl1x1sf_get_chip_info(struct mxl111sf_state *state) { int ret; u8 id, ver; char *mxl_chip, *mxl_rev; if ((state->chip_id) && (state->chip_ver)) return 0; ret = mxl111sf_read_reg(state, CHIP_ID_REG, &id); if (mxl_fail(ret)) goto fail; state->chip_id = id; ret = mxl111sf_read_reg(state, TOP_CHIP_REV_ID_REG, &ver); if (mxl_fail(ret)) goto fail; state->chip_ver = ver; switch (id) { case 0x61: mxl_chip = "MxL101SF"; break; case 0x63: mxl_chip = "MxL111SF"; break; default: mxl_chip = "UNKNOWN MxL1X1"; break; } switch (ver) { case 0x36: state->chip_rev = MXL111SF_V6; mxl_rev = "v6"; break; case 0x08: state->chip_rev = MXL111SF_V8_100; mxl_rev = "v8_100"; break; case 0x18: state->chip_rev = MXL111SF_V8_200; mxl_rev = "v8_200"; break; default: state->chip_rev = 0; mxl_rev = "UNKNOWN REVISION"; break; } info("%s detected, %s (0x%x)", mxl_chip, mxl_rev, ver); fail: return ret; } #define get_chip_info(state) \ ({ \ int ___ret; \ ___ret = mxl1x1sf_get_chip_info(state); \ if (mxl_fail(___ret)) { \ mxl_debug("failed to get chip info" \ " on first probe attempt"); \ ___ret = mxl1x1sf_get_chip_info(state); \ if (mxl_fail(___ret)) \ err("failed to get chip info during probe"); \ else \ mxl_debug("probe needed a retry " \ "in order to succeed."); \ } \ ___ret; \ }) /* ------------------------------------------------------------------------ */ static int mxl111sf_power_ctrl(struct dvb_usb_device *d, int onoff) { /* power control depends on which adapter is being woken: * save this for init, instead, via mxl111sf_adap_fe_init */ return 0; } static int mxl111sf_adap_fe_init(struct dvb_frontend *fe) { struct dvb_usb_adapter *adap = fe->dvb->priv; struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; struct mxl111sf_adap_state *adap_state = adap->fe_adap[fe->id].priv; int err; /* exit if we didnt initialize the driver yet */ if (!state->chip_id) { mxl_debug("driver not yet initialized, exit."); goto fail; } deb_info("%s()\n", __func__); mutex_lock(&state->fe_lock); state->alt_mode = adap_state->alt_mode; if (usb_set_interface(adap->dev->udev, 0, state->alt_mode) < 0) err("set interface failed"); err = mxl1x1sf_soft_reset(state); mxl_fail(err); err = mxl111sf_init_tuner_demod(state); mxl_fail(err); err = mxl1x1sf_set_device_mode(state, adap_state->device_mode); mxl_fail(err); mxl111sf_enable_usb_output(state); mxl_fail(err); mxl1x1sf_top_master_ctrl(state, 1); mxl_fail(err); if ((MXL111SF_GPIO_MOD_DVBT != adap_state->gpio_mode) && (state->chip_rev > MXL111SF_V6)) { mxl111sf_config_pin_mux_modes(state, PIN_MUX_TS_SPI_IN_MODE_1); mxl_fail(err); } err = mxl111sf_init_port_expander(state); if (!mxl_fail(err)) { state->gpio_mode = adap_state->gpio_mode; err = mxl111sf_gpio_mode_switch(state, state->gpio_mode); mxl_fail(err); #if 0 err = fe->ops.init(fe); #endif msleep(100); /* add short delay after enabling * the demod before touching it */ } return (adap_state->fe_init) ? adap_state->fe_init(fe) : 0; fail: return -ENODEV; } static int mxl111sf_adap_fe_sleep(struct dvb_frontend *fe) { struct dvb_usb_adapter *adap = fe->dvb->priv; struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; struct mxl111sf_adap_state *adap_state = adap->fe_adap[fe->id].priv; int err; /* exit if we didnt initialize the driver yet */ if (!state->chip_id) { mxl_debug("driver not yet initialized, exit."); goto fail; } deb_info("%s()\n", __func__); err = (adap_state->fe_sleep) ? adap_state->fe_sleep(fe) : 0; mutex_unlock(&state->fe_lock); return err; fail: return -ENODEV; } static int mxl111sf_ep6_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) { struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; struct mxl111sf_adap_state *adap_state = adap->fe_adap[adap->active_fe].priv; int ret = 0; u8 tmp; deb_info("%s(%d)\n", __func__, onoff); if (onoff) { ret = mxl111sf_enable_usb_output(state); mxl_fail(ret); ret = mxl111sf_config_mpeg_in(state, 1, 1, adap_state->ep6_clockphase, 0, 0); mxl_fail(ret); } else { ret = mxl111sf_disable_656_port(state); mxl_fail(ret); } mxl111sf_read_reg(state, 0x12, &tmp); tmp &= ~0x04; mxl111sf_write_reg(state, 0x12, tmp); return ret; } static int mxl111sf_ep4_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) { struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; int ret = 0; deb_info("%s(%d)\n", __func__, onoff); if (onoff) { ret = mxl111sf_enable_usb_output(state); mxl_fail(ret); } return ret; } /* ------------------------------------------------------------------------ */ static struct lgdt3305_config hauppauge_lgdt3305_config = { .i2c_addr = 0xb2 >> 1, .mpeg_mode = LGDT3305_MPEG_SERIAL, .tpclk_edge = LGDT3305_TPCLK_RISING_EDGE, .tpvalid_polarity = LGDT3305_TP_VALID_HIGH, .deny_i2c_rptr = 1, .spectral_inversion = 0, .qam_if_khz = 6000, .vsb_if_khz = 6000, }; static int mxl111sf_lgdt3305_frontend_attach(struct dvb_usb_adapter *adap) { struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; int fe_id = adap->num_frontends_initialized; struct mxl111sf_adap_state *adap_state = adap->fe_adap[fe_id].priv; int ret; deb_adv("%s()\n", __func__); /* save a pointer to the dvb_usb_device in device state */ state->d = d; adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 2 : 1; state->alt_mode = adap_state->alt_mode; if (usb_set_interface(adap->dev->udev, 0, state->alt_mode) < 0) err("set interface failed"); state->gpio_mode = MXL111SF_GPIO_MOD_ATSC; adap_state->gpio_mode = state->gpio_mode; adap_state->device_mode = MXL_TUNER_MODE; adap_state->ep6_clockphase = 1; ret = mxl1x1sf_soft_reset(state); if (mxl_fail(ret)) goto fail; ret = mxl111sf_init_tuner_demod(state); if (mxl_fail(ret)) goto fail; ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode); if (mxl_fail(ret)) goto fail; ret = mxl111sf_enable_usb_output(state); if (mxl_fail(ret)) goto fail; ret = mxl1x1sf_top_master_ctrl(state, 1); if (mxl_fail(ret)) goto fail; ret = mxl111sf_init_port_expander(state); if (mxl_fail(ret)) goto fail; ret = mxl111sf_gpio_mode_switch(state, state->gpio_mode); if (mxl_fail(ret)) goto fail; adap->fe_adap[fe_id].fe = dvb_attach(lgdt3305_attach, &hauppauge_lgdt3305_config, &adap->dev->i2c_adap); if (adap->fe_adap[fe_id].fe) { adap_state->fe_init = adap->fe_adap[fe_id].fe->ops.init; adap->fe_adap[fe_id].fe->ops.init = mxl111sf_adap_fe_init; adap_state->fe_sleep = adap->fe_adap[fe_id].fe->ops.sleep; adap->fe_adap[fe_id].fe->ops.sleep = mxl111sf_adap_fe_sleep; return 0; } ret = -EIO; fail: return ret; } static struct mxl111sf_demod_config mxl_demod_config = { .read_reg = mxl111sf_read_reg, .write_reg = mxl111sf_write_reg, .program_regs = mxl111sf_ctrl_program_regs, }; static int mxl111sf_attach_demod(struct dvb_usb_adapter *adap) { struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; int fe_id = adap->num_frontends_initialized; struct mxl111sf_adap_state *adap_state = adap->fe_adap[fe_id].priv; int ret; deb_adv("%s()\n", __func__); /* save a pointer to the dvb_usb_device in device state */ state->d = d; adap_state->alt_mode = (dvb_usb_mxl111sf_isoc) ? 1 : 2; state->alt_mode = adap_state->alt_mode; if (usb_set_interface(adap->dev->udev, 0, state->alt_mode) < 0) err("set interface failed"); state->gpio_mode = MXL111SF_GPIO_MOD_DVBT; adap_state->gpio_mode = state->gpio_mode; adap_state->device_mode = MXL_SOC_MODE; adap_state->ep6_clockphase = 1; ret = mxl1x1sf_soft_reset(state); if (mxl_fail(ret)) goto fail; ret = mxl111sf_init_tuner_demod(state); if (mxl_fail(ret)) goto fail; ret = mxl1x1sf_set_device_mode(state, adap_state->device_mode); if (mxl_fail(ret)) goto fail; ret = mxl111sf_enable_usb_output(state); if (mxl_fail(ret)) goto fail; ret = mxl1x1sf_top_master_ctrl(state, 1); if (mxl_fail(ret)) goto fail; /* dont care if this fails */ mxl111sf_init_port_expander(state); adap->fe_adap[fe_id].fe = dvb_attach(mxl111sf_demod_attach, state, &mxl_demod_config); if (adap->fe_adap[fe_id].fe) { adap_state->fe_init = adap->fe_adap[fe_id].fe->ops.init; adap->fe_adap[fe_id].fe->ops.init = mxl111sf_adap_fe_init; adap_state->fe_sleep = adap->fe_adap[fe_id].fe->ops.sleep; adap->fe_adap[fe_id].fe->ops.sleep = mxl111sf_adap_fe_sleep; return 0; } ret = -EIO; fail: return ret; } static inline int mxl111sf_set_ant_path(struct mxl111sf_state *state, int antpath) { return mxl111sf_idac_config(state, 1, 1, (antpath == ANT_PATH_INTERNAL) ? 0x3f : 0x00, 0); } #define DbgAntHunt(x, pwr0, pwr1, pwr2, pwr3) \ err("%s(%d) FINAL input set to %s rxPwr:%d|%d|%d|%d\n", \ __func__, __LINE__, \ (ANT_PATH_EXTERNAL == x) ? "EXTERNAL" : "INTERNAL", \ pwr0, pwr1, pwr2, pwr3) #define ANT_HUNT_SLEEP 90 #define ANT_EXT_TWEAK 0 static int mxl111sf_ant_hunt(struct dvb_frontend *fe) { struct dvb_usb_adapter *adap = fe->dvb->priv; struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; int antctrl = dvb_usb_mxl111sf_rfswitch; u16 rxPwrA, rxPwr0, rxPwr1, rxPwr2; /* FIXME: must force EXTERNAL for QAM - done elsewhere */ mxl111sf_set_ant_path(state, antctrl == ANT_PATH_AUTO ? ANT_PATH_EXTERNAL : antctrl); if (antctrl == ANT_PATH_AUTO) { #if 0 msleep(ANT_HUNT_SLEEP); #endif fe->ops.tuner_ops.get_rf_strength(fe, &rxPwrA); mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL); msleep(ANT_HUNT_SLEEP); fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr0); mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL); msleep(ANT_HUNT_SLEEP); fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr1); mxl111sf_set_ant_path(state, ANT_PATH_INTERNAL); msleep(ANT_HUNT_SLEEP); fe->ops.tuner_ops.get_rf_strength(fe, &rxPwr2); if (rxPwr1+ANT_EXT_TWEAK >= rxPwr2) { /* return with EXTERNAL enabled */ mxl111sf_set_ant_path(state, ANT_PATH_EXTERNAL); DbgAntHunt(ANT_PATH_EXTERNAL, rxPwrA, rxPwr0, rxPwr1, rxPwr2); } else { /* return with INTERNAL enabled */ DbgAntHunt(ANT_PATH_INTERNAL, rxPwrA, rxPwr0, rxPwr1, rxPwr2); } } return 0; } static struct mxl111sf_tuner_config mxl_tuner_config = { .if_freq = MXL_IF_6_0, /* applies to external IF output, only */ .invert_spectrum = 0, .read_reg = mxl111sf_read_reg, .write_reg = mxl111sf_write_reg, .program_regs = mxl111sf_ctrl_program_regs, .top_master_ctrl = mxl1x1sf_top_master_ctrl, .ant_hunt = mxl111sf_ant_hunt, }; static int mxl111sf_attach_tuner(struct dvb_usb_adapter *adap) { struct dvb_usb_device *d = adap->dev; struct mxl111sf_state *state = d->priv; int fe_id = adap->num_frontends_initialized; deb_adv("%s()\n", __func__); if (NULL != dvb_attach(mxl111sf_tuner_attach, adap->fe_adap[fe_id].fe, state, &mxl_tuner_config)) return 0; return -EIO; } static int mxl111sf_fe_ioctl_override(struct dvb_frontend *fe, unsigned int cmd, void *parg, unsigned int stage) { int err = 0; switch (stage) { case DVB_FE_IOCTL_PRE: switch (cmd) { case FE_READ_SIGNAL_STRENGTH: err = fe->ops.tuner_ops.get_rf_strength(fe, parg); /* If no error occurs, prevent dvb-core from handling * this IOCTL, otherwise return the error */ if (0 == err) err = 1; break; } break; case DVB_FE_IOCTL_POST: /* no post-ioctl handling required */ break; } return err; }; static u32 mxl111sf_i2c_func(struct i2c_adapter *adapter) { return I2C_FUNC_I2C; } struct i2c_algorithm mxl111sf_i2c_algo = { .master_xfer = mxl111sf_i2c_xfer, .functionality = mxl111sf_i2c_func, #ifdef NEED_ALGO_CONTROL .algo_control = dummy_algo_control, #endif }; static struct dvb_usb_device_properties mxl111sf_dvbt_bulk_properties; static struct dvb_usb_device_properties mxl111sf_dvbt_isoc_properties; static struct dvb_usb_device_properties mxl111sf_atsc_bulk_properties; static struct dvb_usb_device_properties mxl111sf_atsc_isoc_properties; static int mxl111sf_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct dvb_usb_device *d = NULL; deb_adv("%s()\n", __func__); if (((dvb_usb_mxl111sf_isoc) && (0 == dvb_usb_device_init(intf, &mxl111sf_dvbt_isoc_properties, THIS_MODULE, &d, adapter_nr) || 0 == dvb_usb_device_init(intf, &mxl111sf_atsc_isoc_properties, THIS_MODULE, &d, adapter_nr))) || 0 == dvb_usb_device_init(intf, &mxl111sf_dvbt_bulk_properties, THIS_MODULE, &d, adapter_nr) || 0 == dvb_usb_device_init(intf, &mxl111sf_atsc_bulk_properties, THIS_MODULE, &d, adapter_nr) || 0) { struct mxl111sf_state *state = d->priv; static u8 eeprom[256]; struct i2c_client c; int ret; ret = get_chip_info(state); if (mxl_fail(ret)) err("failed to get chip info during probe"); mutex_init(&state->fe_lock); if (state->chip_rev > MXL111SF_V6) mxl111sf_config_pin_mux_modes(state, PIN_MUX_TS_SPI_IN_MODE_1); c.adapter = &d->i2c_adap; c.addr = 0xa0 >> 1; ret = tveeprom_read(&c, eeprom, sizeof(eeprom)); if (mxl_fail(ret)) return 0; tveeprom_hauppauge_analog(&c, &state->tv, (0x84 == eeprom[0xa0]) ? eeprom + 0xa0 : eeprom + 0x80); #if 0 switch (state->tv.model) { case 117001: case 126001: case 138001: break; default: printk(KERN_WARNING "%s: warning: " "unknown hauppauge model #%d\n", __func__, state->tv.model); } #endif return 0; } err("Your device is not yet supported by this driver. " "See kernellabs.com for more info"); return -EINVAL; } static struct usb_device_id mxl111sf_table[] = { /* 0 */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc600) }, /* ATSC+ IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc601) }, /* ATSC */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc602) }, /* + */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc603) }, /* ATSC+ */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc604) }, /* DVBT */ /* 5 */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc609) }, /* ATSC IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60a) }, /* + IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60b) }, /* ATSC+ IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc60c) }, /* DVBT IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc653) }, /* ATSC+ */ /*10 */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc65b) }, /* ATSC+ IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb700) }, /* ATSC+ sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb701) }, /* ATSC sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb702) }, /* + sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb703) }, /* ATSC+ sw */ /*15 */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb704) }, /* DVBT sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb753) }, /* ATSC+ sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb763) }, /* ATSC+ no */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb764) }, /* DVBT no */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd853) }, /* ATSC+ sw */ /*20 */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd854) }, /* DVBT sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd863) }, /* ATSC+ no */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd864) }, /* DVBT no */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d3) }, /* ATSC+ sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8d4) }, /* DVBT sw */ /*25 */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e3) }, /* ATSC+ no */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8e4) }, /* DVBT no */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xd8ff) }, /* ATSC+ */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc612) }, /* + */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc613) }, /* ATSC+ */ /*30 */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61a) }, /* + IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xc61b) }, /* ATSC+ IR */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb757) }, /* ATSC+DVBT sw */ { USB_DEVICE(USB_VID_HAUPPAUGE, 0xb767) }, /* ATSC+DVBT no */ {} /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, mxl111sf_table); #define MXL111SF_EP4_BULK_STREAMING_CONFIG \ .streaming_ctrl = mxl111sf_ep4_streaming_ctrl, \ .stream = { \ .type = USB_BULK, \ .count = 5, \ .endpoint = 0x04, \ .u = { \ .bulk = { \ .buffersize = 8192, \ } \ } \ } /* FIXME: works for v6 but not v8 silicon */ #define MXL111SF_EP4_ISOC_STREAMING_CONFIG \ .streaming_ctrl = mxl111sf_ep4_streaming_ctrl, \ .stream = { \ .type = USB_ISOC, \ .count = 5, \ .endpoint = 0x04, \ .u = { \ .isoc = { \ .framesperurb = 96, \ /* FIXME: v6 SILICON: */ \ .framesize = 564, \ .interval = 1, \ } \ } \ } #define MXL111SF_EP6_BULK_STREAMING_CONFIG \ .streaming_ctrl = mxl111sf_ep6_streaming_ctrl, \ .stream = { \ .type = USB_BULK, \ .count = 5, \ .endpoint = 0x06, \ .u = { \ .bulk = { \ .buffersize = 8192, \ } \ } \ } /* FIXME */ #define MXL111SF_EP6_ISOC_STREAMING_CONFIG \ .streaming_ctrl = mxl111sf_ep6_streaming_ctrl, \ .stream = { \ .type = USB_ISOC, \ .count = 5, \ .endpoint = 0x06, \ .u = { \ .isoc = { \ .framesperurb = 24, \ .framesize = 3072, \ .interval = 1, \ } \ } \ } #define MXL111SF_DEFAULT_DEVICE_PROPERTIES \ .caps = DVB_USB_IS_AN_I2C_ADAPTER, \ .usb_ctrl = DEVICE_SPECIFIC, \ /* use usb alt setting 1 for EP4 ISOC transfer (dvb-t), \ EP6 BULK transfer (atsc/qam), \ use usb alt setting 2 for EP4 BULK transfer (dvb-t), \ EP6 ISOC transfer (atsc/qam), \ */ \ .power_ctrl = mxl111sf_power_ctrl, \ .i2c_algo = &mxl111sf_i2c_algo, \ .generic_bulk_ctrl_endpoint = MXL_EP2_REG_WRITE, \ .generic_bulk_ctrl_endpoint_response = MXL_EP1_REG_READ, \ .size_of_priv = sizeof(struct mxl111sf_state) static struct dvb_usb_device_properties mxl111sf_dvbt_bulk_properties = { MXL111SF_DEFAULT_DEVICE_PROPERTIES, .num_adapters = 1, .adapter = { { .fe_ioctl_override = mxl111sf_fe_ioctl_override, .num_frontends = 1, .fe = {{ .size_of_priv = sizeof(struct mxl111sf_adap_state), .frontend_attach = mxl111sf_attach_demod, .tuner_attach = mxl111sf_attach_tuner, MXL111SF_EP4_BULK_STREAMING_CONFIG, } }, }, }, .num_device_descs = 4, .devices = { { "Hauppauge 126xxx DVBT (bulk)", { NULL }, { &mxl111sf_table[4], &mxl111sf_table[8], NULL }, }, { "Hauppauge 117xxx DVBT (bulk)", { NULL }, { &mxl111sf_table[15], &mxl111sf_table[18], NULL }, }, { "Hauppauge 138xxx DVBT (bulk)", { NULL }, { &mxl111sf_table[20], &mxl111sf_table[22], &mxl111sf_table[24], &mxl111sf_table[26], NULL }, }, { "Hauppauge 126xxx (tp-bulk)", { NULL }, { &mxl111sf_table[28], &mxl111sf_table[30], NULL }, }, } }; static struct dvb_usb_device_properties mxl111sf_dvbt_isoc_properties = { MXL111SF_DEFAULT_DEVICE_PROPERTIES, .num_adapters = 1, .adapter = { { .fe_ioctl_override = mxl111sf_fe_ioctl_override, .num_frontends = 1, .fe = {{ .size_of_priv = sizeof(struct mxl111sf_adap_state), .frontend_attach = mxl111sf_attach_demod, .tuner_attach = mxl111sf_attach_tuner, MXL111SF_EP4_ISOC_STREAMING_CONFIG, } }, }, }, .num_device_descs = 4, .devices = { { "Hauppauge 126xxx DVBT (isoc)", { NULL }, { &mxl111sf_table[4], &mxl111sf_table[8], NULL }, }, { "Hauppauge 117xxx DVBT (isoc)", { NULL }, { &mxl111sf_table[15], &mxl111sf_table[18], NULL }, }, { "Hauppauge 138xxx DVBT (isoc)", { NULL }, { &mxl111sf_table[20], &mxl111sf_table[22], &mxl111sf_table[24], &mxl111sf_table[26], NULL }, }, { "Hauppauge 126xxx (tp-isoc)", { NULL }, { &mxl111sf_table[28], &mxl111sf_table[30], NULL }, }, } }; static struct dvb_usb_device_properties mxl111sf_atsc_bulk_properties = { MXL111SF_DEFAULT_DEVICE_PROPERTIES, .num_adapters = 1, .adapter = { { .fe_ioctl_override = mxl111sf_fe_ioctl_override, .num_frontends = 2, .fe = {{ .size_of_priv = sizeof(struct mxl111sf_adap_state), .frontend_attach = mxl111sf_lgdt3305_frontend_attach, .tuner_attach = mxl111sf_attach_tuner, MXL111SF_EP6_BULK_STREAMING_CONFIG, }, { .size_of_priv = sizeof(struct mxl111sf_adap_state), .frontend_attach = mxl111sf_attach_demod, .tuner_attach = mxl111sf_attach_tuner, MXL111SF_EP4_BULK_STREAMING_CONFIG, }}, }, }, .num_device_descs = 6, .devices = { { "Hauppauge 126xxx ATSC (bulk)", { NULL }, { &mxl111sf_table[1], &mxl111sf_table[5], NULL }, }, { "Hauppauge 117xxx ATSC (bulk)", { NULL }, { &mxl111sf_table[12], NULL }, }, { "Hauppauge 126xxx ATSC+ (bulk)", { NULL }, { &mxl111sf_table[0], &mxl111sf_table[3], &mxl111sf_table[7], &mxl111sf_table[9], &mxl111sf_table[10], NULL }, }, { "Hauppauge 117xxx ATSC+ (bulk)", { NULL }, { &mxl111sf_table[11], &mxl111sf_table[14], &mxl111sf_table[16], &mxl111sf_table[17], &mxl111sf_table[32], &mxl111sf_table[33], NULL }, }, { "Hauppauge Mercury (tp-bulk)", { NULL }, { &mxl111sf_table[19], &mxl111sf_table[21], &mxl111sf_table[23], &mxl111sf_table[25], &mxl111sf_table[27], NULL }, }, { "Hauppauge WinTV-Aero-M", { NULL }, { &mxl111sf_table[29], &mxl111sf_table[31], NULL }, }, } }; static struct dvb_usb_device_properties mxl111sf_atsc_isoc_properties = { MXL111SF_DEFAULT_DEVICE_PROPERTIES, .num_adapters = 1, .adapter = { { .fe_ioctl_override = mxl111sf_fe_ioctl_override, .num_frontends = 2, .fe = {{ .size_of_priv = sizeof(struct mxl111sf_adap_state), .frontend_attach = mxl111sf_lgdt3305_frontend_attach, .tuner_attach = mxl111sf_attach_tuner, MXL111SF_EP6_ISOC_STREAMING_CONFIG, }, { .size_of_priv = sizeof(struct mxl111sf_adap_state), .frontend_attach = mxl111sf_attach_demod, .tuner_attach = mxl111sf_attach_tuner, MXL111SF_EP4_ISOC_STREAMING_CONFIG, }}, }, }, .num_device_descs = 6, .devices = { { "Hauppauge 126xxx ATSC (isoc)", { NULL }, { &mxl111sf_table[1], &mxl111sf_table[5], NULL }, }, { "Hauppauge 117xxx ATSC (isoc)", { NULL }, { &mxl111sf_table[12], NULL }, }, { "Hauppauge 126xxx ATSC+ (isoc)", { NULL }, { &mxl111sf_table[0], &mxl111sf_table[3], &mxl111sf_table[7], &mxl111sf_table[9], &mxl111sf_table[10], NULL }, }, { "Hauppauge 117xxx ATSC+ (isoc)", { NULL }, { &mxl111sf_table[11], &mxl111sf_table[14], &mxl111sf_table[16], &mxl111sf_table[17], &mxl111sf_table[32], &mxl111sf_table[33], NULL }, }, { "Hauppauge Mercury (tp-isoc)", { NULL }, { &mxl111sf_table[19], &mxl111sf_table[21], &mxl111sf_table[23], &mxl111sf_table[25], &mxl111sf_table[27], NULL }, }, { "Hauppauge WinTV-Aero-M (tp-isoc)", { NULL }, { &mxl111sf_table[29], &mxl111sf_table[31], NULL }, }, } }; static struct usb_driver mxl111sf_driver = { .name = "dvb_usb_mxl111sf", .probe = mxl111sf_probe, .disconnect = dvb_usb_device_exit, .id_table = mxl111sf_table, }; static int __init mxl111sf_module_init(void) { int result = usb_register(&mxl111sf_driver); if (result) { err("usb_register failed. Error number %d", result); return result; } return 0; } static void __exit mxl111sf_module_exit(void) { usb_deregister(&mxl111sf_driver); } module_init(mxl111sf_module_init); module_exit(mxl111sf_module_exit); MODULE_AUTHOR("Michael Krufky "); MODULE_DESCRIPTION("Driver for MaxLinear MxL111SF"); MODULE_VERSION("1.0"); MODULE_LICENSE("GPL"); /* * Local variables: * c-basic-offset: 8 * End: */