void ieee80211_free_node(struct ieee80211com *ic, struct ieee80211_node *ni) { if (ni == ic->ic_bss) panic("freeing bss node"); splassert(IPL_NET); DPRINTF(("%s\n", ether_sprintf(ni->ni_macaddr))); #ifndef IEEE80211_STA_ONLY timeout_del(&ni->ni_eapol_to); timeout_del(&ni->ni_sa_query_to); IEEE80211_AID_CLR(ni->ni_associd, ic->ic_aid_bitmap); #endif RB_REMOVE(ieee80211_tree, &ic->ic_tree, ni); ic->ic_nnodes--; #ifndef IEEE80211_STA_ONLY if (!IF_IS_EMPTY(&ni->ni_savedq)) { IF_PURGE(&ni->ni_savedq); if (ic->ic_set_tim != NULL) (*ic->ic_set_tim)(ic, ni->ni_associd, 0); } #endif (*ic->ic_node_free)(ic, ni); /* TBD indicate to drivers that a new node can be allocated */ }
/* * Bell routines. */ void dnkbd_bell(void *v, u_int period, u_int pitch, u_int volume) { struct dnkbd_softc *sc = v; int ticks, s; s = spltty(); if (pitch == 0 || period == 0 || volume == 0) { if (ISSET(sc->sc_flags, SF_BELL_TMO)) { timeout_del(&sc->sc_bellstop_tmo); dnkbd_bellstop(v); } } else { ticks = (period * hz) / 1000; if (ticks <= 0) ticks = 1; if (!ISSET(sc->sc_flags, SF_BELL)) { dnkbd_pollout(sc->sc_regs, DNCMD_PREFIX); dnkbd_pollout(sc->sc_regs, DNCMD_BELL); dnkbd_pollout(sc->sc_regs, DNCMD_BELL_ON); SET(sc->sc_flags, SF_BELL); } if (ISSET(sc->sc_flags, SF_BELL_TMO)) timeout_del(&sc->sc_bellstop_tmo); timeout_add(&sc->sc_bellstop_tmo, ticks); SET(sc->sc_flags, SF_BELL_TMO); } splx(s); }
int com_detach(struct device *self, int flags) { struct com_softc *sc = (struct com_softc *)self; int maj, mn; sc->sc_swflags |= COM_SW_DEAD; /* Locate the major number. */ for (maj = 0; maj < nchrdev; maj++) if (cdevsw[maj].d_open == comopen) break; /* Nuke the vnodes for any open instances. */ mn = self->dv_unit; vdevgone(maj, mn, mn, VCHR); /* XXX a symbolic constant for the cua bit would be nicer. */ mn |= 0x80; vdevgone(maj, mn, mn, VCHR); /* Detach and free the tty. */ if (sc->sc_tty) { ttyfree(sc->sc_tty); } timeout_del(&sc->sc_dtr_tmo); timeout_del(&sc->sc_diag_tmo); softintr_disestablish(sc->sc_si); return (0); }
/* * Stop the keyboard controller when we are going to suspend */ void pckbc_stop(struct pckbc_softc *sc) { struct pckbc_internal *t = sc->id; timeout_del(&t->t_poll); pckbc_cleanqueues(t); timeout_del(&t->t_cleanup); }
int gem_detach_pci(struct device *self, int flags) { struct gem_pci_softc *gsc = (void *)self; struct gem_softc *sc = &gsc->gsc_gem; timeout_del(&sc->sc_tick_ch); timeout_del(&sc->sc_rx_watchdog); gem_unconfig(sc); pci_intr_disestablish(gsc->gsc_pc, gsc->gsc_ih); bus_space_unmap(gsc->gsc_memt, gsc->gsc_memh, gsc->gsc_memsize); return (0); }
void nep_stop(struct ifnet *ifp) { struct nep_softc *sc = (struct nep_softc *)ifp->if_softc; timeout_del(&sc->sc_tick_ch); }
void bmac_stop(struct bmac_softc *sc) { struct ifnet *ifp = &sc->arpcom.ac_if; int s; s = splnet(); /* timeout */ timeout_del(&sc->sc_tick_ch); mii_down(&sc->sc_mii); /* Disable TX/RX. */ bmac_reset_bits(sc, TXCFG, TxMACEnable); bmac_reset_bits(sc, RXCFG, RxMACEnable); /* Disable all interrupts. */ bmac_write_reg(sc, INTDISABLE, NoEventsMask); dbdma_stop(sc->sc_txdma); dbdma_stop(sc->sc_rxdma); ifp->if_flags &= ~(IFF_UP | IFF_RUNNING); ifp->if_timer = 0; splx(s); }
void wskbd_input(struct device *dev, u_int type, int value) { struct wskbd_softc *sc = (struct wskbd_softc *)dev; #if NWSDISPLAY > 0 int num; #endif #if NWSDISPLAY > 0 if (sc->sc_repeating) { sc->sc_repeating = 0; timeout_del(&sc->sc_repeat_ch); } /* * If /dev/wskbdN is not connected in event mode translate and * send upstream. */ if (sc->sc_translating) { #ifdef HAVE_BURNER_SUPPORT if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_displaydv != NULL) wsdisplay_burn(sc->sc_displaydv, WSDISPLAY_BURN_KBD); #endif num = wskbd_translate(sc->id, type, value); if (num > 0) { if (sc->sc_displaydv != NULL) { #ifdef HAVE_SCROLLBACK_SUPPORT /* XXX - Shift_R+PGUP(release) emits PrtSc */ if (sc->id->t_symbols[0] != KS_Print_Screen) { wsscrollback(sc->sc_displaydv, WSDISPLAY_SCROLL_RESET); } #endif wsdisplay_kbdinput(sc->sc_displaydv, sc->id->t_keymap.layout, sc->id->t_symbols, num); } if (sc->sc_keyrepeat_data.del1 != 0) { sc->sc_repeating = num; timeout_add_msec(&sc->sc_repeat_ch, sc->sc_keyrepeat_data.del1); } } return; } #endif wskbd_deliver_event(sc, type, value); #if NWSDISPLAY > 0 /* Repeat key presses if enabled. */ 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; timeout_add_msec(&sc->sc_repeat_ch, sc->sc_keyrepeat_data.del1); } #endif }
void ykbec_bell(void *arg, u_int pitch, u_int period, u_int volume, int poll) { struct ykbec_softc *sc = (struct ykbec_softc *)arg; int bctrl; int s; s = spltty(); bctrl = ykbec_read(sc, REG_BEEP_CONTROL); if (volume == 0 || timeout_pending(&sc->sc_bell_tmo)) { timeout_del(&sc->sc_bell_tmo); /* inline ykbec_bell_stop(arg); */ ykbec_write(sc, REG_BEEP_CONTROL, bctrl & ~BEEP_ENABLE); } if (volume != 0) { ykbec_write(sc, REG_BEEP_CONTROL, bctrl | BEEP_ENABLE); if (poll) { delay(period * 1000); ykbec_write(sc, REG_BEEP_CONTROL, bctrl & ~BEEP_ENABLE); } else { timeout_add_msec(&sc->sc_bell_tmo, period); } } splx(s); }
int re_pci_detach(struct device *self, int flags) { struct re_pci_softc *psc = (struct re_pci_softc *)self; struct rl_softc *sc = &psc->sc_rl; 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 (psc->sc_ih != NULL) pci_intr_disestablish(psc->sc_pc, psc->sc_ih); /* Free pci resources */ bus_space_unmap(sc->rl_btag, sc->rl_bhandle, psc->sc_iosize); return (0); }
void bestop(struct be_softc *sc) { int n; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t br = sc->sc_br; timeout_del(&sc->sc_tick_ch); /* Down the MII. */ mii_down(&sc->sc_mii); (void)be_intphy_service(sc, &sc->sc_mii, MII_DOWN); /* Stop the transmitter */ bus_space_write_4(t, br, BE_BRI_TXCFG, 0); for (n = 32; n > 0; n--) { if (bus_space_read_4(t, br, BE_BRI_TXCFG) == 0) break; DELAY(20); } /* Stop the receiver */ bus_space_write_4(t, br, BE_BRI_RXCFG, 0); for (n = 32; n > 0; n--) { if (bus_space_read_4(t, br, BE_BRI_RXCFG) == 0) break; DELAY(20); } }
void vnet_ldc_reset(struct ldc_conn *lc) { struct vnet_softc *sc = lc->lc_sc; int i; timeout_del(&sc->sc_handshake_to); sc->sc_tx_prod = sc->sc_tx_cons = 0; sc->sc_peer_state = VIO_DP_STOPPED; sc->sc_vio_state = 0; vnet_link_state(sc); sc->sc_lm->lm_next = 1; sc->sc_lm->lm_count = 1; for (i = 1; i < sc->sc_lm->lm_nentries; i++) sc->sc_lm->lm_slot[i].entry = 0; for (i = 0; i < sc->sc_vd->vd_nentries; i++) { if (sc->sc_vsd[i].vsd_buf) { pool_put(&sc->sc_pool, sc->sc_vsd[i].vsd_buf); sc->sc_vsd[i].vsd_buf = NULL; } sc->sc_vd->vd_desc[i].hdr.dstate = VIO_DESC_FREE; } }
EVQ_API int evq_del (struct event *ev, const int reuse_fd) { struct event_queue *evq = ev->evq; const unsigned int ev_flags = ev->flags; if (ev->tq) timeout_del(ev); ev->evq = NULL; evq->nevents--; if (ev_flags & EVENT_TIMER) return 0; if (ev_flags & EVENT_SIGNAL) return signal_del(evq, ev); if (ev_flags & EVENT_DIRWATCH) return close(ev->fd); if (!reuse_fd) return 0; return ((ev_flags & EVENT_READ) ? kqueue_set(evq, ev, EVFILT_READ, EV_DELETE) : 0) | ((ev_flags & EVENT_WRITE) ? kqueue_set(evq, ev, EVFILT_WRITE, EV_DELETE) : 0); }
void drm_vblank_cleanup(struct drm_device *dev) { #if defined(__NetBSD__) int i; #endif /* defined(__NetBSD__) */ if (dev->vblank == NULL) return; /* not initialised */ timeout_del(&dev->vblank->vb_disable_timer); #if defined(__NetBSD__) callout_destroy(&dev->vblank->vb_disable_timer); #endif /* defined(__NetBSD__) */ vblank_disable(dev); #if defined(__NetBSD__) for (i = 0; i < dev->vblank->vb_num; i++) cv_destroy(&dev->vblank->vb_crtcs[i].condvar); mutex_destroy(&dev->vblank->vb_lock); #endif /* defined(__NetBSD__) */ drm_free(dev->vblank); dev->vblank = NULL; }
void sunkbd_bell(struct sunkbd_softc *sc, u_int period, u_int pitch, u_int volume) { int ticks, s; u_int8_t c = SKBD_CMD_BELLON; #if NTCTRL > 0 if (tadpole_bell(period / 10, pitch, volume) != 0) return; #endif s = spltty(); if (sc->sc_bellactive) { if (sc->sc_belltimeout == 0) timeout_del(&sc->sc_bellto); } if (pitch == 0 || period == 0) { sunkbd_bellstop(sc); splx(s); return; } if (sc->sc_bellactive == 0) { ticks = (period * hz) / 1000; if (ticks <= 0) ticks = 1; sc->sc_bellactive = 1; sc->sc_belltimeout = 1; (*sc->sc_sendcmd)(sc, &c, 1); timeout_add(&sc->sc_bellto, ticks); } splx(s); }
void mec_stop(struct ifnet *ifp) { struct mec_softc *sc = ifp->if_softc; struct mec_txsoft *txs; int i; DPRINTF(MEC_DEBUG_STOP, ("mec_stop\n")); ifp->if_timer = 0; ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); timeout_del(&sc->sc_tick_ch); mii_down(&sc->sc_mii); /* Disable DMA. */ bus_space_write_8(sc->sc_st, sc->sc_sh, MEC_DMA_CONTROL, 0); /* Release any TX buffers. */ for (i = 0; i < MEC_NTXDESC; i++) { txs = &sc->sc_txsoft[i]; if ((txs->txs_flags & MEC_TXS_TXDPTR1) != 0) { bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap); m_freem(txs->txs_mbuf); txs->txs_mbuf = NULL; } } }
int sunkbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p) { struct sunkbd_softc *sc = v; int *d_int = (int *)data; struct wskbd_bell_data *d_bell = (struct wskbd_bell_data *)data; switch (cmd) { case WSKBDIO_GTYPE: if (ISTYPE5(sc->sc_layout)) { *d_int = WSKBD_TYPE_SUN5; } else { *d_int = WSKBD_TYPE_SUN; } return (0); case WSKBDIO_SETLEDS: sunkbd_setleds(sc, *d_int); return (0); case WSKBDIO_GETLEDS: *d_int = sunkbd_getleds(sc); return (0); case WSKBDIO_COMPLEXBELL: sunkbd_bell(sc, d_bell->period, d_bell->pitch, d_bell->volume); return (0); #ifdef WSDISPLAY_COMPAT_RAWKBD case WSKBDIO_SETMODE: sc->sc_rawkbd = *(int *)data == WSKBD_RAW; timeout_del(&sc->sc_rawrepeat_tmo); return (0); #endif } return (-1); }
int zts_enable(void *v) { struct zts_softc *sc = v; if (sc->sc_enabled) return EBUSY; timeout_del(&sc->sc_ts_poll); pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN); /* XXX */ if (sc->sc_gh == NULL) sc->sc_gh = pxa2x0_gpio_intr_establish(GPIO_TP_INT_C3K, IST_EDGE_FALLING, IPL_TTY, zts_irq, sc, sc->sc_dev.dv_xname); else pxa2x0_gpio_intr_unmask(sc->sc_gh); /* enable interrupts */ sc->sc_enabled = 1; sc->sc_running = 1; sc->sc_buttons = 0; return 0; }
/* * 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 dnkbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p) { #ifdef WSDISPLAY_COMPAT_RAWKBD struct dnkbd_softc *sc = v; #endif switch (cmd) { case WSKBDIO_GTYPE: *(int *)data = WSKBD_TYPE_DOMAIN; return (0); case WSKBDIO_SETLEDS: return (ENXIO); case WSKBDIO_GETLEDS: *(int *)data = 0; return (0); case WSKBDIO_COMPLEXBELL: #define d ((struct wskbd_bell_data *)data) dnkbd_bell(v, d->period, d->pitch, d->volume); #undef d return (0); #ifdef WSDISPLAY_COMPAT_RAWKBD case WSKBDIO_SETMODE: sc->sc_rawkbd = *(int *)data == WSKBD_RAW; timeout_del(&sc->sc_rawrepeat_ch); return (0); #endif } return (-1); }
int ukbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p) { struct ukbd_softc *sc = v; switch (cmd) { case WSKBDIO_GTYPE: *(int *)data = WSKBD_TYPE_USB; return (0); case WSKBDIO_SETLEDS: ukbd_set_leds(v, *(int *)data); return (0); case WSKBDIO_GETLEDS: *(int *)data = sc->sc_leds; return (0); case WSKBDIO_COMPLEXBELL: #define d ((struct wskbd_bell_data *)data) ukbd_bell(d->pitch, d->period, d->volume, 0); #undef d return (0); #ifdef WSDISPLAY_COMPAT_RAWKBD case WSKBDIO_SETMODE: DPRINTF(("ukbd_ioctl: set raw = %d\n", *(int *)data)); sc->sc_rawkbd = *(int *)data == WSKBD_RAW; timeout_del(&sc->sc_rawrepeat_ch); return (0); #endif } return (-1); }
void aps_power(int why, void *arg) { struct aps_softc *sc = (struct aps_softc *)arg; bus_space_tag_t iot = sc->aps_iot; bus_space_handle_t ioh = sc->aps_ioh; unsigned char iobuf[16]; if (why != PWR_RESUME) { timeout_del(&aps_timeout); return; } /* * Redo the init sequence on resume, because APS is * as forgetful as it is deaf. */ /* get APS mode */ iobuf[APS_CMD] = 0x13; if (aps_do_io(iot, ioh, iobuf, APS_WRITE_0, APS_READ_1) || aps_init(iot, ioh)) printf("aps: failed to wake up\n"); else timeout_add(&aps_timeout, (5 * hz) / 10); }
static int win32thr_del (struct win32thr *wth, struct event *ev) { int i, n = --wth->n; if (ev->tq) timeout_del(ev); ev->wth = NULL; wth->evq->nevents--; i = ev->w.index; if (ev->flags & EVENT_SOCKET) { HANDLE hEvent = wth->handles[i]; WSAEventSelect((int) ev->fd, hEvent, 0); CloseHandle(hEvent); } if (i < n) { ev = wth->events[n]; ev->w.index = i; wth->events[i] = ev; wth->handles[i] = wth->handles[n]; } wth->handles[n] = wth->signal; /* lower signal event */ if (ev->flags & EVENT_DIRWATCH) return !FindCloseChangeNotification(ev->fd); return 0; }
/* * Pass command to device during normal operation. * to be called at spltty() */ void pckbc_start(struct pckbc_internal *t, pckbc_slot_t slot) { struct pckbc_slotdata *q = t->t_slotdata[slot]; struct pckbc_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue); if (q->polling) { do { pckbc_poll_cmd1(t, slot, cmd); if (cmd->status) printf("pckbc_start: command error\n"); if (cmd->flags & KBC_CMDFLAG_SYNC) { wakeup(cmd); cmd = TAILQ_NEXT(cmd, next); } else { TAILQ_REMOVE(&q->cmdqueue, cmd, next); timeout_del(&t->t_cleanup); TAILQ_INSERT_TAIL(&q->freequeue, cmd, next); cmd = TAILQ_FIRST(&q->cmdqueue); } } while (cmd); return; } if (!pckbc_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) { printf("pckbc_start: send error\n"); /* XXX what now? */ return; } }
void vnet_ldc_start(struct ldc_conn *lc) { struct vnet_softc *sc = lc->lc_sc; timeout_del(&sc->sc_handshake_to); vnet_send_ver_info(sc, VNET_MAJOR, VNET_MINOR); }
int gre_clone_destroy(struct ifnet *ifp) { struct gre_softc *sc = ifp->if_softc; int s; s = splnet(); timeout_del(&sc->sc_ka_snd); timeout_del(&sc->sc_ka_hold); LIST_REMOVE(sc, sc_list); splx(s); if_detach(ifp); free(sc, M_DEVBUF); return (0); }
void lpt_detach_common(struct lpt_softc *sc) { timeout_del(&sc->sc_wakeup_tmo); if (sc->sc_state != 0) { sc->sc_state = 0; wakeup(sc); } }
int sysctl_wdog(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { int error, period; if (wdog_ctl_cb == NULL) return (EOPNOTSUPP); switch (name[0]) { case KERN_WATCHDOG_PERIOD: period = wdog_period; error = sysctl_int(oldp, oldlenp, newp, newlen, &period); if (error) return (error); if (newp) { timeout_del(&wdog_timeout); wdog_period = (*wdog_ctl_cb)(wdog_ctl_cb_arg, period); } break; case KERN_WATCHDOG_AUTO: error = sysctl_int(oldp, oldlenp, newp, newlen, &wdog_auto); if (error) return (error); if (wdog_auto && wdog_cookie == NULL) wdog_cookie = shutdownhook_establish(wdog_shutdown, NULL); else if (!wdog_auto && wdog_cookie) { shutdownhook_disestablish(wdog_cookie); wdog_cookie = NULL; } break; default: return (EINVAL); } if (wdog_auto && wdog_period > 0) { (void) (*wdog_ctl_cb)(wdog_ctl_cb_arg, wdog_period); timeout_add(&wdog_timeout, wdog_period * hz / 2); } else timeout_del(&wdog_timeout); return (error); }
int ste_intr(void *xsc) { struct ste_softc *sc; struct ifnet *ifp; u_int16_t status; int claimed = 0; sc = xsc; ifp = &sc->arpcom.ac_if; /* See if this is really our interrupt. */ if (!(CSR_READ_2(sc, STE_ISR) & STE_ISR_INTLATCH)) return claimed; for (;;) { status = CSR_READ_2(sc, STE_ISR_ACK); if (!(status & STE_INTRS)) break; claimed = 1; if (status & STE_ISR_RX_DMADONE) { ste_rxeoc(sc); ste_rxeof(sc); } if (status & STE_ISR_TX_DMADONE) ste_txeof(sc); if (status & STE_ISR_TX_DONE) ste_txeoc(sc); if (status & STE_ISR_STATS_OFLOW) { timeout_del(&sc->sc_stats_tmo); ste_stats_update(sc); } if (status & STE_ISR_LINKEVENT) mii_pollstat(&sc->sc_mii); if (status & STE_ISR_HOSTERR) { ste_reset(sc); ste_init(sc); } } /* Re-enable interrupts */ CSR_WRITE_2(sc, STE_IMR, STE_INTRS); if (ifp->if_flags & IFF_RUNNING && !IFQ_IS_EMPTY(&ifp->if_snd)) ste_start(ifp); return claimed; }
int octeon_eth_stop(struct ifnet *ifp, int disable) { struct octeon_eth_softc *sc = ifp->if_softc; timeout_del(&sc->sc_tick_misc_ch); timeout_del(&sc->sc_tick_free_ch); timeout_del(&sc->sc_resume_ch); mii_down(&sc->sc_mii); cn30xxgmx_port_enable(sc->sc_gmx_port, 0); /* Mark the interface as down and cancel the watchdog timer. */ CLR(ifp->if_flags, IFF_RUNNING | IFF_OACTIVE); ifp->if_timer = 0; return 0; }