static void
tdma_beacon_miss(struct ieee80211vap *vap)
{
struct ieee80211_tdma_state *ts = vap->iv_tdma;
IEEE80211_LOCK_ASSERT(vap->iv_ic);
KASSERT((vap->iv_ic->ic_flags & IEEE80211_F_SCAN) == 0, ("scanning"));
KASSERT(vap->iv_state == IEEE80211_S_RUN,
("wrong state %d", vap->iv_state));
IEEE80211_DPRINTF(vap,
IEEE80211_MSG_STATE | IEEE80211_MSG_TDMA | IEEE80211_MSG_DEBUG,
"beacon miss, mode %u state %s\n",
vap->iv_opmode, ieee80211_state_name[vap->iv_state]);
callout_stop(&vap->iv_swbmiss);
if (ts->tdma_peer != NULL) { /* XXX? can this be null? */
ieee80211_notify_node_leave(vap->iv_bss);
ts->tdma_peer = NULL;
/*
* Treat beacon miss like an associate failure wrt the
* scan policy; this forces the entry in the scan cache
* to be ignored after several tries.
*/
ieee80211_scan_assoc_fail(vap, vap->iv_bss->ni_macaddr,
IEEE80211_STATUS_TIMEOUT);
}
#if 0
ts->tdma_inuse = 0; /* clear slot usage */
#endif
ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
}
static int
adb_kbd_detach(device_t dev)
{
struct adb_kbd_softc *sc;
keyboard_t *kbd;
sc = device_get_softc(dev);
adb_set_autopoll(dev,0);
callout_stop(&sc->sc_repeater);
mtx_lock(&sc->sc_mutex);
kbd = kbd_get_keyboard(kbd_find_keyboard(KBD_DRIVER_NAME,
device_get_unit(dev)));
kbdd_disable(kbd);
#ifdef KBD_INSTALL_CDEV
kbd_detach(kbd);
#endif
kbdd_term(kbd);
mtx_unlock(&sc->sc_mutex);
mtx_destroy(&sc->sc_mutex);
cv_destroy(&sc->sc_cv);
return (0);
}
void
hpcfb_refresh_screen(struct hpcfb_softc *sc)
{
struct hpcfb_devconfig *dc = sc->sc_dc;
int x, y;
DPRINTF(("hpcfb_refres_screen()\n"));
if (dc == NULL)
return;
#ifdef HPCFB_JUMP
if (dc->dc_state&HPCFB_DC_SCROLLPENDING) {
dc->dc_state &= ~HPCFB_DC_SCROLLPENDING;
dc->dc_state &= ~HPCFB_DC_UPDATE;
callout_stop(&dc->dc_scroll_ch);
}
#endif /* HPCFB_JUMP */
/*
* refresh screen
*/
dc->dc_state &= ~HPCFB_DC_UPDATEALL;
x = dc->dc_curx;
y = dc->dc_cury;
if (0 <= x && 0 <= y)
hpcfb_cursor_raw(dc, 0, y, x); /* disable cursor */
/* redraw all text */
hpcfb_redraw(dc, 0, dc->dc_rows, 1);
if (0 <= x && 0 <= y)
hpcfb_cursor_raw(dc, 1, y, x); /* enable cursor */
}
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);
}
void
wskbd_input(device_t dev, u_int type, int value)
{
struct wskbd_softc *sc = device_private(dev);
#if NWSDISPLAY > 0
int num, i;
#endif
if (sc->sc_repeating) {
sc->sc_repeating = 0;
callout_stop(&sc->sc_repeat_ch);
}
device_active(dev, DVA_HARDWARE);
#if NWSDISPLAY > 0
/*
* If /dev/wskbdN is not connected in event mode translate and
* send upstream.
*/
if (sc->sc_translating) {
num = wskbd_translate(sc->id, type, value);
if (num > 0) {
if (sc->sc_base.me_dispdv != NULL) {
#ifdef WSDISPLAY_SCROLLSUPPORT
if (sc->id->t_symbols [0] != KS_Print_Screen) {
wsdisplay_scroll(sc->sc_base.
me_dispdv, WSDISPLAY_SCROLL_RESET);
}
#endif
for (i = 0; i < num; i++)
wsdisplay_kbdinput(
sc->sc_base.me_dispdv,
sc->id->t_symbols[i]);
}
if (sc->sc_keyrepeat_data.del1 != 0) {
sc->sc_repeating = num;
callout_schedule(&sc->sc_repeat_ch,
mstohz(sc->sc_keyrepeat_data.del1));
}
}
return;
}
#endif
wskbd_deliver_event(sc, type, value);
#if defined(WSKBD_EVENT_AUTOREPEAT)
/* Repeat key presses if set. */
if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_keyrepeat_data.del1 != 0) {
sc->sc_repeat_type = type;
sc->sc_repeat_value = value;
sc->sc_repeating = 1;
callout_schedule(&sc->sc_repeat_ch,
mstohz(sc->sc_keyrepeat_data.del1));
}
#endif /* defined(WSKBD_EVENT_AUTOREPEAT) */
}
void
ath_rate_detach(struct ath_ratectrl *arc)
{
struct onoe_softc *osc = (struct onoe_softc *) arc;
callout_stop(&osc->timer);
free(osc, M_DEVBUF);
}
static void
btn_guard_timeout(void *arg)
{
struct btn_obio_softc *sc = arg;
callout_stop(&sc->sc_guard_ch);
extintr_enable(sc->sc_ih);
}
static void
bvm_tty_close(struct tty *tp)
{
tty_lock(tp);
callout_stop(&bvm_timer);
tty_unlock(tp);
}
bool
spic_suspend(device_t dev, const pmf_qual_t *qual)
{
struct spic_softc *sc = device_private(dev);
callout_stop(&sc->sc_poll);
return true;
}
void
hwmp_vdetach(struct ieee80211vap *vap)
{
struct ieee80211_hwmp_state *hs = vap->iv_hwmp;
callout_stop(&hs->hs_roottimer);
kfree(vap->iv_hwmp, M_80211_VAP);
vap->iv_hwmp = NULL;
}
/**
* @brief This callback method asks the user to stop the supplied timer.
*
* @param[in] controller This parameter specifies the controller with
* which this timer is to associated.
* @param[in] timer This parameter specifies the timer to be stopped.
*
* @return none
*/
void
scif_cb_timer_stop(SCI_CONTROLLER_HANDLE_T controller, void *timer)
{
struct ISCI_TIMER *isci_timer = (struct ISCI_TIMER *)timer;
isci_log_message(3, "TIMER", "stop %p\n", timer);
isci_timer->is_started = FALSE;
callout_stop(&isci_timer->callout);
}
static void
pie_EventTimeout(void *arg)
{
struct pipe *dp = arg;
struct septum *st = &dp->septum;
callout_stop(dp->wrk, &st->co);
PIE_Wakeup(dp);
}
/*ARGSUSED*/
static int
logclose(struct dev_close_args *ap)
{
log_open = 0;
callout_stop(&logsoftc.sc_callout);
logsoftc.sc_state = 0;
funsetown(&logsoftc.sc_sigio);
return (0);
}
static bool
aps_suspend(device_t dv PMF_FN_ARGS)
{
struct aps_softc *sc = device_private(dv);
callout_stop(&sc->sc_callout);
return true;
}
void
tws_cmd_complete(struct tws_request *req)
{
struct tws_softc *sc = req->sc;
callout_stop(req->ccb_ptr->ccb_h.timeout_ch);
tws_unmap_request(sc, req);
}
static void
pdq_ifstop(pdq_softc_t *sc)
{
PDQ_IFNET(sc)->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
sc->sc_pdq->pdq_flags &= ~PDQ_RUNNING;
pdq_stop(sc->sc_pdq);
callout_stop(&sc->watchdog);
}
/*
* sysmon_wdog_setmode:
*
* Set the mode of a watchdog device.
*/
int
sysmon_wdog_setmode(struct sysmon_wdog *smw, int mode, u_int period)
{
u_int operiod = smw->smw_period;
int omode = smw->smw_mode;
int error = 0;
smw->smw_period = period;
smw->smw_mode = mode;
switch (mode & WDOG_MODE_MASK) {
case WDOG_MODE_DISARMED:
if (smw != sysmon_armed_wdog) {
error = EINVAL;
goto out;
}
break;
case WDOG_MODE_KTICKLE:
case WDOG_MODE_UTICKLE:
if (sysmon_armed_wdog != NULL) {
error = EBUSY;
goto out;
}
break;
default:
error = EINVAL;
goto out;
}
error = (*smw->smw_setmode)(smw);
out:
if (error) {
smw->smw_period = operiod;
smw->smw_mode = omode;
} else {
if ((mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) {
sysmon_armed_wdog = NULL;
smw->smw_tickler = (pid_t) -1;
smw->smw_refcnt--;
if ((omode & WDOG_MODE_MASK) == WDOG_MODE_KTICKLE)
callout_stop(&sysmon_wdog_callout);
} else {
sysmon_armed_wdog = smw;
smw->smw_refcnt++;
if ((mode & WDOG_MODE_MASK) == WDOG_MODE_KTICKLE) {
callout_reset(&sysmon_wdog_callout,
WDOG_PERIOD_TO_TICKS(smw->smw_period) / 2,
sysmon_wdog_ktickle, NULL);
}
}
}
return (error);
}
/**
* mrsas_cmd_done: Perform remaining command completion
* input: Adapter instance soft state
* Pointer to command packet
*
* This function calls ummap request and releases the MPT command.
*/
void mrsas_cmd_done(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd)
{
callout_stop(&cmd->cm_callout);
mrsas_unmap_request(sc, cmd);
lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
xpt_done(cmd->ccb_ptr);
cmd->ccb_ptr = NULL;
lockmgr(&sc->sim_lock, LK_RELEASE);
mrsas_release_mpt_cmd(cmd);
}
static bool
wskbd_suspend(device_t dv, const pmf_qual_t *qual)
{
struct wskbd_softc *sc = device_private(dv);
sc->sc_repeating = 0;
callout_stop(&sc->sc_repeat_ch);
return true;
}
/**
* mrsas_cmd_done: Perform remaining command completion
* input: Adapter instance soft state
* Pointer to command packet
*
* This function calls ummap request and releases the MPT command.
*/
void mrsas_cmd_done(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd)
{
callout_stop(&cmd->cm_callout);
mrsas_unmap_request(sc, cmd);
mtx_lock(&sc->sim_lock);
xpt_done(cmd->ccb_ptr);
cmd->ccb_ptr = NULL;
mtx_unlock(&sc->sim_lock);
mrsas_release_mpt_cmd(cmd);
}
int
del_timer_sync(struct timer_list *t)
{
spin_lock(&t->mtx);
callout_stop(&t->callout);
spin_unlock(&t->mtx);
spin_lock_destroy(&t->mtx);
return 0;
}
static int
akbd_disable(keyboard_t *kbd)
{
struct adb_kbd_softc *sc;
sc = (struct adb_kbd_softc *)(kbd);
callout_stop(&sc->sc_repeater);
KBD_DEACTIVATE(kbd);
return (0);
}
int
del_timer_sync(struct timer_list *t)
{
mtx_lock_spin(&t->mtx);
callout_stop(&t->callout);
mtx_unlock_spin(&t->mtx);
mtx_destroy(&t->mtx);
return 0;
}
static void
mpt_restart(mpt_softc_t *mpt, request_t *req0)
{
int i, s, nreq;
request_t *req;
struct scsipi_xfer *xs;
/* first, reset the IOC, leaving stopped so all requests are idle */
if (mpt_soft_reset(mpt) != MPT_OK) {
mpt_prt(mpt, "soft reset failed");
/*
* Don't try a hard reset since this mangles the PCI
* configuration registers.
*/
return;
}
/* Freeze the channel so scsipi doesn't queue more commands. */
scsipi_channel_freeze(&mpt->sc_channel, 1);
/* Return all pending requests to scsipi and de-allocate them. */
s = splbio();
nreq = 0;
for (i = 0; i < MPT_MAX_REQUESTS(mpt); i++) {
req = &mpt->request_pool[i];
xs = req->xfer;
if (xs != NULL) {
if (xs->datalen != 0)
bus_dmamap_unload(mpt->sc_dmat, req->dmap);
req->xfer = NULL;
callout_stop(&xs->xs_callout);
if (req != req0) {
nreq++;
xs->error = XS_REQUEUE;
}
scsipi_done(xs);
/*
* Don't need to mpt_free_request() since mpt_init()
* below will free all requests anyway.
*/
mpt_free_request(mpt, req);
}
}
splx(s);
if (nreq > 0)
mpt_prt(mpt, "re-queued %d requests", nreq);
/* Re-initialize the IOC (which restarts it). */
if (mpt_init(mpt, MPT_DB_INIT_HOST) == 0)
mpt_prt(mpt, "restart succeeded");
/* else error message already printed */
/* Thaw the channel, causing scsipi to re-queue the commands. */
scsipi_channel_thaw(&mpt->sc_channel, 1);
}
static void
tws_scsi_err_complete(struct tws_request *req, struct tws_command_header *hdr)
{
u_int8_t *sense_data;
struct tws_softc *sc = req->sc;
union ccb *ccb = req->ccb_ptr;
TWS_TRACE_DEBUG(sc, "sbe, cmd_status", hdr->status_block.error,
req->cmd_pkt->cmd.pkt_a.status);
if ( hdr->status_block.error == TWS_ERROR_LOGICAL_UNIT_NOT_SUPPORTED ||
hdr->status_block.error == TWS_ERROR_UNIT_OFFLINE ) {
if ( ccb->ccb_h.target_lun ) {
TWS_TRACE_DEBUG(sc, "invalid lun error",0,0);
ccb->ccb_h.status |= CAM_LUN_INVALID;
} else {
TWS_TRACE_DEBUG(sc, "invalid target error",0,0);
ccb->ccb_h.status |= CAM_TID_INVALID;
}
} else {
TWS_TRACE_DEBUG(sc, "scsi status error",0,0);
ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
if (((ccb->csio.cdb_io.cdb_bytes[0] == 0x1A) &&
(hdr->status_block.error == TWS_ERROR_NOT_SUPPORTED))) {
ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID;
TWS_TRACE_DEBUG(sc, "page mode not supported",0,0);
}
}
/* if there were no error simply mark complete error */
if (ccb->ccb_h.status == 0)
ccb->ccb_h.status = CAM_REQ_CMP_ERR;
sense_data = (u_int8_t *)&ccb->csio.sense_data;
if (sense_data) {
memcpy(sense_data, hdr->sense_data, TWS_SENSE_DATA_LENGTH );
ccb->csio.sense_len = TWS_SENSE_DATA_LENGTH;
ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
}
ccb->csio.scsi_status = req->cmd_pkt->cmd.pkt_a.status;
ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
xpt_done(ccb);
lockmgr(&sc->sim_lock, LK_RELEASE);
callout_stop(req->ccb_ptr->ccb_h.timeout_ch);
tws_unmap_request(req->sc, req);
lockmgr(&sc->q_lock, LK_EXCLUSIVE);
tws_q_remove_request(sc, req, TWS_BUSY_Q);
tws_q_insert_tail(sc, req, TWS_FREE_Q);
lockmgr(&sc->q_lock, LK_RELEASE);
}
int
parsendch(struct par_softc *sc, u_char ch)
{
int error = 0;
int s;
/* if either offline, busy or out of paper, wait for that
condition to clear */
s = spl1();
while (!error
&& (parsend_pending
|| !(intio_get_sicilian_intr() & SICILIAN_STAT_PAR)))
{
/* wait a second, and try again */
callout_reset(&intr_callout, hz, parintr, 0);
partimeout_pending = 1;
/* this is essentially a flipflop to have us wait for the
first character being transmitted when trying to transmit
the second, etc. */
parsend_pending = 0;
/* it's quite important that a parallel putc can be
interrupted, given the possibility to lock a printer
in an offline condition.. */
if ((error = tsleep(parintr, PCATCH|(PZERO-1), "parsendch", 0))) {
#ifdef DEBUG
if (pardebug & PDB_INTERRUPT)
printf("parsendch interrupted, error = %d\n", error);
#endif
if (partimeout_pending)
callout_stop(&intr_callout);
partimeout_pending = 0;
}
}
if (!error) {
#ifdef DEBUG
if (pardebug & PDB_INTERRUPT)
printf("#%d", ch);
#endif
bus_space_write_1(sc->sc_bst, sc->sc_bsh, PAR_DATA, ch);
DELAY(1); /* (DELAY(1) == 1us) > 0.5us */
bus_space_write_1(sc->sc_bst, sc->sc_bsh, PAR_STROBE, 0);
intio_set_sicilian_intr(intio_get_sicilian_intr() |
SICILIAN_INTR_PAR);
DELAY(1);
bus_space_write_1(sc->sc_bst, sc->sc_bsh, PAR_STROBE, 1);
parsend_pending = 1;
}
splx(s);
return error;
}
int
arcbios_ttyclose(dev_t dev, int flag, int mode, struct lwp *l)
{
int unit = minor(dev);
struct tty *tp = arcbios_tty[unit];
callout_stop(&arcbios_tty_ch);
(*tp->t_linesw->l_close)(tp, flag);
ttyclose(tp);
return (0);
}
/* detach */
int
url_detach(device_t self, int flags)
{
struct url_softc *sc = device_private(self);
struct ifnet *ifp = GET_IFP(sc);
int s;
DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
/* Detached before attached finished */
if (!sc->sc_attached)
return (0);
callout_stop(&sc->sc_stat_ch);
/* Remove any pending tasks */
usb_rem_task(sc->sc_udev, &sc->sc_tick_task);
usb_rem_task(sc->sc_udev, &sc->sc_stop_task);
s = splusb();
if (--sc->sc_refcnt >= 0) {
/* Wait for processes to go away */
usb_detach_waitold(sc->sc_dev);
}
if (ifp->if_flags & IFF_RUNNING)
url_stop(GET_IFP(sc), 1);
rnd_detach_source(&sc->rnd_source);
mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
ether_ifdetach(ifp);
if_detach(ifp);
#ifdef DIAGNOSTIC
if (sc->sc_pipe_tx != NULL)
aprint_debug_dev(self, "detach has active tx endpoint.\n");
if (sc->sc_pipe_rx != NULL)
aprint_debug_dev(self, "detach has active rx endpoint.\n");
if (sc->sc_pipe_intr != NULL)
aprint_debug_dev(self, "detach has active intr endpoint.\n");
#endif
sc->sc_attached = 0;
splx(s);
rw_destroy(&sc->sc_mii_rwlock);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
return (0);
}
static int
octeon_rnd_detach(device_t dev)
{
struct octeon_rnd_softc *sc;
sc = device_get_softc(dev);
callout_stop(&sc->sc_callout);
return (0);
}
static bool
oj6sh_suspend(device_t dv, const pmf_qual_t *qual)
{
struct oj6sh_softc *sc = device_private(dv);
DPRINTF(3,("%s: oj6sh_suspend()\n", device_xname(sc->sc_dev)));
callout_stop(&sc->sc_c);
sc->sc_enabled = 0;
return true;
}
