/* * Detach the driver from the hardware and other systems in the kernel. */ int ed_detach(device_t dev) { struct ed_softc *sc = device_get_softc(dev); struct ifnet *ifp = sc->ifp; if (mtx_initialized(ED_MUTEX(sc))) ED_ASSERT_UNLOCKED(sc); if (ifp) { ED_LOCK(sc); if (bus_child_present(dev)) ed_stop(sc); ifp->if_drv_flags &= ~IFF_DRV_RUNNING; ED_UNLOCK(sc); ether_ifdetach(ifp); callout_drain(&sc->tick_ch); } if (sc->irq_res != NULL && sc->irq_handle) bus_teardown_intr(dev, sc->irq_res, sc->irq_handle); ed_release_resources(dev); if (sc->miibus) device_delete_child(dev, sc->miibus); if (mtx_initialized(ED_MUTEX(sc))) ED_LOCK_DESTROY(sc); bus_generic_detach(dev); return (0); }
static void free_tid_tabs(struct tid_info *t) { if (mtx_initialized(&t->stid_lock)) mtx_destroy(&t->stid_lock); if (mtx_initialized(&t->atid_lock)) mtx_destroy(&t->atid_lock); free(t->tid_tab, M_CXGB); }
void platform_late_init(void) { bus_addr_t reg_baddr; uint32_t val; if (!mtx_initialized(&al_dbg_lock)) mtx_init(&al_dbg_lock, "ALDBG", "ALDBG", MTX_SPIN); /* configure system fabric */ if (bus_space_map(fdtbus_bs_tag, al_devmap_pa, al_devmap_size, 0, ®_baddr)) panic("Couldn't map Register Space area"); /* do not allow reads to bypass writes to different addresses */ val = bus_space_read_4(fdtbus_bs_tag, reg_baddr, AL_NB_SERVICE_OFFSET + AL_NB_ACF_MISC_OFFSET); val &= ~AL_NB_ACF_MISC_READ_BYPASS; bus_space_write_4(fdtbus_bs_tag, reg_baddr, AL_NB_SERVICE_OFFSET + AL_NB_ACF_MISC_OFFSET, val); /* enable cache snoop */ bus_space_write_4(fdtbus_bs_tag, reg_baddr, AL_NB_CCU_OFFSET + AL_CCU_SNOOP_CONTROL_IOFAB_0_OFFSET, 1); bus_space_write_4(fdtbus_bs_tag, reg_baddr, AL_NB_CCU_OFFSET + AL_CCU_SNOOP_CONTROL_IOFAB_1_OFFSET, 1); /* disable speculative fetches from masters */ bus_space_write_4(fdtbus_bs_tag, reg_baddr, AL_NB_CCU_OFFSET + AL_CCU_SPECULATION_CONTROL_OFFSET, 7); bus_space_unmap(fdtbus_bs_tag, reg_baddr, al_devmap_size); }
/* clean up so we can unload the driver. */ int ips_adapter_free(ips_softc_t *sc) { int error = 0; intrmask_t mask; if(sc->state & IPS_DEV_OPEN) return EBUSY; if((error = ips_diskdev_free(sc))) return error; if(ips_cmdqueue_free(sc)){ device_printf(sc->dev, "trying to exit when command queue is not empty!\n"); return EBUSY; } DEVICE_PRINTF(1, sc->dev, "free\n"); mask = splbio(); untimeout(ips_timeout, sc, sc->timer); splx(mask); if (mtx_initialized(&sc->cmd_mtx)) mtx_destroy(&sc->cmd_mtx); if(sc->sg_dmatag) bus_dma_tag_destroy(sc->sg_dmatag); if(sc->command_dmatag) bus_dma_tag_destroy(sc->command_dmatag); if(sc->device_file) destroy_dev(sc->device_file); return 0; }
/** * ti_gpio_detach - detach function for the driver * @dev: scm device handle * * Allocates and sets up the driver context, this simply entails creating a * bus mappings for the SCM register set. * * LOCKING: * None * * RETURNS: * Always returns 0 */ static int ti_gpio_detach(device_t dev) { struct ti_gpio_softc *sc = device_get_softc(dev); unsigned int i; KASSERT(mtx_initialized(&sc->sc_mtx), ("gpio mutex not initialized")); /* Disable all interrupts */ for (i = 0; i < MAX_GPIO_BANKS; i++) { if (sc->sc_mem_res[i] != NULL) { ti_gpio_write_4(sc, i, TI_GPIO_CLEARIRQENABLE1, 0xffffffff); ti_gpio_write_4(sc, i, TI_GPIO_CLEARIRQENABLE2, 0xffffffff); } } bus_generic_detach(dev); /* Release the memory and IRQ resources */ for (i = 0; i < MAX_GPIO_BANKS; i++) { if (sc->sc_mem_res[i] != NULL) bus_release_resource(dev, SYS_RES_MEMORY, i, sc->sc_mem_res[i]); if (sc->sc_irq_res[i] != NULL) bus_release_resource(dev, SYS_RES_IRQ, i, sc->sc_irq_res[i]); } TI_GPIO_LOCK_DESTROY(sc); return (0); }
/** * ti_gpio_detach - detach function for the driver * @dev: scm device handle * * Allocates and sets up the driver context, this simply entails creating a * bus mappings for the SCM register set. * * LOCKING: * None * * RETURNS: * Always returns 0 */ static int ti_gpio_detach(device_t dev) { struct ti_gpio_softc *sc = device_get_softc(dev); unsigned int i; KASSERT(mtx_initialized(&sc->sc_mtx), ("gpio mutex not initialized")); /* Disable all interrupts */ for (i = 0; i < MAX_GPIO_BANKS; i++) { if (sc->sc_mem_res[i] != NULL) ti_gpio_intr_clr(sc, i, 0xffffffff); } bus_generic_detach(dev); /* Release the memory and IRQ resources. */ ti_gpio_detach_intr(dev); bus_release_resources(dev, ti_gpio_irq_spec, sc->sc_irq_res); bus_release_resources(dev, ti_gpio_mem_spec, sc->sc_mem_res); TI_GPIO_LOCK_DESTROY(sc); return (0); }
/** * ti_gpio_detach - detach function for the driver * @dev: scm device handle * * Allocates and sets up the driver context, this simply entails creating a * bus mappings for the SCM register set. * * LOCKING: * None * * RETURNS: * Always returns 0 */ static int ti_gpio_detach(device_t dev) { struct ti_gpio_softc *sc = device_get_softc(dev); KASSERT(mtx_initialized(&sc->sc_mtx), ("gpio mutex not initialized")); /* Disable all interrupts */ if (sc->sc_mem_res != NULL) ti_gpio_intr_clr(sc, 0xffffffff); gpiobus_detach_bus(dev); if (sc->sc_isrcs != NULL) ti_gpio_pic_detach(sc); /* Release the memory and IRQ resources. */ if (sc->sc_irq_hdl) { bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_hdl); } bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irq_rid, sc->sc_irq_res); bus_release_resource(dev, SYS_RES_MEMORY, sc->sc_mem_rid, sc->sc_mem_res); TI_GPIO_LOCK_DESTROY(sc); return (0); }
/* -------------------------------------------------------------------------- * * Bus * */ static int tegra_gpio_detach(device_t dev) { struct tegra_gpio_softc *sc; int i; sc = device_get_softc(dev); KASSERT(mtx_initialized(&sc->mtx), ("gpio mutex not initialized")); for (i = 0; i < GPIO_NUM_BANKS; i++) { if (sc->irq_ih[i] != NULL) bus_teardown_intr(dev, sc->irq_res[i], sc->irq_ih[i]); } if (sc->isrcs != NULL) tegra_gpio_pic_detach(sc); gpiobus_detach_bus(dev); for (i = 0; i < GPIO_NUM_BANKS; i++) { if (sc->irq_res[i] != NULL) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res[i]); } if (sc->mem_res != NULL) bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res); GPIO_LOCK_DESTROY(sc); return(0); }
static void ofw_real_bounce_alloc(void *junk) { /* * Check that ofw_real is actually in use before allocating wads * of memory. Do this by checking if our mutex has been set up. */ if (!mtx_initialized(&of_bounce_mtx)) return; /* * Allocate a page of contiguous, wired physical memory that can * fit into a 32-bit address space and accessed from real mode. */ mtx_lock(&of_bounce_mtx); of_bounce_virt = contigmalloc(4 * PAGE_SIZE, M_OFWREAL, 0, 0, ulmin(platform_real_maxaddr(), BUS_SPACE_MAXADDR_32BIT), PAGE_SIZE, 4 * PAGE_SIZE); of_bounce_phys = vtophys(of_bounce_virt); of_bounce_size = 4 * PAGE_SIZE; /* * For virtual-mode OF, direct map this physical address so that * we have a 32-bit virtual address to give OF. */ if (!ofw_real_mode && !hw_direct_map) pmap_kenter(of_bounce_phys, of_bounce_phys); mtx_unlock(&of_bounce_mtx); }
void pdq_free (device_t dev) { pdq_softc_t *sc; sc = device_get_softc(dev); if (sc->io) bus_release_resource(dev, sc->io_type, sc->io_rid, sc->io); if (sc->mem) bus_release_resource(dev, sc->mem_type, sc->mem_rid, sc->mem); if (sc->irq_ih) bus_teardown_intr(dev, sc->irq, sc->irq_ih); if (sc->irq) bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq); if (sc->ifp) if_free(sc->ifp); /* * Destroy the mutex. */ if (mtx_initialized(&sc->mtx) != 0) { mtx_destroy(&sc->mtx); } return; }
/* * Since this is not a self-enumerating bus, and since we always add * children in attach, we have to always delete children here. */ static int gpiobus_detach(device_t dev) { struct gpiobus_softc *sc; struct gpiobus_ivar *devi; device_t *devlist; int i, err, ndevs; sc = GPIOBUS_SOFTC(dev); KASSERT(mtx_initialized(&sc->sc_mtx), ("gpiobus mutex not initialized")); GPIOBUS_LOCK_DESTROY(sc); if ((err = bus_generic_detach(dev)) != 0) return (err); if ((err = device_get_children(dev, &devlist, &ndevs)) != 0) return (err); for (i = 0; i < ndevs; i++) { device_delete_child(dev, devlist[i]); devi = GPIOBUS_IVAR(devlist[i]); if (devi->pins) { free(devi->pins, M_DEVBUF); devi->pins = NULL; } } free(devlist, M_TEMP); if (sc->sc_pins_mapped) { free(sc->sc_pins_mapped, M_DEVBUF); sc->sc_pins_mapped = NULL; } return (0); }
void qlnx_rdma_deinit(void) { if (mtx_initialized(&qlnx_rdma_dev_lock) && (qlnx_host_list == NULL)) { mtx_destroy(&qlnx_rdma_dev_lock); } return; }
void qlnx_rdma_init(void) { if (!mtx_initialized(&qlnx_rdma_dev_lock)) { mtx_init(&qlnx_rdma_dev_lock, "qlnx_rdma_dev_lock", NULL, MTX_DEF); } return; }
static int kr_detach(device_t dev) { struct kr_softc *sc = device_get_softc(dev); struct ifnet *ifp = sc->kr_ifp; KASSERT(mtx_initialized(&sc->kr_mtx), ("vr mutex not initialized")); /* These should only be active if attach succeeded */ if (device_is_attached(dev)) { KR_LOCK(sc); sc->kr_detach = 1; kr_stop(sc); KR_UNLOCK(sc); taskqueue_drain(taskqueue_swi, &sc->kr_link_task); ether_ifdetach(ifp); } if (sc->kr_miibus) device_delete_child(dev, sc->kr_miibus); bus_generic_detach(dev); if (sc->kr_rx_intrhand) bus_teardown_intr(dev, sc->kr_rx_irq, sc->kr_rx_intrhand); if (sc->kr_rx_irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->kr_rx_irq); if (sc->kr_tx_intrhand) bus_teardown_intr(dev, sc->kr_tx_irq, sc->kr_tx_intrhand); if (sc->kr_tx_irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->kr_tx_irq); if (sc->kr_rx_und_intrhand) bus_teardown_intr(dev, sc->kr_rx_und_irq, sc->kr_rx_und_intrhand); if (sc->kr_rx_und_irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->kr_rx_und_irq); if (sc->kr_tx_ovr_intrhand) bus_teardown_intr(dev, sc->kr_tx_ovr_irq, sc->kr_tx_ovr_intrhand); if (sc->kr_tx_ovr_irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->kr_tx_ovr_irq); if (sc->kr_res) bus_release_resource(dev, SYS_RES_MEMORY, sc->kr_rid, sc->kr_res); if (ifp) if_free(ifp); kr_dma_free(sc); mtx_destroy(&sc->kr_mtx); return (0); }
static void free_tom_data(struct tom_data *td) { KASSERT(TAILQ_EMPTY(&td->toep_list), ("%s: toep_list not empty", __func__)); if (td->listen_mask != 0) hashdestroy(td->listen_hash, M_CXGB, td->listen_mask); if (mtx_initialized(&td->toep_list_lock)) mtx_destroy(&td->toep_list_lock); if (mtx_initialized(&td->lctx_hash_lock)) mtx_destroy(&td->lctx_hash_lock); if (mtx_initialized(&td->tid_release_lock)) mtx_destroy(&td->tid_release_lock); if (td->l2t) t3_free_l2t(td->l2t); free_tid_tabs(&td->tid_maps); free(td, M_CXGB); }
void alpine_serdes_eth_group_unlock(uint32_t group) { struct alpine_serdes_eth_group_mode *group_mode; group_mode = &alpine_serdes_eth_group_mode[group]; if (mtx_initialized(&group_mode->lock) == 0) return; mtx_unlock(&group_mode->lock); }
static int cambria_gpio_detach(device_t dev) { struct cambria_gpio_softc *sc = device_get_softc(dev); KASSERT(mtx_initialized(&sc->sc_mtx), ("gpio mutex not initialized")); bus_generic_detach(dev); mtx_destroy(&sc->sc_mtx); return(0); }
int mc146818_attach(device_t dev) { struct mc146818_softc *sc; sc = device_get_softc(dev); if (mtx_initialized(&sc->sc_mtx) == 0) { device_printf(dev, "%s: mutex not initialized\n", __func__); return (ENXIO); } if (sc->sc_mcread == NULL) sc->sc_mcread = mc146818_def_read; if (sc->sc_mcwrite == NULL) sc->sc_mcwrite = mc146818_def_write; if (sc->sc_flag & MC146818_NO_CENT_ADJUST) { /* * Note that setting MC146818_NO_CENT_ADJUST means that * the century has to be stored in NVRAM somewhere. */ if (sc->sc_getcent == NULL) sc->sc_getcent = mc146818_def_getcent; if (sc->sc_setcent == NULL) sc->sc_setcent = mc146818_def_setcent; } mtx_lock_spin(&sc->sc_mtx); if (!(*sc->sc_mcread)(dev, MC_REGD) & MC_REGD_VRT) { mtx_unlock_spin(&sc->sc_mtx); device_printf(dev, "%s: battery low\n", __func__); return (ENXIO); } sc->sc_rega = MC_BASE_32_KHz; (*sc->sc_mcwrite)(dev, MC_REGA, sc->sc_rega); sc->sc_regb = 0; sc->sc_regb |= (sc->sc_flag & MC146818_BCD) ? 0 : MC_REGB_BINARY; sc->sc_regb |= (sc->sc_flag & MC146818_12HR) ? 0 : MC_REGB_24HR; (*sc->sc_mcwrite)(dev, MC_REGB, sc->sc_regb); mtx_unlock_spin(&sc->sc_mtx); clock_register(dev, 1000000); /* 1 second resolution. */ return (0); }
int qlnx_rdma_deregister_if(qlnx_rdma_if_t *rdma_if) { int ret = 0; qlnx_host_t *ha; printf("%s: enter rdma_if = %p\n", __func__, rdma_if); if (mtx_initialized(&qlnx_rdma_dev_lock)) { mtx_lock(&qlnx_rdma_dev_lock); ha = qlnx_host_list; while (ha != NULL) { mtx_unlock(&qlnx_rdma_dev_lock); if (ha->dbg_level & 0xF000) ret = EBUSY; else ret = _qlnx_rdma_dev_remove(ha); device_printf(ha->pci_dev, "%s [%d]: ret = 0x%x\n", __func__, __LINE__, ret); if (ret) return (ret); mtx_lock(&qlnx_rdma_dev_lock); ha->qlnx_rdma = NULL; ha = ha->next; } if (!ret) qlnx_rdma_if = NULL; mtx_unlock(&qlnx_rdma_dev_lock); } printf("%s: exit rdma_if = %p\n", __func__, rdma_if); return (ret); }
static int octeon_gpio_detach(device_t dev) { struct octeon_gpio_softc *sc = device_get_softc(dev); int i; KASSERT(mtx_initialized(&sc->gpio_mtx), ("gpio mutex not initialized")); for ( i = 0; i < OCTEON_GPIO_IRQS; i++) { bus_release_resource(dev, SYS_RES_IRQ, sc->gpio_irq_rid[i], sc->gpio_irq_res[i]); } bus_generic_detach(dev); mtx_destroy(&sc->gpio_mtx); return(0); }
void scd_release_resources (device_t dev) { struct scd_softc * sc; sc = device_get_softc(dev); if (sc->port) { bus_release_resource(dev, sc->port_type, sc->port_rid, sc->port); sc->port_bst = 0; sc->port_bsh = 0; } if (mtx_initialized(&sc->mtx) != 0) mtx_destroy(&sc->mtx); return; }
/*---------------------------------------------------------------------------* * interface attach routine *---------------------------------------------------------------------------*/ static void i4btrcattach(void *dummy) { int i; printf("i4btrc: %d ISDN trace device(s) attached\n", NI4BTRC); for(i=0; i < NI4BTRC; i++) { make_dev(&i4btrc_cdevsw, i, UID_ROOT, GID_WHEEL, 0600, "i4btrc%d", i); trace_queue[i].ifq_maxlen = IFQ_MAXLEN; if(!mtx_initialized(&trace_queue[i].ifq_mtx)) mtx_init(&trace_queue[i].ifq_mtx, "i4b_trace", NULL, MTX_DEF); device_state[i] = ST_IDLE; } }
static int ar71xx_gpio_detach(device_t dev) { struct ar71xx_gpio_softc *sc = device_get_softc(dev); KASSERT(mtx_initialized(&sc->gpio_mtx), ("gpio mutex not initialized")); ar71xx_gpio_function_disable(sc, GPIO_FUNC_SPI_CS1_EN); ar71xx_gpio_function_disable(sc, GPIO_FUNC_SPI_CS2_EN); bus_generic_detach(dev); if (sc->gpio_mem_res) bus_release_resource(dev, SYS_RES_MEMORY, sc->gpio_mem_rid, sc->gpio_mem_res); mtx_destroy(&sc->gpio_mtx); return(0); }
static int tegra_gpio_detach(device_t dev) { struct tegra_gpio_softc *sc; sc = device_get_softc(dev); KASSERT(mtx_initialized(&sc->sc_mtx), ("gpio mutex not initialized")); gpiobus_detach_bus(dev); if (sc->gpio_ih != NULL) bus_teardown_intr(dev, sc->irq_res, sc->gpio_ih); if (sc->irq_res != NULL) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res); if (sc->mem_res != NULL) bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res); mtx_destroy(&sc->sc_mtx); return(0); }
/* * Since this is not a self-enumerating bus, and since we always add * children in attach, we have to always delete children here. */ static int gpiobus_detach(device_t dev) { struct gpiobus_softc *sc; struct gpiobus_ivar *devi; device_t *devlist; int i, err, ndevs; sc = GPIOBUS_SOFTC(dev); KASSERT(mtx_initialized(&sc->sc_mtx), ("gpiobus mutex not initialized")); GPIOBUS_LOCK_DESTROY(sc); if ((err = bus_generic_detach(dev)) != 0) return (err); if ((err = device_get_children(dev, &devlist, &ndevs)) != 0) return (err); for (i = 0; i < ndevs; i++) { devi = GPIOBUS_IVAR(devlist[i]); gpiobus_free_ivars(devi); resource_list_free(&devi->rl); free(devi, M_DEVBUF); device_delete_child(dev, devlist[i]); } free(devlist, M_TEMP); rman_fini(&sc->sc_intr_rman); if (sc->sc_pins) { for (i = 0; i < sc->sc_npins; i++) { if (sc->sc_pins[i].name != NULL) free(sc->sc_pins[i].name, M_DEVBUF); sc->sc_pins[i].name = NULL; } free(sc->sc_pins, M_DEVBUF); sc->sc_pins = NULL; } return (0); }
int ds1553_attach(device_t dev) { struct ds1553_softc *sc; uint8_t sec, flags; sc = device_get_softc(dev); if (mtx_initialized(&sc->sc_mtx) == 0) { device_printf(dev, "%s: mutex not initialized\n", __func__); return (ENXIO); } if (sc->sc_read == NULL) sc->sc_read = ds1553_direct_read; if (sc->sc_write == NULL) sc->sc_write = ds1553_direct_write; sc->year_offset = POSIX_BASE_YEAR; mtx_lock_spin(&sc->sc_mtx); /* Turn RTC on if it was not on */ sec = (*sc->sc_read)(dev, DS1553_OFF_SECONDS); if (sec & DS1553_BIT_OSC) { sec &= ~(DS1553_BIT_OSC); (*sc->sc_write)(dev, DS1553_OFF_SECONDS, sec); } /* Low-battery check */ flags = (*sc->sc_read)(dev, DS1553_OFF_FLAGS); if (flags & DS1553_BIT_BLF) device_printf(dev, "voltage-low detected.\n"); mtx_unlock_spin(&sc->sc_mtx); return (0); }
int qlnx_rdma_register_if(qlnx_rdma_if_t *rdma_if) { qlnx_host_t *ha; if (mtx_initialized(&qlnx_rdma_dev_lock)) { mtx_lock(&qlnx_rdma_dev_lock); qlnx_rdma_if = rdma_if; ha = qlnx_host_list; while (ha != NULL) { _qlnx_rdma_dev_add(ha); ha = ha->next; } mtx_unlock(&qlnx_rdma_dev_lock); return (0); } return (-1); }
static void mcd_release_resources (device_t dev) { struct mcd_softc * sc; sc = device_get_softc(dev); if (sc->irq_ih) bus_teardown_intr(dev, sc->irq, sc->irq_ih); if (sc->port) { bus_release_resource(dev, sc->port_type, sc->port_rid, sc->port); sc->port_bst = 0; sc->port_bsh = 0; } if (sc->irq) bus_release_resource(dev, sc->irq_type, sc->irq_rid, sc->irq); if (sc->drq) bus_release_resource(dev, sc->drq_type, sc->drq_rid, sc->drq); if (mtx_initialized(&sc->mtx) != 0) mtx_destroy(&sc->mtx); return; }
int smc_detach(device_t dev) { int type; struct smc_softc *sc; sc = device_get_softc(dev); SMC_LOCK(sc); smc_stop(sc); SMC_UNLOCK(sc); if (sc->smc_ifp != NULL) { ether_ifdetach(sc->smc_ifp); } callout_drain(&sc->smc_watchdog); callout_drain(&sc->smc_mii_tick_ch); #ifdef DEVICE_POLLING if (sc->smc_ifp->if_capenable & IFCAP_POLLING) ether_poll_deregister(sc->smc_ifp); #endif if (sc->smc_ih != NULL) bus_teardown_intr(sc->smc_dev, sc->smc_irq, sc->smc_ih); if (sc->smc_tq != NULL) { taskqueue_drain(sc->smc_tq, &sc->smc_intr); taskqueue_drain(sc->smc_tq, &sc->smc_rx); taskqueue_drain(sc->smc_tq, &sc->smc_tx); taskqueue_free(sc->smc_tq); sc->smc_tq = NULL; } if (sc->smc_ifp != NULL) { if_free(sc->smc_ifp); } if (sc->smc_miibus != NULL) { device_delete_child(sc->smc_dev, sc->smc_miibus); bus_generic_detach(sc->smc_dev); } if (sc->smc_reg != NULL) { type = SYS_RES_IOPORT; if (sc->smc_usemem) type = SYS_RES_MEMORY; bus_release_resource(sc->smc_dev, type, sc->smc_reg_rid, sc->smc_reg); } if (sc->smc_irq != NULL) bus_release_resource(sc->smc_dev, SYS_RES_IRQ, sc->smc_irq_rid, sc->smc_irq); if (mtx_initialized(&sc->smc_mtx)) mtx_destroy(&sc->smc_mtx); return (0); }
/*---------------------------------------------------------------------------* * initialize one B channels rx/tx data structures and init/deinit HSCX *---------------------------------------------------------------------------*/ void isic_bchannel_setup(int unit, int h_chan, int bprot, int activate) { struct l1_softc *sc = &l1_sc[unit]; l1_bchan_state_t *chan = &sc->sc_chan[h_chan]; int s = SPLI4B(); if(activate == 0) { /* deactivation */ isic_hscx_init(sc, h_chan, activate); } NDBGL1(L1_BCHAN, "unit=%d, channel=%d, %s", sc->sc_unit, h_chan, activate ? "activate" : "deactivate"); /* general part */ chan->unit = sc->sc_unit; /* unit number */ chan->channel = h_chan; /* B channel */ chan->bprot = bprot; /* B channel protocol */ chan->state = HSCX_IDLE; /* B channel state */ /* receiver part */ chan->rx_queue.ifq_maxlen = IFQ_MAXLEN; if(!mtx_initialized(&chan->rx_queue.ifq_mtx)) mtx_init(&chan->rx_queue.ifq_mtx, "i4b_isic_rx", NULL, MTX_DEF); i4b_Bcleanifq(&chan->rx_queue); /* clean rx queue */ chan->rxcount = 0; /* reset rx counter */ i4b_Bfreembuf(chan->in_mbuf); /* clean rx mbuf */ chan->in_mbuf = NULL; /* reset mbuf ptr */ chan->in_cbptr = NULL; /* reset mbuf curr ptr */ chan->in_len = 0; /* reset mbuf data len */ /* transmitter part */ chan->tx_queue.ifq_maxlen = IFQ_MAXLEN; if(!mtx_initialized(&chan->tx_queue.ifq_mtx)) mtx_init(&chan->tx_queue.ifq_mtx, "i4b_isic_tx", NULL, MTX_DEF); i4b_Bcleanifq(&chan->tx_queue); /* clean tx queue */ chan->txcount = 0; /* reset tx counter */ i4b_Bfreembuf(chan->out_mbuf_head); /* clean tx mbuf */ chan->out_mbuf_head = NULL; /* reset head mbuf ptr */ chan->out_mbuf_cur = NULL; /* reset current mbuf ptr */ chan->out_mbuf_cur_ptr = NULL; /* reset current mbuf data ptr */ chan->out_mbuf_cur_len = 0; /* reset current mbuf data cnt */ if(activate != 0) { /* activation */ isic_hscx_init(sc, h_chan, activate); } splx(s); }