static int
acpi_panasonic_attach(device_t dev)
{
struct acpi_panasonic_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_STATUS status;
int i;
sc = device_get_softc(dev);
sc->dev = dev;
sc->handle = acpi_get_handle(dev);
acpi_sc = acpi_device_get_parent_softc(dev);
/* Build sysctl tree */
sysctl_ctx_init(&sc->sysctl_ctx);
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
"panasonic", CTLFLAG_RD, 0, "");
for (i = 0; sysctl_table[i].name != NULL; i++) {
SYSCTL_ADD_PROC(&sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
sysctl_table[i].name,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
sc, i, acpi_panasonic_sysctl, "I", "");
}
#if 0
/* Activate hotkeys */
status = AcpiEvaluateObject(sc->handle, "", NULL, NULL);
if (ACPI_FAILURE(status)) {
device_printf(dev, "enable FN keys failed\n");
sysctl_ctx_free(&sc->sysctl_ctx);
return (ENXIO);
}
#endif
/* Handle notifies */
status = AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
acpi_panasonic_notify, sc);
if (ACPI_FAILURE(status)) {
device_printf(dev, "couldn't install notify handler - %s\n",
AcpiFormatException(status));
sysctl_ctx_free(&sc->sysctl_ctx);
return (ENXIO);
}
/* Install power profile event handler */
sc->power_evh = EVENTHANDLER_REGISTER(power_profile_change,
acpi_panasonic_power_profile, sc->handle, 0);
return (0);
}
/* ARGSUSED */
void
random_yarrow_deinit(void)
{
struct harvest *np;
enum esource e;
/* Deregister the randomness harvesting routine */
random_yarrow_deinit_harvester();
/*
* Command the hash/reseed thread to end and wait for it to finish
*/
random_kthread_control = -1;
tsleep((void *)&random_kthread_control, 0, "term", 0);
/* Destroy the harvest fifos */
while (!STAILQ_EMPTY(&emptyfifo.head)) {
np = STAILQ_FIRST(&emptyfifo.head);
STAILQ_REMOVE_HEAD(&emptyfifo.head, next);
free(np, M_ENTROPY);
}
for (e = RANDOM_START; e < ENTROPYSOURCE; e++) {
while (!STAILQ_EMPTY(&harvestfifo[e].head)) {
np = STAILQ_FIRST(&harvestfifo[e].head);
STAILQ_REMOVE_HEAD(&harvestfifo[e].head, next);
free(np, M_ENTROPY);
}
}
random_yarrow_deinit_alg();
mtx_destroy(&harvest_mtx);
sysctl_ctx_free(&random_clist);
}
void
ieee80211_sysctl_vdetach(struct ieee80211vap *vap)
{
if (vap->iv_sysctl != NULL) {
sysctl_ctx_free(vap->iv_sysctl);
free(vap->iv_sysctl, M_DEVBUF);
vap->iv_sysctl = NULL;
}
}
static int
acpi_fujitsu_detach(device_t dev)
{
struct acpi_fujitsu_softc *sc;
sc = device_get_softc(dev);
AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
acpi_fujitsu_notify_handler);
sysctl_ctx_free(&sc->sysctl_ctx);
return (0);
}
static int
vpd_detach (device_t dev)
{
struct vpd_softc *sc;
sc = device_get_softc(dev);
if (sc->res)
bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res);
sysctl_ctx_free(&sc->ctx);
return (0);
}
/********************************************************************************
* Free all of the resources associated with (sc).
*
* Should not be called if the controller is active.
*/
static void
twe_free(struct twe_softc *sc)
{
struct twe_request *tr;
debug_called(4);
/* throw away any command buffers */
while ((tr = twe_dequeue_free(sc)) != NULL)
twe_free_request(tr);
if (sc->twe_cmd != NULL) {
bus_dmamap_unload(sc->twe_cmd_dmat, sc->twe_cmdmap);
bus_dmamem_free(sc->twe_cmd_dmat, sc->twe_cmd, sc->twe_cmdmap);
}
if (sc->twe_immediate != NULL) {
bus_dmamap_unload(sc->twe_immediate_dmat, sc->twe_immediate_map);
bus_dmamem_free(sc->twe_immediate_dmat, sc->twe_immediate,
sc->twe_immediate_map);
}
if (sc->twe_immediate_dmat)
bus_dma_tag_destroy(sc->twe_immediate_dmat);
/* destroy the data-transfer DMA tag */
if (sc->twe_buffer_dmat)
bus_dma_tag_destroy(sc->twe_buffer_dmat);
/* disconnect the interrupt handler */
if (sc->twe_intr)
bus_teardown_intr(sc->twe_dev, sc->twe_irq, sc->twe_intr);
if (sc->twe_irq != NULL)
bus_release_resource(sc->twe_dev, SYS_RES_IRQ, 0, sc->twe_irq);
/* destroy the parent DMA tag */
if (sc->twe_parent_dmat)
bus_dma_tag_destroy(sc->twe_parent_dmat);
/* release the register window mapping */
if (sc->twe_io != NULL)
bus_release_resource(sc->twe_dev, SYS_RES_IOPORT, TWE_IO_CONFIG_REG, sc->twe_io);
/* destroy control device */
if (sc->twe_dev_t != (struct cdev *)NULL)
destroy_dev(sc->twe_dev_t);
sysctl_ctx_free(&sc->sysctl_ctx);
}
/**
* This function deinitalizes already registered ctl_table structures with
* the kernel and frees up previously allocated dynamic memory
*
* @param
* ieee80211vap
*
* @returns
* void
*/
void
ieee80211_sysctl_vdetach(struct ieee80211vap *vap)
{
return; //FIXME: Currently not handling this feature.
if (vap->iv_sysctl != NULL)
{
/* De-register sysctl table */
sysctl_ctx_free(vap->iv_sysctl->iv_sysctl_header);
/* Free previously allocated memory */
free(vap->iv_sysctl->sysctl_list[2].procname, M_DEVBUF);
free(vap->iv_sysctl, M_DEVBUF);
vap->iv_sysctl = NULL;
} /* End if <condition> */
return;
}
/*
* Function name: twa_free
* Description: Performs clean-up at the time of going down.
*
* Input: sc -- ptr to per ctlr structure
* Output: None
* Return value: None
*/
static void
twa_free(struct twa_softc *sc)
{
struct twa_request *tr;
twa_dbg_dprint_enter(3, sc);
/* Detach from CAM */
twa_cam_detach(sc);
/* Destroy dma handles. */
bus_dmamap_unload(sc->twa_dma_tag, sc->twa_cmd_map);
while ((tr = twa_dequeue_free(sc)) != NULL)
bus_dmamap_destroy(sc->twa_dma_tag, tr->tr_dma_map);
/* Free all memory allocated so far. */
if (sc->twa_req_buf)
free(sc->twa_req_buf, TWA_MALLOC_CLASS);
if (sc->twa_cmd_pkt_buf)
bus_dmamem_free(sc->twa_dma_tag, sc->twa_cmd_pkt_buf,
sc->twa_cmd_map);
if (sc->twa_aen_queue[0])
free (sc->twa_aen_queue[0], M_DEVBUF);
/* Destroy the data-transfer DMA tag. */
if (sc->twa_dma_tag)
bus_dma_tag_destroy(sc->twa_dma_tag);
/* Disconnect the interrupt handler. */
if (sc->twa_intr_handle)
bus_teardown_intr(sc->twa_bus_dev, sc->twa_irq_res,
sc->twa_intr_handle);
if (sc->twa_irq_res != NULL)
bus_release_resource(sc->twa_bus_dev, SYS_RES_IRQ,
0, sc->twa_irq_res);
/* Release the register window mapping. */
if (sc->twa_io_res != NULL)
bus_release_resource(sc->twa_bus_dev, SYS_RES_IOPORT,
TWA_IO_CONFIG_REG, sc->twa_io_res);
/* Destroy the control device. */
if (sc->twa_ctrl_dev != (struct cdev *)NULL)
destroy_dev(sc->twa_ctrl_dev);
sysctl_ctx_free(&sc->twa_sysctl_ctx);
}
static int
ahci_detach (device_t dev)
{
struct ahci_softc *sc = device_get_softc(dev);
int error = 0;
if (sc->sysctl_tree) {
sysctl_ctx_free(&sc->sysctl_ctx);
sc->sysctl_tree = NULL;
}
if (sc->sc_ad) {
error = sc->sc_ad->ad_detach(dev);
sc->sc_ad = NULL;
}
return(error);
}
static void mlx4_en_destroy_rl_res(struct mlx4_en_priv *priv,
int ring_id)
{
struct mlx4_en_tx_ring *ring;
struct mlx4_en_dev *mdev = priv->mdev;
ring = priv->tx_ring[ring_id];
mutex_lock(&mdev->state_lock);
/* Index was validated, thus ring is not NULL */
spin_lock(&ring->tx_lock);
if (ring->rl_data.user_valid == false) {
en_err(priv, "ring %d doesn't exist\n", ring_id);
spin_unlock(&ring->tx_lock);
return;
} else {
ring->rl_data.user_valid = false;
}
if (!drbr_empty(priv->dev, ring->br)) {
struct mbuf *m;
while ((m = buf_ring_dequeue_sc(ring->br)) != NULL) {
m_freem(m);
}
}
spin_unlock(&ring->tx_lock);
atomic_subtract_int(&priv->rate_limits[ring->rl_data.rate_index].ref, 1);
/* Deactivate resources */
if (priv->port_up) {
mlx4_en_deactivate_tx_ring(priv, ring);
mlx4_en_deactivate_cq(priv, priv->tx_cq[ring_id]);
msleep(10);
mlx4_en_free_tx_buf(priv->dev, ring);
}
mutex_unlock(&mdev->state_lock);
/* clear statistics */
ring->bytes = 0;
ring->packets = 0;
sysctl_ctx_free(&ring->rl_data.rl_stats_ctx);
/* Add index to re-use list */
priv->rate_limit_tx_ring_num--;
mlx4_en_rl_reused_index_insert(priv, ring_id);
}
static int
cxgbei_deactivate(struct adapter *sc)
{
struct cxgbei_data *ci = sc->iscsi_ulp_softc;
ASSERT_SYNCHRONIZED_OP(sc);
if (ci != NULL) {
sysctl_ctx_free(&ci->ctx);
t4_free_ppod_region(&ci->pr);
free_ci_counters(ci);
free(ci, M_CXGBE);
sc->iscsi_ulp_softc = NULL;
}
return (0);
}
static int
canbus_detach(device_t dev)
{
struct canbus_softc *sc = device_get_softc(dev);
/* I/O resource free */
release_ioresource(dev);
delete_ioresource(dev);
/* Dynamic sysctl tree destroy */
if (sysctl_ctx_free(&sc->canbus_sysctl_ctx)) {
device_printf(dev,
"can't free this context - other oids depend on it\n");
return (ENOTEMPTY);
}
return (0);
}
void
uether_ifdetach(struct usb_ether *ue)
{
struct ifnet *ifp;
/* wait for any post attach or other command to complete */
usb_proc_drain(&ue->ue_tq);
/* read "ifnet" pointer after taskqueue drain */
ifp = ue->ue_ifp;
if (ifp != NULL) {
/* we are not running any more */
UE_LOCK(ue);
ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
UE_UNLOCK(ue);
/* drain any callouts */
usb_callout_drain(&ue->ue_watchdog);
/* detach miibus */
if (ue->ue_miibus != NULL) {
mtx_lock(&Giant); /* device_xxx() depends on this */
device_delete_child(ue->ue_dev, ue->ue_miibus);
mtx_unlock(&Giant);
}
/* detach ethernet */
ether_ifdetach(ifp);
/* free interface instance */
if_free(ifp);
/* free sysctl */
sysctl_ctx_free(&ue->ue_sysctl_ctx);
/* free unit */
free_unr(ueunit, ue->ue_unit);
}
/* free taskqueue, if any */
usb_proc_free(&ue->ue_tq);
}
static int
ubt_detach(device_t self)
{
struct ubt_softc *sc = device_get_softc(self);
DPRINTF("sc=%p \n", sc);
sc->sc_dying = 1;
if (!sc->sc_ok)
return 0;
/* Detach HCI interface */
if (sc->sc_unit) {
hci_detach(sc->sc_unit);
sc->sc_unit = NULL;
}
/*
* Abort all pipes. Causes processes waiting for transfer to wake.
*
* Actually, hci_detach() above will call ubt_disable() which may
* call ubt_abortdealloc(), but lets be sure since doing it twice
* wont cause an error.
*/
ubt_abortdealloc(sc);
/* wait for all processes to finish */
if (sc->sc_refcnt-- > 0)
usb_detach_wait(sc->sc_dev);
if (sc->sysctl_tree != NULL) {
sc->sysctl_tree = NULL;
sysctl_ctx_free(&sc->sysctl_ctx);
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
DPRINTFN(1, "driver detached\n");
return 0;
}
static int
acpi_panasonic_detach(device_t dev)
{
struct acpi_panasonic_softc *sc;
sc = device_get_softc(dev);
/* Remove power profile event handler */
EVENTHANDLER_DEREGISTER(power_profile_change, sc->power_evh);
/* Remove notify handler */
AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
acpi_panasonic_notify);
/* Free sysctl tree */
sysctl_ctx_free(&sc->sysctl_ctx);
return (0);
}
static int
zy7_devcfg_init_fclk_sysctl(struct zy7_devcfg_softc *sc)
{
struct sysctl_oid *fclk_node;
char fclk_num[4];
int i;
sysctl_ctx_init(&sc->sysctl_tree);
sc->sysctl_tree_top = SYSCTL_ADD_NODE(&sc->sysctl_tree,
SYSCTL_STATIC_CHILDREN(_hw_fpga), OID_AUTO, "fclk",
CTLFLAG_RD, 0, "");
if (sc->sysctl_tree_top == NULL) {
sysctl_ctx_free(&sc->sysctl_tree);
return (-1);
}
for (i = 0; i < FCLK_NUM; i++) {
snprintf(fclk_num, sizeof(fclk_num), "%d", i);
fclk_node = SYSCTL_ADD_NODE(&sc->sysctl_tree,
SYSCTL_CHILDREN(sc->sysctl_tree_top), OID_AUTO, fclk_num,
CTLFLAG_RD, 0, "");
SYSCTL_ADD_INT(&sc->sysctl_tree,
SYSCTL_CHILDREN(fclk_node), OID_AUTO,
"actual_freq", CTLFLAG_RD,
&fclk_configs[i].actual_frequency, i,
"Actual frequency");
SYSCTL_ADD_PROC(&sc->sysctl_tree,
SYSCTL_CHILDREN(fclk_node), OID_AUTO,
"freq", CTLFLAG_RW | CTLTYPE_INT,
&fclk_configs[i], i,
zy7_devcfg_fclk_sysctl_freq,
"I", "Configured frequency");
SYSCTL_ADD_PROC(&sc->sysctl_tree,
SYSCTL_CHILDREN(fclk_node), OID_AUTO,
"source", CTLFLAG_RW | CTLTYPE_STRING,
&fclk_configs[i], i,
zy7_devcfg_fclk_sysctl_source,
"A", "Clock source");
}
return (0);
}
static int
ahci_attach (device_t dev)
{
struct ahci_softc *sc = device_get_softc(dev);
char name[16];
int error;
sc->sc_ad = ahci_lookup_device(dev);
if (sc->sc_ad == NULL)
return(ENXIO);
/*
* Some chipsets do not properly implement the AHCI spec and may
* require the link speed to be specifically requested.
*/
if (kgetenv("hint.ahci.force150"))
AhciForceGen = 1;
if (kgetenv("hint.ahci.force300"))
AhciForceGen = 2;
if (kgetenv("hint.ahci.force600"))
AhciForceGen = 3;
if (kgetenv("hint.ahci.nofeatures"))
AhciNoFeatures = -1;
if (kgetenv("hint.ahci.forcefbss"))
sc->sc_flags |= AHCI_F_FORCE_FBSS;
sysctl_ctx_init(&sc->sysctl_ctx);
ksnprintf(name, sizeof(name), "%s%d",
device_get_name(dev), device_get_unit(dev));
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_hw),
OID_AUTO, name, CTLFLAG_RD, 0, "");
error = sc->sc_ad->ad_attach(dev);
if (error) {
sysctl_ctx_free(&sc->sysctl_ctx);
sc->sysctl_tree = NULL;
}
return (error);
}
static void
pmpcleanup(struct cam_periph *periph)
{
struct pmp_softc *softc;
softc = (struct pmp_softc *)periph->softc;
cam_periph_unlock(periph);
/*
* If we can't free the sysctl tree, oh well...
*/
if ((softc->flags & PMP_FLAG_SCTX_INIT) != 0
&& sysctl_ctx_free(&softc->sysctl_ctx) != 0) {
xpt_print(periph->path, "can't remove sysctl context\n");
}
free(softc, M_DEVBUF);
cam_periph_lock(periph);
}
void
randomdev_deinit(void)
{
/* Deregister the randomness harvesting routine */
randomdev_deinit_harvester();
/*
* Command the hash/reseed thread to end and wait for it to finish
*/
random_kthread_control = -1;
tsleep((void *)&random_kthread_control, 0, "term", 0);
#if defined(RANDOM_YARROW)
random_yarrow_deinit_alg();
#endif
#if defined(RANDOM_FORTUNA)
random_fortuna_deinit_alg();
#endif
sysctl_ctx_free(&random_clist);
}
void
uether_ifdetach(struct usb_ether *ue)
{
struct ifnet *ifp;
/* wait for any post attach or other command to complete */
usb_proc_drain(&ue->ue_tq);
/* read "ifnet" pointer after taskqueue drain */
ifp = uether_getifp(ue);
if (ifp != NULL) {
/* we are not running any more */
UE_LOCK(ue);
ifp->if_flags &= ~IFF_RUNNING;
UE_UNLOCK(ue);
/* drain any callouts */
usb_callout_drain(&ue->ue_watchdog);
/* detach miibus */
if (ue->ue_miibus != NULL) {
device_delete_child(ue->ue_dev, ue->ue_miibus);
}
/* detach ethernet */
ether_ifdetach(ifp);
/* free sysctl */
sysctl_ctx_free(&ue->ue_sysctl_ctx);
/* free unit */
devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(ue), ue->ue_unit);
}
/* free taskqueue, if any */
usb_proc_free(&ue->ue_tq);
}
/*
* Stop the OS-specific port helper thread and kill the per-port lock.
*/
void
ahci_os_stop_port(struct ahci_port *ap)
{
if (ap->sysctl_tree) {
sysctl_ctx_free(&ap->sysctl_ctx);
ap->sysctl_tree = NULL;
}
if (ap->ap_thread) {
ahci_os_signal_port_thread(ap, AP_SIGF_STOP);
ahci_os_sleep(10);
if (ap->ap_thread) {
kprintf("%s: Waiting for thread to terminate\n",
PORTNAME(ap));
while (ap->ap_thread)
ahci_os_sleep(100);
kprintf("%s: thread terminated\n",
PORTNAME(ap));
}
}
lockuninit(&ap->ap_lock);
}
static int
mlx5e_ethtool_debug_stats(SYSCTL_HANDLER_ARGS)
{
struct mlx5e_priv *priv = arg1;
int error;
int sys_debug;
sys_debug = priv->sysctl_debug;
error = sysctl_handle_int(oidp, &priv->sysctl_debug, 0, req);
if (error || !req->newptr)
return (error);
priv->sysctl_debug = !!priv->sysctl_debug;
if (sys_debug == priv->sysctl_debug)
return (error);
if (priv->sysctl_debug)
mlx5e_create_stats(&priv->stats.port_stats_debug.ctx,
SYSCTL_CHILDREN(priv->sysctl_dev), "debug_stats",
mlx5e_port_stats_debug_desc, MLX5E_PORT_STATS_DEBUG_NUM,
priv->stats.port_stats_debug.arg);
else
sysctl_ctx_free(&priv->stats.port_stats_debug.ctx);
return (error);
}
static int
zy7_devcfg_detach(device_t dev)
{
struct zy7_devcfg_softc *sc = device_get_softc(dev);
if (sc->sysctl_tree_top != NULL) {
sysctl_ctx_free(&sc->sysctl_tree);
sc->sysctl_tree_top = NULL;
}
if (device_is_attached(dev))
bus_generic_detach(dev);
/* Get rid of /dev/devcfg0. */
if (sc->sc_ctl_dev != NULL)
destroy_dev(sc->sc_ctl_dev);
/* Teardown and release interrupt. */
if (sc->irq_res != NULL) {
if (sc->intrhandle)
bus_teardown_intr(dev, sc->irq_res, sc->intrhandle);
bus_release_resource(dev, SYS_RES_IRQ,
rman_get_rid(sc->irq_res), sc->irq_res);
}
/* Release memory resource. */
if (sc->mem_res != NULL)
bus_release_resource(dev, SYS_RES_MEMORY,
rman_get_rid(sc->mem_res), sc->mem_res);
zy7_devcfg_softc_p = NULL;
DEVCFG_SC_LOCK_DESTROY(sc);
return (0);
}
void
reiserfs_mod_unload(PDRIVER_OBJECT drvobp)
{
UNICODE_STRING dosdev;
extern int xfs_fstype;
if (reiserfs_type.fs_type != 0) {
reiserfs_unload();
}
vfs_unregisterfs("reiserfs");
#if 0
sysctl_ctx_free(nfssysctl_ctxp);
kmem_free(nfssysctl_ctxp);
/* remove symbolic-link to our device */
RtlInitUnicodeString(&dosdev, XFS_DOSDEV_NAME);
(void)IoDeleteSymbolicLink(&dosdev);
/* delete our device itself */
IoDeleteDevice(xfs_fsdevptr);
#endif
}
static int
tws_detach(device_t dev)
{
struct tws_softc *sc = device_get_softc(dev);
int i;
u_int32_t reg;
TWS_TRACE_DEBUG(sc, "entry", 0, 0);
mtx_lock(&sc->gen_lock);
tws_send_event(sc, TWS_UNINIT_START);
mtx_unlock(&sc->gen_lock);
/* needs to disable interrupt before detaching from cam */
tws_turn_off_interrupts(sc);
/* clear door bell */
tws_write_reg(sc, TWS_I2O0_HOBDBC, ~0, 4);
reg = tws_read_reg(sc, TWS_I2O0_HIMASK, 4);
TWS_TRACE_DEBUG(sc, "turn-off-intr", reg, 0);
sc->obfl_q_overrun = false;
tws_init_connect(sc, 1);
/* Teardown the state in our softc created in our attach routine. */
/* Disconnect the interrupt handler. */
tws_teardown_intr(sc);
/* Release irq resource */
for(i=0;i<sc->irqs;i++) {
if ( sc->irq_res[i] ){
if (bus_release_resource(sc->tws_dev,
SYS_RES_IRQ, sc->irq_res_id[i], sc->irq_res[i]))
TWS_TRACE(sc, "bus release irq resource",
i, sc->irq_res_id[i]);
}
}
if ( sc->intr_type == TWS_MSI ) {
pci_release_msi(sc->tws_dev);
}
tws_cam_detach(sc);
/* Release memory resource */
if ( sc->mfa_res ){
if (bus_release_resource(sc->tws_dev,
SYS_RES_MEMORY, sc->mfa_res_id, sc->mfa_res))
TWS_TRACE(sc, "bus release mem resource", 0, sc->mfa_res_id);
}
if ( sc->reg_res ){
if (bus_release_resource(sc->tws_dev,
SYS_RES_MEMORY, sc->reg_res_id, sc->reg_res))
TWS_TRACE(sc, "bus release mem resource", 0, sc->reg_res_id);
}
free(sc->reqs, M_TWS);
free(sc->sense_bufs, M_TWS);
free(sc->scan_ccb, M_TWS);
if (sc->ioctl_data_mem)
bus_dmamem_free(sc->data_tag, sc->ioctl_data_mem, sc->ioctl_data_map);
free(sc->aen_q.q, M_TWS);
free(sc->trace_q.q, M_TWS);
mtx_destroy(&sc->q_lock);
mtx_destroy(&sc->sim_lock);
mtx_destroy(&sc->gen_lock);
mtx_destroy(&sc->io_lock);
destroy_dev(sc->tws_cdev);
sysctl_ctx_free(&sc->tws_clist);
return (0);
}
static void
vmbus_chan_close_internal(struct vmbus_channel *chan)
{
struct vmbus_softc *sc = chan->ch_vmbus;
struct vmbus_msghc *mh;
struct vmbus_chanmsg_chclose *req;
struct taskqueue *tq = chan->ch_tq;
int error;
/* TODO: stringent check */
atomic_clear_int(&chan->ch_stflags, VMBUS_CHAN_ST_OPENED);
/*
* Free this channel's sysctl tree attached to its device's
* sysctl tree.
*/
sysctl_ctx_free(&chan->ch_sysctl_ctx);
/*
* Set ch_tq to NULL to avoid more requests be scheduled.
* XXX pretty broken; need rework.
*/
chan->ch_tq = NULL;
taskqueue_drain(tq, &chan->ch_task);
chan->ch_cb = NULL;
/*
* Close this channel.
*/
mh = vmbus_msghc_get(sc, sizeof(*req));
if (mh == NULL) {
device_printf(sc->vmbus_dev,
"can not get msg hypercall for chclose(chan%u)\n",
chan->ch_id);
return;
}
req = vmbus_msghc_dataptr(mh);
req->chm_hdr.chm_type = VMBUS_CHANMSG_TYPE_CHCLOSE;
req->chm_chanid = chan->ch_id;
error = vmbus_msghc_exec_noresult(mh);
vmbus_msghc_put(sc, mh);
if (error) {
device_printf(sc->vmbus_dev,
"chclose(chan%u) msg hypercall exec failed: %d\n",
chan->ch_id, error);
return;
} else if (bootverbose) {
device_printf(sc->vmbus_dev, "close chan%u\n", chan->ch_id);
}
/*
* Disconnect the TX+RX bufrings from this channel.
*/
if (chan->ch_bufring_gpadl) {
vmbus_chan_gpadl_disconnect(chan, chan->ch_bufring_gpadl);
chan->ch_bufring_gpadl = 0;
}
/*
* Destroy the TX+RX bufrings.
*/
if (chan->ch_bufring != NULL) {
hyperv_dmamem_free(&chan->ch_bufring_dma, chan->ch_bufring);
chan->ch_bufring = NULL;
}
}
void mlx4_en_invalidate_rl_ring(struct mlx4_en_priv *priv, uint32_t ring_id)
{
priv->tx_ring[ring_id]->rl_data.user_valid = false;
sysctl_ctx_free(&priv->tx_ring[ring_id]->rl_data.rl_stats_ctx);
}
static int
acpi_tz_attach(device_t dev)
{
struct acpi_tz_softc *sc;
struct acpi_softc *acpi_sc;
int error;
char oidname[8];
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
sc->tz_dev = dev;
sc->tz_handle = acpi_get_handle(dev);
sc->tz_requested = TZ_ACTIVE_NONE;
sc->tz_active = TZ_ACTIVE_UNKNOWN;
sc->tz_thflags = TZ_THFLAG_NONE;
sc->tz_cooling_proc = NULL;
sc->tz_cooling_proc_running = FALSE;
sc->tz_cooling_active = FALSE;
sc->tz_cooling_updated = FALSE;
sc->tz_cooling_enabled = FALSE;
/*
* Parse the current state of the thermal zone and build control
* structures. We don't need to worry about interference with the
* control thread since we haven't fully attached this device yet.
*/
if ((error = acpi_tz_establish(sc)) != 0)
return (error);
/*
* Register for any Notify events sent to this zone.
*/
AcpiInstallNotifyHandler(sc->tz_handle, ACPI_DEVICE_NOTIFY,
acpi_tz_notify_handler, sc);
/*
* Create our sysctl nodes.
*
* XXX we need a mechanism for adding nodes under ACPI.
*/
if (device_get_unit(dev) == 0) {
acpi_sc = acpi_device_get_parent_softc(dev);
sysctl_ctx_init(&acpi_tz_sysctl_ctx);
acpi_tz_sysctl_tree = SYSCTL_ADD_NODE(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, "thermal", CTLFLAG_RD, 0, "");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, "min_runtime", CTLFLAG_RW,
&acpi_tz_min_runtime, 0,
"minimum cooling run time in sec");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, "polling_rate", CTLFLAG_RW,
&acpi_tz_polling_rate, 0, "monitor polling interval in seconds");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree), OID_AUTO,
"user_override", CTLFLAG_RW, &acpi_tz_override, 0,
"allow override of thermal settings");
}
sysctl_ctx_init(&sc->tz_sysctl_ctx);
sprintf(oidname, "tz%d", device_get_unit(dev));
sc->tz_sysctl_tree = SYSCTL_ADD_NODE(&sc->tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, oidname, CTLFLAG_RD, 0, "");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD,
&sc->tz_temperature, 0, sysctl_handle_int,
"IK", "current thermal zone temperature");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "active", CTLTYPE_INT | CTLFLAG_RW,
sc, 0, acpi_tz_active_sysctl, "I", "cooling is active");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "passive_cooling", CTLTYPE_INT | CTLFLAG_RW,
sc, 0, acpi_tz_cooling_sysctl, "I",
"enable passive (speed reduction) cooling");
SYSCTL_ADD_INT(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "thermal_flags", CTLFLAG_RD,
&sc->tz_thflags, 0, "thermal zone flags");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_PSV", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.psv),
acpi_tz_temp_sysctl, "IK", "passive cooling temp setpoint");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_HOT", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.hot),
acpi_tz_temp_sysctl, "IK",
"too hot temp setpoint (suspend now)");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_CRT", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.crt),
acpi_tz_temp_sysctl, "IK",
"critical temp setpoint (shutdown now)");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_ACx", CTLTYPE_INT | CTLFLAG_RD,
&sc->tz_zone.ac, sizeof(sc->tz_zone.ac),
sysctl_handle_opaque, "IK", "");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TC1", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tc1),
acpi_tz_passive_sysctl, "I",
"thermal constant 1 for passive cooling");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TC2", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tc2),
acpi_tz_passive_sysctl, "I",
"thermal constant 2 for passive cooling");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TSP", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tsp),
acpi_tz_passive_sysctl, "I",
"thermal sampling period for passive cooling");
/*
* Create thread to service all of the thermal zones. Register
* our power profile event handler.
*/
sc->tz_event = EVENTHANDLER_REGISTER(power_profile_change,
acpi_tz_power_profile, sc, 0);
if (acpi_tz_proc == NULL) {
error = kproc_create(acpi_tz_thread, NULL, &acpi_tz_proc,
RFHIGHPID, 0, "acpi_thermal");
if (error != 0) {
device_printf(sc->tz_dev, "could not create thread - %d", error);
goto out;
}
}
/*
* Create a thread to handle passive cooling for 1st zone which
* has _PSV, _TSP, _TC1 and _TC2. Users can enable it for other
* zones manually for now.
*
* XXX We enable only one zone to avoid multiple zones conflict
* with each other since cpufreq currently sets all CPUs to the
* given frequency whereas it's possible for different thermal
* zones to specify independent settings for multiple CPUs.
*/
if (acpi_tz_cooling_unit < 0 && acpi_tz_cooling_is_available(sc))
sc->tz_cooling_enabled = TRUE;
if (sc->tz_cooling_enabled) {
error = acpi_tz_cooling_thread_start(sc);
if (error != 0) {
sc->tz_cooling_enabled = FALSE;
goto out;
}
acpi_tz_cooling_unit = device_get_unit(dev);
}
/*
* Flag the event handler for a manual invocation by our timeout.
* We defer it like this so that the rest of the subsystem has time
* to come up. Don't bother evaluating/printing the temperature at
* this point; on many systems it'll be bogus until the EC is running.
*/
sc->tz_flags |= TZ_FLAG_GETPROFILE;
out:
if (error != 0) {
EVENTHANDLER_DEREGISTER(power_profile_change, sc->tz_event);
AcpiRemoveNotifyHandler(sc->tz_handle, ACPI_DEVICE_NOTIFY,
acpi_tz_notify_handler);
sysctl_ctx_free(&sc->tz_sysctl_ctx);
}
return_VALUE (error);
}
static int
acpi_cpu_attach(device_t dev)
{
struct acpi_cpux_softc *sc = device_get_softc(dev);
ACPI_HANDLE handle;
device_t child;
int cpu_id, cpu_features;
struct acpi_softc *acpi_sc;
handle = acpi_get_handle(dev);
cpu_id = acpi_get_magic(dev);
acpi_sc = acpi_device_get_parent_softc(dev);
if (cpu_id == 0) {
sysctl_ctx_init(&sc->glob_sysctl_ctx);
sc->glob_sysctl_tree = SYSCTL_ADD_NODE(&sc->glob_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, "cpu", CTLFLAG_RD, 0,
"node for CPU global settings");
if (sc->glob_sysctl_tree == NULL)
return ENOMEM;
}
sysctl_ctx_init(&sc->pcpu_sysctl_ctx);
sc->pcpu_sysctl_tree = SYSCTL_ADD_NODE(&sc->pcpu_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, device_get_nameunit(dev), CTLFLAG_RD, 0,
"node for per-CPU settings");
if (sc->pcpu_sysctl_tree == NULL) {
sysctl_ctx_free(&sc->glob_sysctl_ctx);
return ENOMEM;
}
/*
* Before calling any CPU methods, collect child driver feature hints
* and notify ACPI of them. We support unified SMP power control
* so advertise this ourselves. Note this is not the same as independent
* SMP control where each CPU can have different settings.
*/
cpu_features = ACPI_PDC_MP_C1PXTX | ACPI_PDC_MP_C2C3;
cpu_features |= acpi_cpu_md_features();
/*
* CPU capabilities are specified as a buffer of 32-bit integers:
* revision, count, and one or more capabilities.
*/
if (cpu_features) {
ACPI_OBJECT_LIST arglist;
uint32_t cap_set[3];
ACPI_OBJECT arg[4];
ACPI_STATUS status;
/* UUID needed by _OSC evaluation */
static uint8_t cpu_oscuuid[16] = {
0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29, 0xBE, 0x47,
0x9E, 0xBD, 0xD8, 0x70, 0x58, 0x71, 0x39, 0x53
};
arglist.Pointer = arg;
arglist.Count = 4;
arg[0].Type = ACPI_TYPE_BUFFER;
arg[0].Buffer.Length = sizeof(cpu_oscuuid);
arg[0].Buffer.Pointer = cpu_oscuuid; /* UUID */
arg[1].Type = ACPI_TYPE_INTEGER;
arg[1].Integer.Value = 1; /* revision */
arg[2].Type = ACPI_TYPE_INTEGER;
arg[2].Integer.Value = 2; /* # of capabilities integers */
arg[3].Type = ACPI_TYPE_BUFFER;
arg[3].Buffer.Length = sizeof(cap_set[0]) * 2; /* capabilities buffer */
arg[3].Buffer.Pointer = (uint8_t *)cap_set;
cap_set[0] = 0;
cap_set[1] = cpu_features;
status = AcpiEvaluateObject(handle, "_OSC", &arglist, NULL);
if (!ACPI_SUCCESS(status)) {
if (bootverbose)
device_printf(dev, "_OSC failed, use _PDC\n");
arglist.Pointer = arg;
arglist.Count = 1;
arg[0].Type = ACPI_TYPE_BUFFER;
arg[0].Buffer.Length = sizeof(cap_set);
arg[0].Buffer.Pointer = (uint8_t *)cap_set;
cap_set[0] = 1; /* revision */
cap_set[1] = 1; /* # of capabilities integers */
cap_set[2] = cpu_features;
AcpiEvaluateObject(handle, "_PDC", &arglist, NULL);
}
}
child = BUS_ADD_CHILD(dev, dev, 0, "cpu_cst", -1);
if (child == NULL)
return ENXIO;
acpi_set_handle(child, handle);
acpi_set_magic(child, cpu_id);
sc->cpux_cst = child;
child = BUS_ADD_CHILD(dev, dev, 0, "cpu_pst", -1);
if (child == NULL)
return ENXIO;
acpi_set_handle(child, handle);
acpi_set_magic(child, cpu_id);
bus_generic_attach(dev);
AcpiInstallNotifyHandler(handle, ACPI_DEVICE_NOTIFY, acpi_cpu_notify, sc);
return 0;
}
/*
* Function name: tw_osli_free_resources
* Description: Performs clean-up at the time of going down.
*
* Input: sc -- ptr to OSL internal ctlr context
* Output: None
* Return value: None
*/
static TW_VOID
tw_osli_free_resources(struct twa_softc *sc)
{
struct tw_osli_req_context *req;
TW_INT32 error = 0;
tw_osli_dbg_dprintf(3, sc, "entered");
/* Detach from CAM */
tw_osli_cam_detach(sc);
if (sc->req_ctx_buf)
while ((req = tw_osli_req_q_remove_head(sc, TW_OSLI_FREE_Q)) !=
NULL) {
mtx_destroy(req->ioctl_wake_timeout_lock);
if ((error = bus_dmamap_destroy(sc->dma_tag,
req->dma_map)))
tw_osli_dbg_dprintf(1, sc,
"dmamap_destroy(dma) returned %d",
error);
}
if ((sc->ioctl_tag) && (sc->ioctl_map))
if ((error = bus_dmamap_destroy(sc->ioctl_tag, sc->ioctl_map)))
tw_osli_dbg_dprintf(1, sc,
"dmamap_destroy(ioctl) returned %d", error);
/* Free all memory allocated so far. */
if (sc->req_ctx_buf)
free(sc->req_ctx_buf, TW_OSLI_MALLOC_CLASS);
if (sc->non_dma_mem)
free(sc->non_dma_mem, TW_OSLI_MALLOC_CLASS);
if (sc->dma_mem) {
bus_dmamap_unload(sc->cmd_tag, sc->cmd_map);
bus_dmamem_free(sc->cmd_tag, sc->dma_mem,
sc->cmd_map);
}
if (sc->cmd_tag)
if ((error = bus_dma_tag_destroy(sc->cmd_tag)))
tw_osli_dbg_dprintf(1, sc,
"dma_tag_destroy(cmd) returned %d", error);
if (sc->dma_tag)
if ((error = bus_dma_tag_destroy(sc->dma_tag)))
tw_osli_dbg_dprintf(1, sc,
"dma_tag_destroy(dma) returned %d", error);
if (sc->ioctl_tag)
if ((error = bus_dma_tag_destroy(sc->ioctl_tag)))
tw_osli_dbg_dprintf(1, sc,
"dma_tag_destroy(ioctl) returned %d", error);
if (sc->parent_tag)
if ((error = bus_dma_tag_destroy(sc->parent_tag)))
tw_osli_dbg_dprintf(1, sc,
"dma_tag_destroy(parent) returned %d", error);
/* Disconnect the interrupt handler. */
if ((error = twa_teardown_intr(sc)))
tw_osli_dbg_dprintf(1, sc,
"teardown_intr returned %d", error);
if (sc->irq_res != NULL)
if ((error = bus_release_resource(sc->bus_dev,
SYS_RES_IRQ, sc->irq_res_id, sc->irq_res)))
tw_osli_dbg_dprintf(1, sc,
"release_resource(irq) returned %d", error);
/* Release the register window mapping. */
if (sc->reg_res != NULL)
if ((error = bus_release_resource(sc->bus_dev,
SYS_RES_MEMORY, sc->reg_res_id, sc->reg_res)))
tw_osli_dbg_dprintf(1, sc,
"release_resource(io) returned %d", error);
/* Destroy the control device. */
if (sc->ctrl_dev != (struct cdev *)NULL)
destroy_dev(sc->ctrl_dev);
if ((error = sysctl_ctx_free(&sc->sysctl_ctxt)))
tw_osli_dbg_dprintf(1, sc,
"sysctl_ctx_free returned %d", error);
}
