void
sdp_tx_ring_destroy(struct sdp_sock *ssk)
{
sdp_dbg(ssk->socket, "tx ring destroy\n");
SDP_WLOCK(ssk);
callout_stop(&ssk->tx_ring.timer);
callout_stop(&ssk->nagle_timer);
SDP_WUNLOCK(ssk);
callout_drain(&ssk->tx_ring.timer);
callout_drain(&ssk->nagle_timer);
if (ssk->tx_ring.buffer) {
sdp_tx_ring_purge(ssk);
kfree(ssk->tx_ring.buffer);
ssk->tx_ring.buffer = NULL;
}
if (ssk->tx_ring.cq) {
if (ib_destroy_cq(ssk->tx_ring.cq)) {
sdp_warn(ssk->socket, "destroy cq(%p) failed\n",
ssk->tx_ring.cq);
} else {
ssk->tx_ring.cq = NULL;
}
}
WARN_ON(ring_head(ssk->tx_ring) != ring_tail(ssk->tx_ring));
}
/* Link down event*/
static void
ntb_transport_link_cleanup(struct ntb_transport_ctx *nt)
{
struct ntb_transport_qp *qp;
struct _qpset qp_bitmap_alloc;
unsigned i;
BIT_COPY(QP_SETSIZE, &nt->qp_bitmap, &qp_bitmap_alloc);
BIT_NAND(QP_SETSIZE, &qp_bitmap_alloc, &nt->qp_bitmap_free);
/* Pass along the info to any clients */
for (i = 0; i < nt->qp_count; i++)
if (test_bit(i, &qp_bitmap_alloc)) {
qp = &nt->qp_vec[i];
ntb_qp_link_cleanup(qp);
callout_drain(&qp->link_work);
}
if (!nt->link_is_up)
callout_drain(&nt->link_work);
/*
* The scratchpad registers keep the values if the remote side
* goes down, blast them now to give them a sane value the next
* time they are accessed
*/
for (i = 0; i < IF_NTB_MAX_SPAD; i++)
ntb_spad_write(nt->ntb, i, 0);
}
/*
* Function name: twa_shutdown
* Description: Called at unload/shutdown time. Lets the controller
* know that we are going down.
*
* Input: dev -- bus device corresponding to the ctlr
* Output: None
* Return value: 0 -- success
* non-zero-- failure
*/
static TW_INT32
twa_shutdown(device_t dev)
{
struct twa_softc *sc = device_get_softc(dev);
TW_INT32 error = 0;
tw_osli_dbg_dprintf(3, sc, "entered");
/* Disconnect interrupts. */
error = twa_teardown_intr(sc);
/* Stop watchdog task. */
callout_drain(&(sc->watchdog_callout[0]));
callout_drain(&(sc->watchdog_callout[1]));
/* Disconnect from the controller. */
if ((error = tw_cl_shutdown_ctlr(&(sc->ctlr_handle), 0))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2015,
"Failed to shutdown Common Layer/controller",
error);
}
return(error);
}
static void
ntb_transport_free(struct ntb_transport_ctx *nt)
{
struct ntb_softc *ntb = nt->ntb;
struct _qpset qp_bitmap_alloc;
uint8_t i;
ntb_transport_link_cleanup(nt);
taskqueue_drain(taskqueue_swi, &nt->link_cleanup);
callout_drain(&nt->link_work);
callout_drain(&nt->link_watchdog);
BIT_COPY(QP_SETSIZE, &nt->qp_bitmap, &qp_bitmap_alloc);
BIT_NAND(QP_SETSIZE, &qp_bitmap_alloc, &nt->qp_bitmap_free);
/* Verify that all the QPs are freed */
for (i = 0; i < nt->qp_count; i++)
if (test_bit(i, &qp_bitmap_alloc))
ntb_transport_free_queue(&nt->qp_vec[i]);
ntb_link_disable(ntb);
ntb_clear_ctx(ntb);
for (i = 0; i < nt->mw_count; i++)
ntb_free_mw(nt, i);
free(nt->qp_vec, M_NTB_IF);
}
static int
ntb_detach(device_t device)
{
struct ntb_softc *ntb = DEVICE2SOFTC(device);
callout_drain(&ntb->heartbeat_timer);
callout_drain(&ntb->lr_timer);
ntb_teardown_interrupts(ntb);
ntb_unmap_pci_bar(ntb);
return (0);
}
static void
stop_ep_timer(struct iwch_ep *ep)
{
CTR2(KTR_IW_CXGB, "%s ep %p", __FUNCTION__, ep);
callout_drain(&ep->timer);
put_ep(&ep->com);
}
int
in6_detachhead(void **head, int off)
{
callout_drain(&V_rtq_mtutimer);
return (rn_detachhead(head));
}
/*
* 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);
}
void
ip6_destroy()
{
nd6_destroy();
callout_drain(&V_in6_tmpaddrtimer_ch);
}
void timeout_test_cancel_callout(int mpsave, bool use_drain)
{
enum arg argument = HANDLER_NOT_VISITED;
struct callout callout;
int retval = 0;
printf("== Start a callout and cancel it with %s. mpsave=%d\n", use_drain ? "drain" : "stop", mpsave);
callout_init(&callout, mpsave);
retval = callout_reset(&callout, RTEMS_MILLISECONDS_TO_TICKS(TIMEOUT_MILLISECONDS), timeout_handler, &argument);
assert(retval == 0);
usleep(TEST_NOT_FIRED_MS * 1000);
if(!use_drain)
{
retval = callout_stop(&callout);
}
else
{
retval = callout_drain(&callout);
}
assert(retval != 0);
usleep(TEST_FIRED_MS * 1000);
assert(argument == HANDLER_NOT_VISITED);
callout_deactivate(&callout);
}
static int
ad_detach(device_t dev)
{
struct ad_softc *adp = device_get_ivars(dev);
struct ata_device *atadev = device_get_softc(dev);
/* check that we have a valid disk to detach */
if (!device_get_ivars(dev))
return ENXIO;
/* destroy the power timeout */
callout_drain(&atadev->spindown_timer);
/* detach & delete all children */
device_delete_children(dev);
/* destroy disk from the system so we don't get any further requests */
disk_destroy(adp->disk);
/* fail requests on the queue and any that's "in flight" for this device */
ata_fail_requests(dev);
/* don't leave anything behind */
device_set_ivars(dev, NULL);
free(adp, M_AD);
return 0;
}
static void
adv_destroy_ccb_info(struct adv_softc *adv, struct adv_ccb_info *cinfo)
{
callout_drain(&cinfo->timer);
bus_dmamap_destroy(adv->buffer_dmat, cinfo->dmamap);
}
static void
ntb_transport_free_queue(struct ntb_transport_qp *qp)
{
struct ntb_queue_entry *entry;
if (qp == NULL)
return;
callout_drain(&qp->link_work);
ntb_db_set_mask(qp->ntb, 1ull << qp->qp_num);
taskqueue_drain(taskqueue_swi, &qp->rxc_db_work);
taskqueue_drain(taskqueue_swi, &qp->rx_completion_task);
qp->cb_data = NULL;
qp->rx_handler = NULL;
qp->tx_handler = NULL;
qp->event_handler = NULL;
while ((entry = ntb_list_rm(&qp->ntb_rx_q_lock, &qp->rx_pend_q)))
free(entry, M_NTB_IF);
while ((entry = ntb_list_rm(&qp->ntb_rx_q_lock, &qp->rx_post_q)))
free(entry, M_NTB_IF);
while ((entry = ntb_list_rm(&qp->ntb_tx_free_q_lock, &qp->tx_free_q)))
free(entry, M_NTB_IF);
set_bit(qp->qp_num, &qp->transport->qp_bitmap_free);
}
int
in_detachhead(void **head, int off)
{
callout_drain(&V_rtq_timer);
return (1);
}
static int
at91_udp_detach(device_t dev)
{
struct at91_udp_softc *sc = device_get_softc(dev);
device_t bdev;
int err;
if (sc->sc_dci.sc_bus.bdev) {
bdev = sc->sc_dci.sc_bus.bdev;
device_detach(bdev);
device_delete_child(dev, bdev);
}
/* during module unload there are lots of children leftover */
device_delete_children(dev);
USB_BUS_LOCK(&sc->sc_dci.sc_bus);
callout_stop(&sc->sc_vbus);
USB_BUS_UNLOCK(&sc->sc_dci.sc_bus);
callout_drain(&sc->sc_vbus);
/* disable Transceiver */
AT91_UDP_WRITE_4(&sc->sc_dci, AT91_UDP_TXVC, AT91_UDP_TXVC_DIS);
/* disable and clear all interrupts */
AT91_UDP_WRITE_4(&sc->sc_dci, AT91_UDP_IDR, 0xFFFFFFFF);
AT91_UDP_WRITE_4(&sc->sc_dci, AT91_UDP_ICR, 0xFFFFFFFF);
if (sc->sc_dci.sc_irq_res && sc->sc_dci.sc_intr_hdl) {
/*
* only call at91_udp_uninit() after at91_udp_init()
*/
at91dci_uninit(&sc->sc_dci);
err = bus_teardown_intr(dev, sc->sc_dci.sc_irq_res,
sc->sc_dci.sc_intr_hdl);
sc->sc_dci.sc_intr_hdl = NULL;
}
if (sc->sc_dci.sc_irq_res) {
bus_release_resource(dev, SYS_RES_IRQ, 0,
sc->sc_dci.sc_irq_res);
sc->sc_dci.sc_irq_res = NULL;
}
if (sc->sc_dci.sc_io_res) {
bus_release_resource(dev, SYS_RES_MEMORY, MEM_RID,
sc->sc_dci.sc_io_res);
sc->sc_dci.sc_io_res = NULL;
}
usb_bus_mem_free_all(&sc->sc_dci.sc_bus, NULL);
/* disable clocks */
at91_pmc_clock_disable(sc->sc_iclk);
at91_pmc_clock_disable(sc->sc_fclk);
at91_pmc_clock_disable(sc->sc_mclk);
at91_pmc_clock_deref(sc->sc_fclk);
at91_pmc_clock_deref(sc->sc_iclk);
at91_pmc_clock_deref(sc->sc_mclk);
return (0);
}
/*
* Bus independant device detachment routine. Makes sure all
* allocated resources are freed, callouts disabled and waiting
* processes unblocked.
*/
int
cmx_detach(device_t dev)
{
struct cmx_softc *sc = device_get_softc(dev);
DEBUG_printf(dev, "called\n");
sc->dying = 1;
CMX_LOCK(sc);
if (sc->polling) {
DEBUG_printf(sc->dev, "disabling polling\n");
callout_stop(&sc->ch);
sc->polling = 0;
CMX_UNLOCK(sc);
callout_drain(&sc->ch);
selwakeuppri(&sc->sel, PZERO);
} else {
CMX_UNLOCK(sc);
}
wakeup(sc);
destroy_dev(sc->cdev);
DEBUG_printf(dev, "releasing resources\n");
cmx_release_resources(dev);
return 0;
}
/*
* Close the character device.
*/
static int
cmx_close(struct cdev *cdev, int flags, int fmt, struct thread *td)
{
struct cmx_softc *sc = cdev->si_drv1;
if (sc == NULL || sc->dying)
return ENXIO;
CMX_LOCK(sc);
if (!sc->open) {
CMX_UNLOCK(sc);
return EINVAL;
}
if (sc->polling) {
DEBUG_printf(sc->dev, "disabling polling\n");
callout_stop(&sc->ch);
sc->polling = 0;
CMX_UNLOCK(sc);
callout_drain(&sc->ch);
selwakeuppri(&sc->sel, PZERO);
CMX_LOCK(sc);
}
sc->open = 0;
CMX_UNLOCK(sc);
DEBUG_printf(sc->dev, "close (flags=%b thread=%p)\n",
flags, MODEBITS, td);
return 0;
}
static void
ntb_transport_free(void *transport)
{
struct ntb_netdev *nt = transport;
struct ntb_softc *ntb = nt->ntb;
int i;
nt->transport_link = NTB_LINK_DOWN;
callout_drain(&nt->link_work);
/* verify that all the qps are freed */
for (i = 0; i < nt->max_qps; i++)
if (!test_bit(i, &nt->qp_bitmap))
ntb_transport_free_queue(&nt->qps[i]);
ntb_unregister_event_callback(ntb);
for (i = 0; i < NTB_NUM_MW; i++)
if (nt->mw[i].virt_addr != NULL)
contigfree(nt->mw[i].virt_addr, nt->mw[i].size,
M_NTB_IF);
free(nt->qps, M_NTB_IF);
ntb_unregister_transport(ntb);
}
void
ieee80211_scan_detach(struct ieee80211com *ic)
{
struct ieee80211_scan_state *ss = ic->ic_scan;
if (ss != NULL) {
IEEE80211_LOCK(ic);
SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT;
scan_signal(ss);
IEEE80211_UNLOCK(ic);
ieee80211_draintask(ic, &SCAN_PRIVATE(ss)->ss_scan_task);
callout_drain(&SCAN_PRIVATE(ss)->ss_scan_timer);
KASSERT((ic->ic_flags & IEEE80211_F_SCAN) == 0,
("scan still running"));
if (ss->ss_ops != NULL) {
ss->ss_ops->scan_detach(ss);
ss->ss_ops = NULL;
}
ic->ic_scan = NULL;
free(SCAN_PRIVATE(ss), M_80211_SCAN);
}
#if defined(__ANTARES__)
ieee80211_scan_sta_uninit();
#endif
}
void
ip6_destroy()
{
hashdestroy(V_in6_ifaddrhashtbl, M_IFADDR, V_in6_ifaddrhmask);
nd6_destroy();
callout_drain(&V_in6_tmpaddrtimer_ch);
}
void
ath_rate_detach(struct ath_ratectrl *arc)
{
struct amrr_softc *asc = (struct amrr_softc *) arc;
callout_drain(&asc->timer);
free(asc, M_DEVBUF);
}
/* finish using this keyboard */
static int
pckbd_term(keyboard_t *kbd)
{
pckbd_state_t *state = (pckbd_state_t *)kbd->kb_data;
kbd_unregister(kbd);
callout_drain(&state->ks_timer);
return 0;
}
int
in6_detachhead(void **head, int off)
{
callout_drain(&V_rtq_mtutimer);
rt_table_destroy((struct rib_head *)(*head));
return (1);
}
void
hwmp_vdetach(struct ieee80211vap *vap)
{
struct ieee80211_hwmp_state *hs = vap->iv_hwmp;
callout_drain(&hs->hs_roottimer);
free(vap->iv_hwmp, M_80211_VAP);
vap->iv_hwmp = NULL;
}
static void
dtsec_if_deinit_locked(struct dtsec_softc *sc)
{
DTSEC_LOCK_ASSERT(sc);
DTSEC_UNLOCK(sc);
callout_drain(&sc->sc_tick_callout);
DTSEC_LOCK(sc);
}
static int
vtrnd_detach(device_t dev)
{
struct vtrnd_softc *sc;
sc = device_get_softc(dev);
callout_drain(&sc->vtrnd_callout);
return (0);
}
static int
aml8726_rng_detach(device_t dev)
{
struct aml8726_rng_softc *sc = device_get_softc(dev);
callout_drain(&sc->co);
bus_release_resources(dev, aml8726_rng_spec, sc->res);
return (0);
}
static void
stop_ep_timer(struct iwch_ep *ep)
{
CTR2(KTR_IW_CXGB, "%s ep %p", __FUNCTION__, ep);
if (!callout_pending(&ep->timer)) {
CTR3(KTR_IW_CXGB, "%s timer stopped when its not running! ep %p state %u\n",
__func__, ep, ep->com.state);
return;
}
callout_drain(&ep->timer);
put_ep(&ep->com);
}
static int
ntb_detach(device_t device)
{
struct ntb_softc *ntb;
ntb = DEVICE2SOFTC(device);
callout_drain(&ntb->heartbeat_timer);
callout_drain(&ntb->lr_timer);
if (ntb->type == NTB_XEON)
ntb_teardown_xeon(ntb);
ntb_teardown_interrupts(ntb);
/*
* Redetect total MWs so we unmap properly -- in case we lowered the
* maximum to work around Xeon errata.
*/
ntb_detect_max_mw(ntb);
ntb_unmap_pci_bar(ntb);
return (0);
}
void
ip6_destroy()
{
int i;
if ((i = pfil_head_unregister(&V_inet6_pfil_hook)) != 0)
printf("%s: WARNING: unable to unregister pfil hook, "
"error %d\n", __func__, i);
hashdestroy(V_in6_ifaddrhashtbl, M_IFADDR, V_in6_ifaddrhmask);
nd6_destroy();
callout_drain(&V_in6_tmpaddrtimer_ch);
}
