static int
fxp_cardbus_detach(device_t self, int flags)
{
struct fxp_cardbus_softc *csc = device_private(self);
struct fxp_softc *sc = &csc->sc;
struct cardbus_devfunc *ct = csc->ct;
int rv, reg;
#ifdef DIAGNOSTIC
if (ct == NULL)
panic("%s: data structure lacks", device_xname(self));
#endif
rv = fxp_detach(sc);
if (rv == 0) {
/*
* Unhook the interrupt handler.
*/
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, sc->sc_ih);
/*
* release bus space and close window
*/
if (csc->base0_reg)
reg = CARDBUS_BASE0_REG;
else
reg = CARDBUS_BASE1_REG;
Cardbus_mapreg_unmap(ct, reg, sc->sc_st, sc->sc_sh, csc->size);
}
return (rv);
}
/*
* Cardbus detach function: deallocate all resources
*/
int
re_cardbus_detach(struct device *self, int flags)
{
struct re_cardbus_softc *csc = (void *)self;
struct rl_softc *sc = &csc->sc_rl;
struct cardbus_devfunc *ct = csc->ct;
struct ifnet *ifp = &sc->sc_arpcom.ac_if;
/* Remove timeout handler */
timeout_del(&sc->timer_handle);
/* Detach PHY */
if (LIST_FIRST(&sc->sc_mii.mii_phys) != NULL)
mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
/* Delete media stuff */
ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
ether_ifdetach(ifp);
if_detach(ifp);
/* Disable interrupts */
if (csc->sc_ih != NULL)
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih);
/* Free cardbus resources */
Cardbus_mapreg_unmap(ct, csc->sc_bar_reg, sc->rl_btag, sc->rl_bhandle,
csc->sc_mapsize);
return (0);
}
int
puc_cardbus_detach(struct device *self, int flags)
{
struct puc_cardbus_softc *sc = (struct puc_cardbus_softc *)self;
struct puc_softc *psc = &sc->sc_psc;
struct cardbus_devfunc *ct = sc->ct;
int i, rv;
for (i = PUC_MAX_PORTS; i--; ) {
if (psc->sc_ports[i].intrhand)
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf,
psc->sc_ports[i].intrhand);
if (psc->sc_ports[i].dev)
if ((rv = config_detach(psc->sc_ports[i].dev, flags)))
return (rv);
}
for (i = PUC_NBARS; i--; )
if (psc->sc_bar_mappings[i].mapped)
Cardbus_mapreg_unmap(ct, psc->sc_bar_mappings[i].type,
psc->sc_bar_mappings[i].t,
psc->sc_bar_mappings[i].h,
psc->sc_bar_mappings[i].s);
return (0);
}
int
ex_cardbus_detach(device_t self, int arg)
{
struct ex_cardbus_softc *csc = device_private(self);
struct ex_softc *sc = &csc->sc_softc;
struct cardbus_devfunc *ct = csc->sc_ct;
int rv;
#if defined(DIAGNOSTIC)
if (ct == NULL) {
panic("%s: data structure lacks", device_xname(self));
}
#endif
rv = ex_detach(sc);
if (rv == 0) {
/*
* Unhook the interrupt handler.
*/
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, sc->sc_ih);
if (csc->sc_cardtype == EX_CB_CYCLONE) {
Cardbus_mapreg_unmap(ct,
CARDBUS_3C575BTX_FUNCSTAT_PCIREG,
csc->sc_funct, csc->sc_funch, csc->sc_funcsize);
}
Cardbus_mapreg_unmap(ct, CARDBUS_BASE0_REG, sc->sc_iot,
sc->sc_ioh, csc->sc_mapsize);
}
return (rv);
}
int
pgt_cardbus_detach(struct device *self, int flags)
{
struct pgt_cardbus_softc *csc = (struct pgt_cardbus_softc *)self;
struct pgt_softc *sc = &csc->sc_pgt;
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
int error;
error = pgt_detach(sc);
if (error != 0)
return (error);
/* unhook the interrupt handler */
if (csc->sc_ih != NULL) {
cardbus_intr_disestablish(cc, cf, csc->sc_ih);
csc->sc_ih = NULL;
}
/* release bus space and close window */
Cardbus_mapreg_unmap(ct, CARDBUS_BASE0_REG,
sc->sc_iotag, sc->sc_iohandle, csc->sc_mapsize);
return (0);
}
int
re_cardbus_detach(device_t self, int flags)
{
struct re_cardbus_softc *csc = device_private(self);
struct rtk_softc *sc = &csc->sc_rtk;
struct cardbus_devfunc *ct = csc->sc_ct;
int rv;
#ifdef DIAGNOSTIC
if (ct == NULL)
panic("%s: cardbus softc, cardbus_devfunc NULL",
device_xname(self));
#endif
rv = re_detach(sc);
if (rv)
return rv;
pmf_device_deregister(self);
/*
* Unhook the interrupt handler.
*/
if (csc->sc_ih != NULL)
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih);
/*
* Release bus space and close window.
*/
if (csc->sc_bar_reg != 0)
Cardbus_mapreg_unmap(ct, csc->sc_bar_reg,
sc->rtk_btag, sc->rtk_bhandle, csc->sc_mapsize);
return 0;
}
int
rtw_cardbus_detach(struct device *self, int flags)
{
struct rtw_cardbus_softc *csc = (void *)self;
struct rtw_softc *sc = &csc->sc_rtw;
struct rtw_regs *regs = &sc->sc_regs;
struct cardbus_devfunc *ct = csc->sc_ct;
int rv;
#if defined(DIAGNOSTIC)
if (ct == NULL)
panic("%s: data structure lacks", sc->sc_dev.dv_xname);
#endif
rv = rtw_detach(sc);
if (rv)
return (rv);
rtw_cardbus_funcregen(regs, 0);
/*
* Unhook the interrupt handler.
*/
if (csc->sc_ih != NULL)
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih);
/*
* Release bus space and close window.
*/
if (csc->sc_bar_reg != 0)
Cardbus_mapreg_unmap(ct, csc->sc_bar_reg,
regs->r_bt, regs->r_bh, csc->sc_mapsize);
return (0);
}
/*
* Attach the interface. Allocate softc structures, do ifmedia
* setup and ethernet/BPF attach.
*/
void
re_cardbus_attach(struct device *parent, struct device *self, void *aux)
{
struct re_cardbus_softc *csc = (struct re_cardbus_softc *)self;
struct rl_softc *sc = &csc->sc_rl;
struct cardbus_attach_args *ca = aux;
struct cardbus_softc *psc =
(struct cardbus_softc *)sc->sc_dev.dv_parent;
cardbus_chipset_tag_t cc = psc->sc_cc;
cardbus_function_tag_t cf = psc->sc_cf;
cardbus_devfunc_t ct = ca->ca_ct;
bus_addr_t adr;
char intrstr[16];
sc->sc_dmat = ca->ca_dmat;
csc->ct = ct;
csc->sc_tag = ca->ca_tag;
csc->sc_pc = ca->ca_pc;
csc->sc_intrline = ca->ca_intrline;
/*
* Map control/status registers.
*/
if (Cardbus_mapreg_map(ct, RL_PCI_LOMEM, PCI_MAPREG_TYPE_MEM, 0,
&sc->rl_btag, &sc->rl_bhandle, &adr, &csc->sc_mapsize) == 0) {
csc->sc_cben = CARDBUS_MEM_ENABLE;
csc->sc_csr |= PCI_COMMAND_MEM_ENABLE;
csc->sc_bar_reg = RL_PCI_LOMEM;
csc->sc_bar_val = adr | PCI_MAPREG_TYPE_MEM;
} else {
printf(": can't map mem space\n");
return;
}
/* Enable power */
Cardbus_function_enable(ct);
/* Get chip out of powersave mode (if applicable), initialize
* config registers */
re_cardbus_setup(sc);
/* Allocate interrupt */
csc->sc_ih = cardbus_intr_establish(cc, cf, csc->sc_intrline,
IPL_NET, re_intr, sc, sc->sc_dev.dv_xname);
if (csc->sc_ih == NULL) {
printf(": couldn't establish interrupt at %d",
ca->ca_intrline);
Cardbus_function_disable(csc->ct);
return;
}
snprintf(intrstr, sizeof(intrstr), "irq %d", ca->ca_intrline);
/* Call bus-independent (common) attach routine */
if (re_attach(sc, intrstr)) {
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih);
Cardbus_mapreg_unmap(ct, csc->sc_bar_reg, sc->rl_btag,
sc->rl_bhandle, csc->sc_mapsize);
}
}
void
com_cardbus_disable(struct com_softc *sc)
{
struct com_cardbus_softc *csc = (struct com_cardbus_softc*)sc;
struct cardbus_softc *psc =
(struct cardbus_softc *)sc->sc_dev.dv_parent;
cardbus_chipset_tag_t cc = psc->sc_cc;
cardbus_function_tag_t cf = psc->sc_cf;
cardbus_intr_disestablish(cc, cf, csc->cc_ih);
Cardbus_function_disable(csc->cc_ct);
}
static void
fxp_cardbus_disable(struct fxp_softc * sc)
{
struct fxp_cardbus_softc *csc = (struct fxp_cardbus_softc *)sc;
struct cardbus_softc *psc = device_private(device_parent(sc->sc_dev));
cardbus_chipset_tag_t cc = psc->sc_cc;
cardbus_function_tag_t cf = psc->sc_cf;
/* Remove interrupt handler. */
cardbus_intr_disestablish(cc, cf, sc->sc_ih);
Cardbus_function_disable(csc->ct);
}
static bool
ath_cardbus_suspend(device_t self PMF_FN_ARGS)
{
struct ath_cardbus_softc *csc = device_private(self);
ath_suspend(&csc->sc_ath);
if (csc->sc_ih != NULL) {
cardbus_intr_disestablish(csc->sc_ct->ct_cc, csc->sc_ct->ct_cf,
csc->sc_ih);
csc->sc_ih = NULL;
}
return true;
}
void
ex_cardbus_disable(struct ex_softc *sc)
{
struct ex_cardbus_softc *csc = (struct ex_cardbus_softc *)sc;
cardbus_function_tag_t cf = csc->sc_ct->ct_cf;
cardbus_chipset_tag_t cc = csc->sc_ct->ct_cc;
cardbus_intr_disestablish(cc, cf, sc->sc_ih);
sc->sc_ih = NULL;
Cardbus_function_disable(csc->sc_ct);
}
void
re_cardbus_disable(struct rtk_softc *sc)
{
struct re_cardbus_softc *csc = (struct re_cardbus_softc *)sc;
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
/* Unhook the interrupt handler. */
cardbus_intr_disestablish(cc, cf, csc->sc_ih);
csc->sc_ih = NULL;
/* Power down the socket. */
Cardbus_function_disable(ct);
}
int
dc_cardbus_detach(struct device *self, int flags)
{
struct dc_cardbus_softc *csc = (struct dc_cardbus_softc *)self;
struct dc_softc *sc = &csc->sc_dc;
struct cardbus_devfunc *ct = csc->sc_ct;
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, sc->sc_ih);
dc_detach(sc);
/* unmap cardbus resources */
Cardbus_mapreg_unmap(ct,
csc->sc_actype == CARDBUS_IO_ENABLE ? PCI_CBIO : PCI_CBMEM,
sc->dc_btag, sc->dc_bhandle, csc->sc_mapsize);
return (0);
}
int
com_cardbus_detach(struct device *self, int flags)
{
struct com_cardbus_softc *csc = (struct com_cardbus_softc *) self;
struct com_softc *sc = (struct com_softc *) self;
struct cardbus_softc *psc = (struct cardbus_softc *)self->dv_parent;
int error;
if ((error = com_detach(self, flags)) != 0)
return (error);
cardbus_intr_disestablish(psc->sc_cc, psc->sc_cf, csc->cc_ih);
Cardbus_mapreg_unmap(csc->cc_ct, csc->cc_reg, sc->sc_iot, sc->sc_ioh,
csc->cc_size);
return (0);
}
void
rtw_cardbus_disable(struct rtw_softc *sc)
{
struct rtw_cardbus_softc *csc = (void *) sc;
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
RTW_WRITE(&sc->sc_regs, RTW_FEMR,
RTW_READ(&sc->sc_regs, RTW_FEMR) & ~RTW_FEMR_INTR);
rtw_cardbus_funcregen(&sc->sc_regs, 0);
/* Unhook the interrupt handler. */
cardbus_intr_disestablish(cc, cf, csc->sc_ih);
csc->sc_ih = NULL;
/* Power down the socket. */
Cardbus_function_disable(ct);
}
int
athn_cardbus_detach(struct device *self, int flags)
{
struct athn_cardbus_softc *csc = (struct athn_cardbus_softc *)self;
struct athn_softc *sc = &csc->sc_sc;
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
athn_detach(sc);
/* Unhook the interrupt handler. */
if (csc->sc_ih != NULL)
cardbus_intr_disestablish(cc, cf, csc->sc_ih);
/* Release bus space and close window. */
Cardbus_mapreg_unmap(ct, CARDBUS_BASE0_REG, csc->sc_st, csc->sc_sh,
csc->sc_mapsize);
return (0);
}
int
ehci_cardbus_detach(struct device *self, int flags)
{
struct ehci_cardbus_softc *sc = (struct ehci_cardbus_softc *)self;
struct cardbus_devfunc *ct = sc->sc_ct;
int rv;
rv = ehci_detach(self, flags);
if (rv)
return (rv);
if (sc->sc_ih != NULL) {
cardbus_intr_disestablish(sc->sc_cc, sc->sc_cf, sc->sc_ih);
sc->sc_ih = NULL;
}
if (sc->sc.sc_size) {
Cardbus_mapreg_unmap(ct, CARDBUS_CBMEM, sc->sc.iot,
sc->sc.ioh, sc->sc.sc_size);
sc->sc.sc_size = 0;
}
return (0);
}
int
ath_cardbus_detach(device_t self, int flags)
{
struct ath_cardbus_softc *csc = device_private(self);
struct ath_softc *sc = &csc->sc_ath;
struct cardbus_devfunc *ct = csc->sc_ct;
int rv;
#if defined(DIAGNOSTIC)
if (ct == NULL)
panic("%s: data structure lacks", device_xname(sc->sc_dev));
#endif
rv = ath_detach(sc);
if (rv)
return (rv);
pmf_device_deregister(self);
/*
* Unhook the interrupt handler.
*/
if (csc->sc_ih != NULL) {
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih);
csc->sc_ih = NULL;
}
/*
* Release bus space and close window.
*/
Cardbus_mapreg_unmap(ct, ATH_PCI_MMBA, csc->sc_iot, csc->sc_ioh,
csc->sc_mapsize);
ATH_LOCK_DESTROY(sc);
return (0);
}
static int
njs_cardbus_detach(struct device *self, int flags)
{
struct njsc32_cardbus_softc *csc = (void *) self;
struct njsc32_softc *sc = &csc->sc_njsc32;
int rv;
rv = njsc32_detach(sc, flags);
if (rv)
return rv;
if (sc->sc_ih)
cardbus_intr_disestablish(csc->sc_ct->ct_cc,
csc->sc_ct->ct_cf, sc->sc_ih);
if (sc->sc_flags & NJSC32_IO_MAPPED)
Cardbus_mapreg_unmap(csc->sc_ct, NJSC32_CARDBUS_BASEADDR_IO,
sc->sc_regt, sc->sc_regh, csc->sc_regmap_size);
if (sc->sc_flags & NJSC32_MEM_MAPPED)
Cardbus_mapreg_unmap(csc->sc_ct, NJSC32_CARDBUS_BASEADDR_MEM,
sc->sc_regt, csc->sc_regmaph, csc->sc_regmap_size);
return 0;
}
static int
uhci_cardbus_detach(device_t self, int flags)
{
struct uhci_cardbus_softc *sc = device_private(self);
struct cardbus_devfunc *ct = sc->sc_ct;
int rv;
rv = uhci_detach(&sc->sc, flags);
if (rv)
return (rv);
if (sc->sc_ih != NULL) {
cardbus_intr_disestablish(sc->sc_cc, sc->sc_cf, sc->sc_ih);
sc->sc_ih = NULL;
}
if (sc->sc.sc_size) {
Cardbus_mapreg_unmap(ct, CARDBUS_CBIO, sc->sc.iot,
sc->sc.ioh, sc->sc.sc_size);
sc->sc.sc_size = 0;
}
#if NEHCI_CARDBUS > 0
usb_cardbus_rem(&sc->sc_cardbus);
#endif
return (0);
}
void
ehci_cardbus_attach(struct device *parent, struct device *self, void *aux)
{
struct ehci_cardbus_softc *sc = (struct ehci_cardbus_softc *)self;
struct cardbus_attach_args *ca = aux;
cardbus_devfunc_t ct = ca->ca_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
pci_chipset_tag_t pc = ca->ca_pc;
cardbus_function_tag_t cf = ct->ct_cf;
pcireg_t csr;
usbd_status r;
const char *vendor;
const char *devname = sc->sc.sc_bus.bdev.dv_xname;
/* Map I/O registers */
if (Cardbus_mapreg_map(ct, CARDBUS_CBMEM, PCI_MAPREG_TYPE_MEM, 0,
&sc->sc.iot, &sc->sc.ioh, NULL, &sc->sc.sc_size)) {
printf(": can't map mem space\n");
return;
}
sc->sc_cc = cc;
sc->sc_cf = cf;
sc->sc_ct = ct;
sc->sc.sc_bus.dmatag = ca->ca_dmat;
(ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_MEM_ENABLE);
(ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_BM_ENABLE);
/* Enable the device. */
csr = pci_conf_read(pc, ca->ca_tag,
PCI_COMMAND_STATUS_REG);
pci_conf_write(pc, ca->ca_tag, PCI_COMMAND_STATUS_REG,
csr | PCI_COMMAND_MASTER_ENABLE
| PCI_COMMAND_MEM_ENABLE);
/* Disable interrupts, so we don't get any spurious ones. */
sc->sc.sc_offs = EREAD1(&sc->sc, EHCI_CAPLENGTH);
EOWRITE2(&sc->sc, EHCI_USBINTR, 0);
sc->sc_ih = cardbus_intr_establish(cc, cf, ca->ca_intrline,
IPL_USB, ehci_intr, sc, devname);
if (sc->sc_ih == NULL) {
printf(": unable to establish interrupt\n");
return;
}
printf(": irq %d\n", ca->ca_intrline);
/* Figure out vendor for root hub descriptor. */
vendor = cardbus_findvendor(ca->ca_id);
sc->sc.sc_id_vendor = PCI_VENDOR(ca->ca_id);
if (vendor)
strlcpy(sc->sc.sc_vendor, vendor, sizeof(sc->sc.sc_vendor));
else
snprintf(sc->sc.sc_vendor, sizeof(sc->sc.sc_vendor),
"vendor 0x%04x", PCI_VENDOR(ca->ca_id));
r = ehci_init(&sc->sc);
if (r != USBD_NORMAL_COMPLETION) {
printf("%s: init failed, error=%d\n", devname, r);
/* Avoid spurious interrupts. */
cardbus_intr_disestablish(sc->sc_cc, sc->sc_cf, sc->sc_ih);
sc->sc_ih = NULL;
return;
}
/* Attach usb device. */
config_found(self, &sc->sc.sc_bus, usbctlprint);
}
static void
uhci_cardbus_attach(device_t parent, device_t self,
void *aux)
{
struct uhci_cardbus_softc *sc = device_private(self);
struct cardbus_attach_args *ca = (struct cardbus_attach_args *)aux;
cardbus_devfunc_t ct = ca->ca_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
cardbustag_t tag = ca->ca_tag;
cardbusreg_t csr;
const char *vendor;
const char *devname = device_xname(self);
char devinfo[256];
usbd_status r;
sc->sc.sc_dev = self;
sc->sc.sc_bus.hci_private = sc;
cardbus_devinfo(ca->ca_id, ca->ca_class, 0, devinfo, sizeof(devinfo));
printf(": %s (rev. 0x%02x)\n", devinfo, CARDBUS_REVISION(ca->ca_class));
/* Map I/O registers */
if (Cardbus_mapreg_map(ct, CARDBUS_CBIO, CARDBUS_MAPREG_TYPE_IO, 0,
&sc->sc.iot, &sc->sc.ioh, NULL, &sc->sc.sc_size)) {
printf("%s: can't map i/o space\n", devname);
return;
}
sc->sc_cc = cc;
sc->sc_cf = cf;
sc->sc_ct = ct;
sc->sc_tag = tag;
sc->sc.sc_bus.dmatag = ca->ca_dmat;
#if rbus
#else
XXX (ct->ct_cf->cardbus_io_open)(cc, 0, iob, iob + 0x40);
#endif
(ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_IO_ENABLE);
(ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_BM_ENABLE);
/* Enable the device. */
csr = cardbus_conf_read(cc, cf, tag, CARDBUS_COMMAND_STATUS_REG);
cardbus_conf_write(cc, cf, tag, CARDBUS_COMMAND_STATUS_REG,
csr | CARDBUS_COMMAND_MASTER_ENABLE
| CARDBUS_COMMAND_IO_ENABLE);
/* Disable interrupts, so we don't get any spurious ones. */
bus_space_write_2(sc->sc.iot, sc->sc.ioh, UHCI_INTR, 0);
/* Map and establish the interrupt. */
sc->sc_ih = cardbus_intr_establish(cc, cf, ca->ca_intrline,
IPL_USB, uhci_intr, sc);
if (sc->sc_ih == NULL) {
printf("%s: couldn't establish interrupt\n", devname);
return;
}
/* Set LEGSUP register to its default value. */
cardbus_conf_write(cc, cf, tag, PCI_LEGSUP, PCI_LEGSUP_USBPIRQDEN);
switch(cardbus_conf_read(cc, cf, tag, PCI_USBREV) & PCI_USBREV_MASK) {
case PCI_USBREV_PRE_1_0:
sc->sc.sc_bus.usbrev = USBREV_PRE_1_0;
break;
case PCI_USBREV_1_0:
sc->sc.sc_bus.usbrev = USBREV_1_0;
break;
case PCI_USBREV_1_1:
sc->sc.sc_bus.usbrev = USBREV_1_1;
break;
default:
sc->sc.sc_bus.usbrev = USBREV_UNKNOWN;
break;
}
/* Figure out vendor for root hub descriptor. */
vendor = cardbus_findvendor(ca->ca_id);
sc->sc.sc_id_vendor = CARDBUS_VENDOR(ca->ca_id);
if (vendor)
strlcpy(sc->sc.sc_vendor, vendor, sizeof(sc->sc.sc_vendor));
else
snprintf(sc->sc.sc_vendor, sizeof(sc->sc.sc_vendor),
"vendor 0x%04x", CARDBUS_VENDOR(ca->ca_id));
r = uhci_init(&sc->sc);
if (r != USBD_NORMAL_COMPLETION) {
printf("%s: init failed, error=%d\n", devname, r);
/* Avoid spurious interrupts. */
cardbus_intr_disestablish(sc->sc_cc, sc->sc_cf, sc->sc_ih);
sc->sc_ih = NULL;
return;
}
#if NEHCI_CARDBUS > 0
usb_cardbus_add(&sc->sc_cardbus, ca, self);
#endif
/* Attach usb device. */
sc->sc.sc_child = config_found(self, &sc->sc.sc_bus, usbctlprint);
}