static int snd_als300_resume(struct pci_dev *pci) { struct snd_card *card = pci_get_drvdata(pci); struct snd_als300 *chip = card->private_data; pci_set_power_state(pci, PCI_D0); pci_restore_state(pci); if (pci_enable_device(pci) < 0) { printk(KERN_ERR "als300: pci_enable_device failed, " "disabling device\n"); snd_card_disconnect(card); return -EIO; } pci_set_master(pci); snd_als300_init(chip); snd_ac97_resume(chip->ac97); snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; }
int prism54_resume(struct pci_dev *pdev) { struct net_device *ndev = pci_get_drvdata(pdev); islpci_private *priv = ndev ? netdev_priv(ndev) : NULL; BUG_ON(!priv); pci_enable_device(pdev); printk(KERN_NOTICE "%s: got resume request\n", ndev->name); pci_restore_state(pdev); /* alright let's go into the PREBOOT state */ islpci_reset(priv, 1); netif_device_attach(ndev); netif_start_queue(ndev); return 0; }
static int ahc_linux_pci_dev_resume(struct pci_dev *pdev) { struct ahc_softc *ahc = pci_get_drvdata(pdev); int rc; pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); if ((rc = pci_enable_device(pdev))) { dev_printk(KERN_ERR, &pdev->dev, "failed to enable device after resume (%d)\n", rc); return rc; } pci_set_master(pdev); ahc_pci_resume(ahc); return (ahc_resume(ahc)); }
int chd_dec_pci_resume(struct pci_dev *pdev) { struct crystalhd_adp *adp; struct device *dev = &pdev->dev; BC_STATUS sts = BC_STS_SUCCESS; int rc; adp = (struct crystalhd_adp *)pci_get_drvdata(pdev); if (!adp) { dev_err(dev, "%s: could not get adp\n", __func__); return -ENODEV; } pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); /* device's irq possibly is changed, driver should take care */ if (pci_enable_device(pdev)) { dev_err(dev, "Failed to enable PCI device\n"); return 1; } pci_set_master(pdev); rc = chd_dec_enable_int(adp); if (rc) { dev_err(dev, "_enable_int err:%d\n", rc); pci_disable_device(pdev); return -ENODEV; } sts = crystalhd_resume(&adp->cmds); if (sts != BC_STS_SUCCESS) { dev_err(dev, "Crystal HD Resume %d\n", sts); pci_disable_device(pdev); return -ENODEV; } return 0; }
/** * genwqe_pci_fundamental_reset() - trigger a PCIe fundamental reset on the slot * * Note: pci_set_pcie_reset_state() is not implemented on all archs, so this * reset method will not work in all cases. * * Return: 0 on success or error code from pci_set_pcie_reset_state() */ static int genwqe_pci_fundamental_reset(struct pci_dev *pci_dev) { int rc; /* * lock pci config space access from userspace, * save state and issue PCIe fundamental reset */ pci_cfg_access_lock(pci_dev); pci_save_state(pci_dev); rc = pci_set_pcie_reset_state(pci_dev, pcie_warm_reset); if (!rc) { /* keep PCIe reset asserted for 250ms */ msleep(250); pci_set_pcie_reset_state(pci_dev, pcie_deassert_reset); /* Wait for 2s to reload flash and train the link */ msleep(2000); } pci_restore_state(pci_dev); pci_cfg_access_unlock(pci_dev); return rc; }
static int snd_atiixp_resume(struct device *dev) { struct pci_dev *pci = to_pci_dev(dev); struct snd_card *card = dev_get_drvdata(dev); struct atiixp *chip = card->private_data; int i; pci_set_power_state(pci, PCI_D0); pci_restore_state(pci); if (pci_enable_device(pci) < 0) { printk(KERN_ERR "atiixp: pci_enable_device failed, " "disabling device\n"); snd_card_disconnect(card); return -EIO; } pci_set_master(pci); snd_atiixp_aclink_reset(chip); snd_atiixp_chip_start(chip); for (i = 0; i < NUM_ATI_CODECS; i++) snd_ac97_resume(chip->ac97[i]); for (i = 0; i < NUM_ATI_PCMDEVS; i++) if (chip->pcmdevs[i]) { struct atiixp_dma *dma = &chip->dmas[i]; if (dma->substream && dma->suspended) { dma->ops->enable_dma(chip, 1); dma->substream->ops->prepare(dma->substream); writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN, chip->remap_addr + dma->ops->llp_offset); writel(dma->saved_curptr, chip->remap_addr + dma->ops->dt_cur); } } snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; }
static int chd_dec_pci_resume(struct pci_dev *pdev) { struct crystalhd_adp *adp; enum BC_STATUS sts = BC_STS_SUCCESS; int rc; adp = pci_get_drvdata(pdev); if (!adp) { BCMLOG_ERR("could not get adp\n"); return -ENODEV; } pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); /* device's irq possibly is changed, driver should take care */ if (pci_enable_device(pdev)) { BCMLOG_ERR("Failed to enable PCI device\n"); return 1; } pci_set_master(pdev); rc = chd_dec_enable_int(adp); if (rc) { BCMLOG_ERR("_enable_int err:%d\n", rc); pci_disable_device(pdev); return -ENODEV; } sts = crystalhd_resume(&adp->cmds); if (sts != BC_STS_SUCCESS) { BCMLOG_ERR("BCM70012 Resume %d\n", sts); pci_disable_device(pdev); return -ENODEV; } return 0; }
static int nm256_resume(struct device *dev) { struct pci_dev *pci = to_pci_dev(dev); struct snd_card *card = dev_get_drvdata(dev); struct nm256 *chip = card->private_data; int i; /* Perform a full reset on the hardware */ chip->in_resume = 1; pci_set_power_state(pci, PCI_D0); pci_restore_state(pci); if (pci_enable_device(pci) < 0) { printk(KERN_ERR "nm256: pci_enable_device failed, " "disabling device\n"); snd_card_disconnect(card); return -EIO; } pci_set_master(pci); snd_nm256_init_chip(chip); /* restore ac97 */ snd_ac97_resume(chip->ac97); for (i = 0; i < 2; i++) { struct nm256_stream *s = &chip->streams[i]; if (s->substream && s->suspended) { spin_lock_irq(&chip->reg_lock); snd_nm256_set_format(chip, s, s->substream); spin_unlock_irq(&chip->reg_lock); } } snd_power_change_state(card, SNDRV_CTL_POWER_D0); chip->in_resume = 0; return 0; }
void warp_fpga_reconfig(void) { struct warp_fpga *chip = warp_fpga_getdevice(); disable_irq(chip->irq); #ifndef WARP_V2 pci_save_state(chip->pdev); pci_disable_device(chip->pdev); #endif fpga_write(chip->fpga, FPGA_CONFIG, fpga_read(chip->fpga, FPGA_CONFIG) | TRIGGER_RECONFIG_FLAG ); udelay(100); fpga_write(chip->fpga, FPGA_CONFIG, fpga_read(chip->fpga, FPGA_CONFIG) & ~ TRIGGER_RECONFIG_FLAG ); ssleep(5); #ifndef WARP_V2 pci_restore_state(chip->pdev); pci_enable_device(chip->pdev); #endif enable_irq(chip->irq); }
static int ahd_linux_pci_dev_resume(struct pci_dev *pdev) { struct ahd_softc *ahd = pci_get_drvdata(pdev); int rc; pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); if ((rc = pci_enable_device(pdev))) { // dev_printk(KERN_ERR, &pdev->dev, ; return rc; } pci_set_master(pdev); ahd_pci_resume(ahd); ahd_resume(ahd); return rc; }
static int b44_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct b44 *bp = dev->priv; pci_restore_state(pdev, bp->pci_cfg_state); if (!netif_running(dev)) return 0; spin_lock_irq(&bp->lock); b44_init_rings(bp); b44_init_hw(bp); netif_device_attach(bp->dev); spin_unlock_irq(&bp->lock); bp->timer.expires = jiffies + HZ; add_timer(&bp->timer); b44_enable_ints(bp); return 0; }
static int wl_resume(struct pci_dev *pdev) { struct wl_info *wl; struct ieee80211_hw *hw; int err = 0; u32 val; hw = pci_get_drvdata(pdev); wl = HW_TO_WL(hw); if (!wl) { wiphy_err(wl->wiphy, "wl: wl_resume: pci_get_drvdata failed\n"); return -ENODEV; } err = pci_set_power_state(pdev, PCI_D0); if (err) return err; pci_restore_state(pdev); err = pci_enable_device(pdev); if (err) return err; pci_set_master(pdev); pci_read_config_dword(pdev, 0x40, &val); if ((val & 0x0000ff00) != 0) pci_write_config_dword(pdev, 0x40, val & 0xffff00ff); /* * done. driver will be put in up state * in wl_ops_add_interface() call. */ return err; }
static int orinoco_pci_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct orinoco_private *priv = netdev_priv(dev); unsigned long flags; int err; printk(KERN_DEBUG "%s: Orinoco-PCI waking up\n", dev->name); pci_set_power_state(pdev, 0); pci_restore_state(pdev); err = orinoco_reinit_firmware(dev); if (err) { printk(KERN_ERR "%s: Error %d re-initializing firmware on orinoco_pci_resume()\n", dev->name, err); return err; } spin_lock_irqsave(&priv->lock, flags); netif_device_attach(dev); priv->hw_unavailable--; if (priv->open && (! priv->hw_unavailable)) { err = __orinoco_up(dev); if (err) printk(KERN_ERR "%s: Error %d restarting card on orinoco_pci_resume()\n", dev->name, err); } spin_unlock_irqrestore(&priv->lock, flags); return 0; }
/** * gma_resume_pci - resume helper * @dev: our PCI device * * Perform the resume processing on our PCI device state - rewrite * register state and re-enable the PCI device */ static bool gma_resume_pci(struct pci_dev *pdev) { struct drm_device *dev = pci_get_drvdata(pdev); struct drm_psb_private *dev_priv = dev->dev_private; int ret; if (!dev_priv->suspended) return true; pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); pci_write_config_dword(pdev, 0x5c, dev_priv->regs.saveBSM); pci_write_config_dword(pdev, 0xFC, dev_priv->regs.saveVBT); /* restoring MSI address and data in PCIx space */ pci_write_config_dword(pdev, PSB_PCIx_MSI_ADDR_LOC, dev_priv->msi_addr); pci_write_config_dword(pdev, PSB_PCIx_MSI_DATA_LOC, dev_priv->msi_data); ret = pci_enable_device(pdev); if (ret != 0) dev_err(&pdev->dev, "pci_enable failed: %d\n", ret); else dev_priv->suspended = false; return !dev_priv->suspended; }
static int __falcon_reset_hw(struct efx_nic *efx, enum reset_type method) { struct falcon_nic_data *nic_data = efx->nic_data; efx_oword_t glb_ctl_reg_ker; int rc; netif_dbg(efx, hw, efx->net_dev, "performing %s hardware reset\n", RESET_TYPE(method)); if (method == RESET_TYPE_WORLD) { rc = pci_save_state(efx->pci_dev); if (rc) { netif_err(efx, drv, efx->net_dev, "failed to backup PCI state of primary " "function prior to hardware reset\n"); goto fail1; } if (efx_nic_is_dual_func(efx)) { rc = pci_save_state(nic_data->pci_dev2); if (rc) { netif_err(efx, drv, efx->net_dev, "failed to backup PCI state of " "secondary function prior to " "hardware reset\n"); goto fail2; } } EFX_POPULATE_OWORD_2(glb_ctl_reg_ker, FRF_AB_EXT_PHY_RST_DUR, FFE_AB_EXT_PHY_RST_DUR_10240US, FRF_AB_SWRST, 1); } else { EFX_POPULATE_OWORD_7(glb_ctl_reg_ker, FRF_AB_EXT_PHY_RST_CTL, method == RESET_TYPE_INVISIBLE, FRF_AB_PCIE_CORE_RST_CTL, 1, FRF_AB_PCIE_NSTKY_RST_CTL, 1, FRF_AB_PCIE_SD_RST_CTL, 1, FRF_AB_EE_RST_CTL, 1, FRF_AB_EXT_PHY_RST_DUR, FFE_AB_EXT_PHY_RST_DUR_10240US, FRF_AB_SWRST, 1); } efx_writeo(efx, &glb_ctl_reg_ker, FR_AB_GLB_CTL); netif_dbg(efx, hw, efx->net_dev, "waiting for hardware reset\n"); schedule_timeout_uninterruptible(HZ / 20); if (method == RESET_TYPE_WORLD) { if (efx_nic_is_dual_func(efx)) pci_restore_state(nic_data->pci_dev2); pci_restore_state(efx->pci_dev); netif_dbg(efx, drv, efx->net_dev, "successfully restored PCI config\n"); } efx_reado(efx, &glb_ctl_reg_ker, FR_AB_GLB_CTL); if (EFX_OWORD_FIELD(glb_ctl_reg_ker, FRF_AB_SWRST) != 0) { rc = -ETIMEDOUT; netif_err(efx, hw, efx->net_dev, "timed out waiting for hardware reset\n"); goto fail3; } netif_dbg(efx, hw, efx->net_dev, "hardware reset complete\n"); return 0; fail2: pci_restore_state(efx->pci_dev); fail1: fail3: return rc; }
static int ioat_reset_hw(struct ioat_softc *ioat) { uint64_t status; uint32_t chanerr; unsigned timeout; int error; mtx_lock(IOAT_REFLK); ioat->quiescing = TRUE; ioat_drain_locked(ioat); mtx_unlock(IOAT_REFLK); status = ioat_get_chansts(ioat); if (is_ioat_active(status) || is_ioat_idle(status)) ioat_suspend(ioat); /* Wait at most 20 ms */ for (timeout = 0; (is_ioat_active(status) || is_ioat_idle(status)) && timeout < 20; timeout++) { DELAY(1000); status = ioat_get_chansts(ioat); } if (timeout == 20) { error = ETIMEDOUT; goto out; } KASSERT(ioat_get_active(ioat) == 0, ("active after quiesce")); chanerr = ioat_read_4(ioat, IOAT_CHANERR_OFFSET); ioat_write_4(ioat, IOAT_CHANERR_OFFSET, chanerr); /* * IOAT v3 workaround - CHANERRMSK_INT with 3E07h to masks out errors * that can cause stability issues for IOAT v3. */ pci_write_config(ioat->device, IOAT_CFG_CHANERRMASK_INT_OFFSET, 0x3e07, 4); chanerr = pci_read_config(ioat->device, IOAT_CFG_CHANERR_INT_OFFSET, 4); pci_write_config(ioat->device, IOAT_CFG_CHANERR_INT_OFFSET, chanerr, 4); /* * BDXDE and BWD models reset MSI-X registers on device reset. * Save/restore their contents manually. */ if (ioat_model_resets_msix(ioat)) { ioat_log_message(1, "device resets MSI-X registers; saving\n"); pci_save_state(ioat->device); } ioat_reset(ioat); /* Wait at most 20 ms */ for (timeout = 0; ioat_reset_pending(ioat) && timeout < 20; timeout++) DELAY(1000); if (timeout == 20) { error = ETIMEDOUT; goto out; } if (ioat_model_resets_msix(ioat)) { ioat_log_message(1, "device resets registers; restored\n"); pci_restore_state(ioat->device); } /* Reset attempts to return the hardware to "halted." */ status = ioat_get_chansts(ioat); if (is_ioat_active(status) || is_ioat_idle(status)) { /* So this really shouldn't happen... */ ioat_log_message(0, "Device is active after a reset?\n"); ioat_write_chanctrl(ioat, IOAT_CHANCTRL_RUN); error = 0; goto out; } chanerr = ioat_read_4(ioat, IOAT_CHANERR_OFFSET); if (chanerr != 0) { mtx_lock(&ioat->cleanup_lock); ioat_halted_debug(ioat, chanerr); mtx_unlock(&ioat->cleanup_lock); error = EIO; goto out; } /* * Bring device back online after reset. Writing CHAINADDR brings the * device back to active. * * The internal ring counter resets to zero, so we have to start over * at zero as well. */ ioat->tail = ioat->head = ioat->hw_head = 0; ioat->last_seen = 0; ioat_write_chanctrl(ioat, IOAT_CHANCTRL_RUN); ioat_write_chancmp(ioat, ioat->comp_update_bus_addr); ioat_write_chainaddr(ioat, ioat->ring[0]->hw_desc_bus_addr); error = 0; out: mtx_lock(IOAT_REFLK); ioat->quiescing = FALSE; mtx_unlock(IOAT_REFLK); if (error == 0) error = ioat_start_channel(ioat); return (error); }
int rtl8192E_resume (struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); #ifdef _RTL8192_EXT_PATCH_ struct net_device *meshdev = priv->rtllib->meshdev; #endif int err; u32 val; RT_TRACE(COMP_POWER, "================>r8192E resume call."); printk("================>r8192E resume call.\n"); pci_set_power_state(pdev, PCI_D0); err = pci_enable_device(pdev); if(err) { printk(KERN_ERR "%s: pci_enable_device failed on resume\n", dev->name); return err; } #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)) pci_restore_state(pdev,&(priv->pci_state)); #else pci_restore_state(pdev); #endif pci_read_config_dword(pdev, 0x40, &val); if ((val & 0x0000ff00) != 0) { pci_write_config_dword(pdev, 0x40, val & 0xffff00ff); } pci_enable_wake(pdev, PCI_D0, 0); #ifdef ENABLE_GPIO_RADIO_CTL if(priv->polling_timer_on == 0){ check_rfctrl_gpio_timer((unsigned long)dev); } #endif #ifdef _RTL8192_EXT_PATCH_ if ((!netif_running(dev)) && (!netif_running(meshdev))) #else if(!netif_running(dev)) #endif { printk("RTL819XE:UI is open out of resume function\n"); goto out; } netif_device_attach(dev); #ifdef HAVE_NET_DEVICE_OPS if (priv->rtllib->wlan_up_before_suspend) { if (dev->netdev_ops->ndo_open) dev->netdev_ops->ndo_open(dev); } #ifdef _RTL8192_EXT_PATCH_ if (priv->rtllib->mesh_up_before_suspend) { if (meshdev->netdev_ops->ndo_open) meshdev->netdev_ops->ndo_open(meshdev); netif_carrier_on(meshdev); } #endif #else if (priv->rtllib->wlan_up_before_suspend) { dev->open(dev); } #ifdef _RTL8192_EXT_PATCH_ if (priv->rtllib->mesh_up_before_suspend) { meshdev->open(meshdev); netif_carrier_on(meshdev); } #endif #endif #if !(defined RTL8192SE || defined RTL8192CE) if(!priv->rtllib->bSupportRemoteWakeUp) { MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_INIT,true); } #endif out: RT_TRACE(COMP_POWER, "<================r8192E resume call.\n"); return 0; }
static int rt2860_resume( struct pci_dev *pci_dev) { struct net_device *net_dev = pci_get_drvdata(pci_dev); PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)NULL; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) INT32 retval; retval = pci_set_power_state(pci_dev, PCI_D0); pci_restore_state(pci_dev); if (pci_enable_device(pci_dev)) { printk("pci enable fail!\n"); return 0; } #endif DBGPRINT(RT_DEBUG_TRACE, ("===> rt2860_resume()\n")); if (net_dev == NULL) { DBGPRINT(RT_DEBUG_ERROR, ("net_dev == NULL!\n")); } else pAd = (PRTMP_ADAPTER)RTMP_OS_NETDEV_GET_PRIV(net_dev); if (pAd != NULL) { if (VIRTUAL_IF_NUM(pAd) > 0) { netif_device_attach(net_dev); if (rt28xx_open((PNET_DEV)net_dev) != 0) { DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2860_resume()\n")); return 0; } RT_MOD_INC_USE_COUNT(); RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS); RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF); netif_start_queue(net_dev); netif_carrier_on(net_dev); netif_wake_queue(net_dev); } } DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2860_resume()\n")); return 0; }
static int rtl8180_resume(struct pci_dev *pdev) { pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); return 0; }
/** * usb_hcd_pci_resume - power management resume of a PCI-based HCD * @dev: USB Host Controller being resumed * * Store this function in the HCD's struct pci_driver as resume(). */ int usb_hcd_pci_resume (struct pci_dev *dev) { struct usb_hcd *hcd; int retval; hcd = pci_get_drvdata(dev); if (hcd->state != HC_STATE_SUSPENDED) { dev_dbg (hcd->self.controller, "can't resume, not suspended!\n"); return 0; } /* NOTE: chip docs cover clean "real suspend" cases (what Linux * calls "standby", "suspend to RAM", and so on). There are also * dirty cases when swsusp fakes a suspend in "shutdown" mode. */ if (dev->current_state != PCI_D0) { #ifdef DEBUG int pci_pm; u16 pmcr; pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM); pci_read_config_word(dev, pci_pm + PCI_PM_CTRL, &pmcr); pmcr &= PCI_PM_CTRL_STATE_MASK; if (pmcr) { /* Clean case: power to USB and to HC registers was * maintained; remote wakeup is easy. */ dev_dbg(hcd->self.controller, "resume from PCI D%d\n", pmcr); } else { /* Clean: HC lost Vcc power, D0 uninitialized * + Vaux may have preserved port and transceiver * state ... for remote wakeup from D3cold * + or not; HCD must reinit + re-enumerate * * Dirty: D0 semi-initialized cases with swsusp * + after BIOS init * + after Linux init (HCD statically linked) */ dev_dbg(hcd->self.controller, "PCI D0, from previous PCI D%d\n", dev->current_state); } #endif pci_enable_wake (dev, dev->current_state, 0); pci_enable_wake (dev, PCI_D3cold, 0); } else { /* Same basic cases: clean (powered/not), dirty */ dev_dbg(hcd->self.controller, "PCI legacy resume\n"); } /* NOTE: the PCI API itself is asymmetric here. We don't need to * pci_set_power_state(PCI_D0) since that's part of re-enabling; * but that won't re-enable bus mastering. Yet pci_disable_device() * explicitly disables bus mastering... */ retval = pci_enable_device (dev); if (retval < 0) { dev_err (hcd->self.controller, "can't re-enable after resume, %d!\n", retval); return retval; } pci_set_master (dev); pci_restore_state (dev); dev->dev.power.power_state = PMSG_ON; hcd->state = HC_STATE_RESUMING; hcd->saw_irq = 0; retval = request_irq (dev->irq, usb_hcd_irq, SA_SHIRQ, hcd->irq_descr, hcd); if (retval < 0) { dev_err (hcd->self.controller, "can't restore IRQ after resume!\n"); usb_hc_died (hcd); return retval; } retval = hcd->driver->resume (hcd); if (!HC_IS_RUNNING (hcd->state)) { dev_dbg (hcd->self.controller, "resume fail, retval %d\n", retval); usb_hc_died (hcd); } pci_enable_device(dev); return retval; }
/** * usb_hcd_pci_resume - power management resume of a PCI-based HCD * @dev: USB Host Controller being resumed * * Store this function in the HCD's struct pci_driver as resume(). */ int usb_hcd_pci_resume (struct pci_dev *dev) { struct usb_hcd *hcd; int retval; hcd = pci_get_drvdata(dev); if (hcd->state != HC_STATE_SUSPENDED) { dev_dbg (hcd->self.controller, "can't resume, not suspended!\n"); return 0; } #ifdef CONFIG_PPC_PMAC /* Reenable ASIC clocks for USB */ if (machine_is(powermac)) { struct device_node *of_node; of_node = pci_device_to_OF_node (dev); if (of_node) pmac_call_feature (PMAC_FTR_USB_ENABLE, of_node, 0, 1); } #endif /* NOTE: chip docs cover clean "real suspend" cases (what Linux * calls "standby", "suspend to RAM", and so on). There are also * dirty cases when swsusp fakes a suspend in "shutdown" mode. */ if (dev->current_state != PCI_D0) { #ifdef DEBUG int pci_pm; u16 pmcr; pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM); pci_read_config_word(dev, pci_pm + PCI_PM_CTRL, &pmcr); pmcr &= PCI_PM_CTRL_STATE_MASK; if (pmcr) { /* Clean case: power to USB and to HC registers was * maintained; remote wakeup is easy. */ dev_dbg(hcd->self.controller, "resume from PCI D%d\n", pmcr); } else { /* Clean: HC lost Vcc power, D0 uninitialized * + Vaux may have preserved port and transceiver * state ... for remote wakeup from D3cold * + or not; HCD must reinit + re-enumerate * * Dirty: D0 semi-initialized cases with swsusp * + after BIOS init * + after Linux init (HCD statically linked) */ dev_dbg(hcd->self.controller, "PCI D0, from previous PCI D%d\n", dev->current_state); } #endif /* yes, ignore these results too... */ (void) pci_enable_wake (dev, dev->current_state, 0); (void) pci_enable_wake (dev, PCI_D3cold, 0); } else { /* Same basic cases: clean (powered/not), dirty */ dev_dbg(hcd->self.controller, "PCI legacy resume\n"); } /* NOTE: the PCI API itself is asymmetric here. We don't need to * pci_set_power_state(PCI_D0) since that's part of re-enabling; * but that won't re-enable bus mastering. Yet pci_disable_device() * explicitly disables bus mastering... */ retval = pci_enable_device (dev); if (retval < 0) { dev_err (hcd->self.controller, "can't re-enable after resume, %d!\n", retval); return retval; } pci_set_master (dev); pci_restore_state (dev); dev->dev.power.power_state = PMSG_ON; clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags); if (hcd->driver->resume) { retval = hcd->driver->resume(hcd); if (retval) { dev_err (hcd->self.controller, "PCI post-resume error %d!\n", retval); usb_hc_died (hcd); } } return retval; }
int cnss_wlan_register_driver(struct cnss_wlan_driver *driver) { int ret = 0; struct cnss_wlan_driver *wdrv; struct cnss_wlan_vreg_info *vreg_info; struct cnss_wlan_gpio_info *gpio_info; struct pci_dev *pdev; if (!penv) return -ENODEV; wdrv = penv->driver; vreg_info = &penv->vreg_info; gpio_info = &penv->gpio_info; pdev = penv->pdev; if (!wdrv) { penv->driver = wdrv = driver; } else { pr_err("driver already registered\n"); return -EEXIST; } ret = cnss_wlan_vreg_set(vreg_info, VREG_ON); if (ret) { pr_err("wlan vreg ON failed\n"); goto err_wlan_vreg_on; } usleep(POWER_ON_DELAY); cnss_wlan_gpio_set(gpio_info, WLAN_EN_HIGH); usleep(WLAN_ENABLE_DELAY); if (!pdev) { pr_debug("%s: invalid pdev. register pci device\n", __func__); ret = pci_register_driver(&cnss_wlan_pci_driver); if (ret) { pr_err("%s: pci registration failed\n", __func__); goto err_pcie_link_up; } pdev = penv->pdev; if (!pdev) { pr_err("%s: pdev is still invalid\n", __func__); goto err_pcie_link_up; } } if (!penv->pcie_link_state) { ret = msm_pcie_pm_control(MSM_PCIE_RESUME, cnss_get_pci_dev_bus_number(pdev), NULL, NULL, PM_OPTIONS); if (ret) { pr_err("PCIe link bring-up failed\n"); goto err_pcie_link_up; } penv->pcie_link_state = PCIE_LINK_UP; } if (wdrv->probe) { if (penv->saved_state) pci_load_and_free_saved_state(pdev, &penv->saved_state); pci_restore_state(pdev); ret = wdrv->probe(pdev, penv->id); if (ret) { pr_err("Failed to probe WLAN\n"); goto err_wlan_probe; } } if (pdev && wdrv->modem_status) wdrv->modem_status(pdev, penv->modem_current_status); return ret; err_wlan_probe: pci_save_state(pdev); penv->saved_state = pci_store_saved_state(pdev); msm_pcie_pm_control(MSM_PCIE_SUSPEND, cnss_get_pci_dev_bus_number(pdev), NULL, NULL, PM_OPTIONS); penv->pcie_link_state = PCIE_LINK_DOWN; err_pcie_link_up: cnss_wlan_gpio_set(gpio_info, WLAN_EN_LOW); cnss_wlan_vreg_set(vreg_info, VREG_OFF); if (pdev) { pr_err("%d: Unregistering PCI device\n", __LINE__); pci_unregister_driver(&cnss_wlan_pci_driver); penv->pdev = NULL; penv->pci_register_again = true; } err_wlan_vreg_on: penv->driver = NULL; return ret; }
static int rt_pci_resume(struct pci_dev *pci_dev) { struct net_device *net_dev = pci_get_drvdata(pci_dev); VOID *pAd = NULL; #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10) INT32 retval; /* Set the power state of a PCI device PCI has 4 power states, DO (normal) ~ D3(less power) you can find that in include/linux/pci.h #define PCI_D0 ((pci_power_t __force) 0) #define PCI_D1 ((pci_power_t __force) 1) #define PCI_D2 ((pci_power_t __force) 2) #define PCI_D3hot ((pci_power_t __force) 3) #define PCI_D3cold ((pci_power_t __force) 4) #define PCI_UNKNOWN ((pci_power_t __force) 5) #define PCI_POWER_ERROR ((pci_power_t __force) -1) */ retval = pci_set_power_state(pci_dev, PCI_D0); /* restore the saved state of a PCI device */ pci_restore_state(pci_dev); /* initialize device before it's used by a driver */ if (pci_enable_device(pci_dev)) { printk("pci enable fail!\n"); return 0; } #endif DBGPRINT(RT_DEBUG_TRACE, ("===>%s()\n", __FUNCTION__)); if (net_dev == NULL) { DBGPRINT(RT_DEBUG_ERROR, ("net_dev == NULL!\n")); } else GET_PAD_FROM_NET_DEV(pAd, net_dev); if (pAd != NULL) { ULONG IfNum; /* we can not use IFF_UP because ra0 down but ra1 up and 1 suspend/resume function for 1 module, not for each interface so Linux will call suspend/resume function once */ RTMP_DRIVER_VIRTUAL_INF_NUM_GET(pAd, &IfNum); if (IfNum > 0) /* if (VIRTUAL_IF_NUM(pAd) > 0) */ { /* mark device as attached from system and restart if needed */ netif_device_attach(net_dev); if (rt28xx_open((PNET_DEV)net_dev) != 0) { /* open fail */ DBGPRINT(RT_DEBUG_TRACE, ("<===%s()\n", __FUNCTION__)); return 0; } /* increase MODULE use count */ RT_MOD_INC_USE_COUNT(); /* RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS); */ /* RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF); */ RTMP_DRIVER_PCI_RESUME(pAd); netif_start_queue(net_dev); netif_carrier_on(net_dev); netif_wake_queue(net_dev); } } DBGPRINT(RT_DEBUG_TRACE, ("<=== %s()\n", __FUNCTION__)); return 0; }
static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream, struct atiixp_dma *dma, int pcm_type) { struct atiixp_modem *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; int err; static unsigned int rates[] = { 8000, 9600, 12000, 16000 }; static struct snd_pcm_hw_constraint_list hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, }; if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma)) return -EINVAL; if (dma->opened) return -EBUSY; dma->substream = substream; runtime->hw = snd_atiixp_pcm_hw; dma->ac97_pcm_type = pcm_type; if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates)) < 0) return err; if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) return err; runtime->private_data = dma; /* */ spin_lock_irq(&chip->reg_lock); dma->ops->enable_dma(chip, 1); spin_unlock_irq(&chip->reg_lock); dma->opened = 1; return 0; } static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream, struct atiixp_dma *dma) { struct atiixp_modem *chip = snd_pcm_substream_chip(substream); /* */ if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma)) return -EINVAL; spin_lock_irq(&chip->reg_lock); dma->ops->enable_dma(chip, 0); spin_unlock_irq(&chip->reg_lock); dma->substream = NULL; dma->opened = 0; return 0; } /* */ static int snd_atiixp_playback_open(struct snd_pcm_substream *substream) { struct atiixp_modem *chip = snd_pcm_substream_chip(substream); int err; mutex_lock(&chip->open_mutex); err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0); mutex_unlock(&chip->open_mutex); if (err < 0) return err; return 0; } static int snd_atiixp_playback_close(struct snd_pcm_substream *substream) { struct atiixp_modem *chip = snd_pcm_substream_chip(substream); int err; mutex_lock(&chip->open_mutex); err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]); mutex_unlock(&chip->open_mutex); return err; } static int snd_atiixp_capture_open(struct snd_pcm_substream *substream) { struct atiixp_modem *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1); } static int snd_atiixp_capture_close(struct snd_pcm_substream *substream) { struct atiixp_modem *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]); } /* */ static struct snd_pcm_ops snd_atiixp_playback_ops = { .open = snd_atiixp_playback_open, .close = snd_atiixp_playback_close, .ioctl = snd_pcm_lib_ioctl, .hw_params = snd_atiixp_pcm_hw_params, .hw_free = snd_atiixp_pcm_hw_free, .prepare = snd_atiixp_playback_prepare, .trigger = snd_atiixp_pcm_trigger, .pointer = snd_atiixp_pcm_pointer, }; /* */ static struct snd_pcm_ops snd_atiixp_capture_ops = { .open = snd_atiixp_capture_open, .close = snd_atiixp_capture_close, .ioctl = snd_pcm_lib_ioctl, .hw_params = snd_atiixp_pcm_hw_params, .hw_free = snd_atiixp_pcm_hw_free, .prepare = snd_atiixp_capture_prepare, .trigger = snd_atiixp_pcm_trigger, .pointer = snd_atiixp_pcm_pointer, }; static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = { .type = ATI_DMA_PLAYBACK, .llp_offset = ATI_REG_MODEM_OUT_DMA1_LINKPTR, .dt_cur = ATI_REG_MODEM_OUT_DMA1_DT_CUR, .enable_dma = atiixp_out_enable_dma, .enable_transfer = atiixp_out_enable_transfer, .flush_dma = atiixp_out_flush_dma, }; static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = { .type = ATI_DMA_CAPTURE, .llp_offset = ATI_REG_MODEM_IN_DMA_LINKPTR, .dt_cur = ATI_REG_MODEM_IN_DMA_DT_CUR, .enable_dma = atiixp_in_enable_dma, .enable_transfer = atiixp_in_enable_transfer, .flush_dma = atiixp_in_flush_dma, }; static int __devinit snd_atiixp_pcm_new(struct atiixp_modem *chip) { struct snd_pcm *pcm; int err; /* */ chip->dmas[ATI_DMA_PLAYBACK].ops = &snd_atiixp_playback_dma_ops; chip->dmas[ATI_DMA_CAPTURE].ops = &snd_atiixp_capture_dma_ops; /* */ err = snd_pcm_new(chip->card, "ATI IXP MC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_atiixp_capture_ops); pcm->dev_class = SNDRV_PCM_CLASS_MODEM; pcm->private_data = chip; strcpy(pcm->name, "ATI IXP MC97"); chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm; snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci), 64*1024, 128*1024); return 0; } /* */ static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id) { struct atiixp_modem *chip = dev_id; unsigned int status; status = atiixp_read(chip, ISR); if (! status) return IRQ_NONE; /* */ if (status & ATI_REG_ISR_MODEM_OUT1_XRUN) snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]); else if (status & ATI_REG_ISR_MODEM_OUT1_STATUS) snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]); if (status & ATI_REG_ISR_MODEM_IN_XRUN) snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]); else if (status & ATI_REG_ISR_MODEM_IN_STATUS) snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]); /* */ if (status & CODEC_CHECK_BITS) { unsigned int detected; detected = status & CODEC_CHECK_BITS; spin_lock(&chip->reg_lock); chip->codec_not_ready_bits |= detected; atiixp_update(chip, IER, detected, 0); /* */ spin_unlock(&chip->reg_lock); } /* */ atiixp_write(chip, ISR, status); return IRQ_HANDLED; } /* */ static int __devinit snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock) { struct snd_ac97_bus *pbus; struct snd_ac97_template ac97; int i, err; int codec_count; static struct snd_ac97_bus_ops ops = { .write = snd_atiixp_ac97_write, .read = snd_atiixp_ac97_read, }; static unsigned int codec_skip[NUM_ATI_CODECS] = { ATI_REG_ISR_CODEC0_NOT_READY, ATI_REG_ISR_CODEC1_NOT_READY, ATI_REG_ISR_CODEC2_NOT_READY, }; if (snd_atiixp_codec_detect(chip) < 0) return -ENXIO; if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus)) < 0) return err; pbus->clock = clock; chip->ac97_bus = pbus; codec_count = 0; for (i = 0; i < NUM_ATI_CODECS; i++) { if (chip->codec_not_ready_bits & codec_skip[i]) continue; memset(&ac97, 0, sizeof(ac97)); ac97.private_data = chip; ac97.pci = chip->pci; ac97.num = i; ac97.scaps = AC97_SCAP_SKIP_AUDIO | AC97_SCAP_POWER_SAVE; if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) { chip->ac97[i] = NULL; /* */ snd_printdd("atiixp-modem: codec %d not available for modem\n", i); continue; } codec_count++; } if (! codec_count) { snd_printk(KERN_ERR "atiixp-modem: no codec available\n"); return -ENODEV; } /* */ return 0; } #ifdef CONFIG_PM /* */ static int snd_atiixp_suspend(struct pci_dev *pci, pm_message_t state) { struct snd_card *card = pci_get_drvdata(pci); struct atiixp_modem *chip = card->private_data; int i; snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < NUM_ATI_PCMDEVS; i++) snd_pcm_suspend_all(chip->pcmdevs[i]); for (i = 0; i < NUM_ATI_CODECS; i++) snd_ac97_suspend(chip->ac97[i]); snd_atiixp_aclink_down(chip); snd_atiixp_chip_stop(chip); pci_disable_device(pci); pci_save_state(pci); pci_set_power_state(pci, pci_choose_state(pci, state)); return 0; } static int snd_atiixp_resume(struct pci_dev *pci) { struct snd_card *card = pci_get_drvdata(pci); struct atiixp_modem *chip = card->private_data; int i; pci_set_power_state(pci, PCI_D0); pci_restore_state(pci); if (pci_enable_device(pci) < 0) { printk(KERN_ERR "atiixp-modem: pci_enable_device failed, " "disabling device\n"); snd_card_disconnect(card); return -EIO; } pci_set_master(pci); snd_atiixp_aclink_reset(chip); snd_atiixp_chip_start(chip); for (i = 0; i < NUM_ATI_CODECS; i++) snd_ac97_resume(chip->ac97[i]); snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* */ #ifdef CONFIG_PROC_FS /* */ static void snd_atiixp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct atiixp_modem *chip = entry->private_data; int i; for (i = 0; i < 256; i += 4) snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i)); } static void __devinit snd_atiixp_proc_init(struct atiixp_modem *chip) { struct snd_info_entry *entry; if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry)) snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read); } #else #define snd_atiixp_proc_init(chip) #endif /* */ static int snd_atiixp_free(struct atiixp_modem *chip) { if (chip->irq < 0) goto __hw_end; snd_atiixp_chip_stop(chip); __hw_end: if (chip->irq >= 0) free_irq(chip->irq, chip); if (chip->remap_addr) iounmap(chip->remap_addr); pci_release_regions(chip->pci); pci_disable_device(chip->pci); kfree(chip); return 0; } static int snd_atiixp_dev_free(struct snd_device *device) { struct atiixp_modem *chip = device->device_data; return snd_atiixp_free(chip); } /* */ static int __devinit snd_atiixp_create(struct snd_card *card, struct pci_dev *pci, struct atiixp_modem **r_chip) { static struct snd_device_ops ops = { .dev_free = snd_atiixp_dev_free, }; struct atiixp_modem *chip; int err; if ((err = pci_enable_device(pci)) < 0) return err; chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) { pci_disable_device(pci); return -ENOMEM; } spin_lock_init(&chip->reg_lock); mutex_init(&chip->open_mutex); chip->card = card; chip->pci = pci; chip->irq = -1; if ((err = pci_request_regions(pci, "ATI IXP MC97")) < 0) { kfree(chip); pci_disable_device(pci); return err; } chip->addr = pci_resource_start(pci, 0); chip->remap_addr = pci_ioremap_bar(pci, 0); if (chip->remap_addr == NULL) { snd_printk(KERN_ERR "AC'97 space ioremap problem\n"); snd_atiixp_free(chip); return -EIO; } if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED, KBUILD_MODNAME, chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_atiixp_free(chip); return -EBUSY; } chip->irq = pci->irq; pci_set_master(pci); synchronize_irq(chip->irq); if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { snd_atiixp_free(chip); return err; } snd_card_set_dev(card, &pci->dev); *r_chip = chip; return 0; } static int __devinit snd_atiixp_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { struct snd_card *card; struct atiixp_modem *chip; int err; err = snd_card_create(index, id, THIS_MODULE, 0, &card); if (err < 0) return err; strcpy(card->driver, "ATIIXP-MODEM"); strcpy(card->shortname, "ATI IXP Modem"); if ((err = snd_atiixp_create(card, pci, &chip)) < 0) goto __error; card->private_data = chip; if ((err = snd_atiixp_aclink_reset(chip)) < 0) goto __error; if ((err = snd_atiixp_mixer_new(chip, ac97_clock)) < 0) goto __error; if ((err = snd_atiixp_pcm_new(chip)) < 0) goto __error; snd_atiixp_proc_init(chip); snd_atiixp_chip_start(chip); sprintf(card->longname, "%s rev %x at 0x%lx, irq %i", card->shortname, pci->revision, chip->addr, chip->irq); if ((err = snd_card_register(card)) < 0) goto __error; pci_set_drvdata(pci, card); return 0; __error: snd_card_free(card); return err; } static void __devexit snd_atiixp_remove(struct pci_dev *pci) { snd_card_free(pci_get_drvdata(pci)); pci_set_drvdata(pci, NULL); }
int dwc3_intel_resume(struct dwc_otg2 *otg) { struct pci_dev *pci_dev; struct usb_hcd *hcd = NULL; u32 data; int ret; if (!otg) return 0; hcd = container_of(otg->otg.host, struct usb_hcd, self); /* After resume from D0i3cold. The UTMI PHY D+ drive issue * reproduced due to all setting be reseted. So switch to OTG * mode avoid D+ drive too early. */ if ((otg->state == DWC_STATE_B_IDLE || otg->state == DWC_STATE_CHARGING || otg->state == DWC_STATE_WAIT_VBUS_FALL || otg->state == DWC_STATE_WAIT_VBUS_RAISE) && is_utmi_phy(otg)) { /* Reconnect DP/DM between Pmic and SOC for support host * and device mode. */ ret = intel_scu_ipc_update_register(PMIC_USBPHYCTRL, USBPHYRSTB, USBPHYRSTB); if (ret) otg_err(otg, "%s: ipc update failed\n", __func__); otg_write(otg, OEVTEN, 0); otg_write(otg, OCTL, 0); dwc3_switch_mode(otg, GCTL_PRT_CAP_DIR_OTG); } /* This is one SCU WA. SCU should set GUSB2PHYCFG0 * bit 4 for ULPI setting. But SCU haven't do that. * So do WA first until SCU fix. */ data = otg_read(otg, GUSB2PHYCFG0); if (is_utmi_phy(otg)) data &= ~(1 << 4); else data |= (1 << 4); otg_write(otg, GUSB2PHYCFG0, data); pci_dev = to_pci_dev(otg->dev); /* From synopsys spec 12.2.11. * Software cannot access memory-mapped I/O space * for 10ms. Delay 5 ms here should be enough. Too * long a delay causes hibernation exit failure. */ mdelay(5); pci_restore_state(pci_dev); if (pci_enable_device(pci_dev) < 0) { otg_err(otg, "pci_enable_device failed.\n"); return -EIO; } set_sus_phy(otg, 0); /* Delay 1ms waiting PHY clock debounce. * Without this debounce, will met fabric error randomly. **/ mdelay(1); if (otg->state == DWC_STATE_A_HOST && otg->resume_host) otg->resume_host(hcd); return 0; }
static int cnss_powerup(const struct subsys_desc *subsys) { struct cnss_wlan_driver *wdrv; struct pci_dev *pdev; struct cnss_wlan_vreg_info *vreg_info; struct cnss_wlan_gpio_info *gpio_info; int ret = 0; if (!penv) return -ENODEV; if (penv->driver) { wdrv = penv->driver; pdev = penv->pdev; vreg_info = &penv->vreg_info; gpio_info = &penv->gpio_info; ret = cnss_wlan_vreg_set(vreg_info, VREG_ON); if (ret) { pr_err("cnss: Failed to set WLAN VREG_ON!\n"); goto err_wlan_vreg_on; } usleep(POWER_ON_DELAY); cnss_wlan_gpio_set(gpio_info, WLAN_EN_HIGH); usleep(WLAN_ENABLE_DELAY); if (!pdev) { pr_err("%d: invalid pdev\n", __LINE__); goto err_pcie_link_up; } if (!penv->pcie_link_state) { ret = msm_pcie_pm_control(MSM_PCIE_RESUME, cnss_get_pci_dev_bus_number(pdev), NULL, NULL, PM_OPTIONS); if (ret) { pr_err("cnss: Failed to bring-up PCIe link!\n"); goto err_pcie_link_up; } penv->pcie_link_state = PCIE_LINK_UP; } if (wdrv && wdrv->reinit) { if (penv->saved_state) pci_load_and_free_saved_state(pdev, &penv->saved_state); pci_restore_state(pdev); ret = wdrv->reinit(pdev, penv->id); if (ret) { pr_err("%d: Failed to do reinit\n", __LINE__); goto err_wlan_reinit; } } else { pr_err("%d: wdrv->reinit is invalid\n", __LINE__); goto err_pcie_link_up; } } return ret; err_wlan_reinit: pci_save_state(pdev); penv->saved_state = pci_store_saved_state(pdev); msm_pcie_pm_control(MSM_PCIE_SUSPEND, cnss_get_pci_dev_bus_number(pdev), NULL, NULL, PM_OPTIONS); penv->pcie_link_state = PCIE_LINK_DOWN; err_pcie_link_up: cnss_wlan_gpio_set(gpio_info, WLAN_EN_LOW); cnss_wlan_vreg_set(vreg_info, VREG_OFF); if (penv->pdev) { pr_err("%d: Unregistering pci device\n", __LINE__); pci_unregister_driver(&cnss_wlan_pci_driver); penv->pdev = NULL; penv->pci_register_again = true; } err_wlan_vreg_on: return ret; }
static int vmw_pci_resume(struct pci_dev *pdev) { pci_set_power_state(pdev, PCI_D0); pci_restore_state(pdev); return pci_enable_device(pdev); }
static int be_resume(struct pci_dev *pdev) { int status = 0; struct be_adapter *adapter = pci_get_drvdata(pdev); struct net_device *netdev = adapter->netdevp; struct be_net_object *pnob = netdev_priv(netdev); netif_device_detach(netdev); status = pci_enable_device(pdev); if (status) return status; pci_set_power_state(pdev, 0); pci_restore_state(pdev); pci_enable_wake(pdev, 3, 0); pci_enable_wake(pdev, 4, 0); /* 4 is D3 cold */ netif_carrier_on(netdev); netif_start_queue(netdev); if (netif_running(netdev)) { be_rxf_mac_address_read_write(&pnob->fn_obj, false, false, false, true, false, netdev->dev_addr, NULL, NULL); status = be_nob_ring_init(adapter, pnob); if (status < 0) return status; tasklet_init(&(adapter->sts_handler), be_process_intr, (unsigned long)adapter); adapter->tasklet_started = 1; if (be_register_isr(adapter, pnob) != 0) { printk(KERN_ERR "be_register_isr failed\n"); return status; } status = be_mcc_init(adapter); if (status < 0) { printk(KERN_ERR "be_mcc_init failed\n"); return status; } be_update_link_status(adapter); /* * Register async call back function to handle link * status updates */ status = be_mcc_add_async_event_callback( &adapter->net_obj->mcc_q_obj, be_link_status_async_callback, (void *)adapter); if (status != BE_SUCCESS) { printk(KERN_WARNING "add_async_event_callback failed"); printk(KERN_WARNING "Link status changes may not be reflected\n"); } be_enable_intr(pnob); be_enable_eq_intr(pnob); be_up(adapter); } netif_device_attach(netdev); adapter->dev_state = adapter->dev_pm_state; return 0; }
static int rt2860_resume( struct pci_dev *pci_dev) { struct net_device *net_dev = pci_get_drvdata(pci_dev); PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)NULL; #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10) INT32 retval; // set the power state of a PCI device // PCI has 4 power states, DO (normal) ~ D3(less power) // in include/linux/pci.h, you can find that // #define PCI_D0 ((pci_power_t __force) 0) // #define PCI_D1 ((pci_power_t __force) 1) // #define PCI_D2 ((pci_power_t __force) 2) // #define PCI_D3hot ((pci_power_t __force) 3) // #define PCI_D3cold ((pci_power_t __force) 4) // #define PCI_UNKNOWN ((pci_power_t __force) 5) // #define PCI_POWER_ERROR ((pci_power_t __force) -1) retval = pci_set_power_state(pci_dev, PCI_D0); // restore the saved state of a PCI device pci_restore_state(pci_dev); // initialize device before it's used by a driver if (pci_enable_device(pci_dev)) { printk("pci enable fail!\n"); return 0; } #endif DBGPRINT(RT_DEBUG_TRACE, ("===> rt2860_resume()\n")); if (net_dev == NULL) { DBGPRINT(RT_DEBUG_ERROR, ("net_dev == NULL!\n")); } else GET_PAD_FROM_NET_DEV(pAd, net_dev); if (pAd != NULL) { /* we can not use IFF_UP because ra0 down but ra1 up */ /* and 1 suspend/resume function for 1 module, not for each interface */ /* so Linux will call suspend/resume function once */ if (VIRTUAL_IF_NUM(pAd) > 0) { // mark device as attached from system and restart if needed netif_device_attach(net_dev); if (rt28xx_open((PNET_DEV)net_dev) != 0) { // open fail DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2860_resume()\n")); return 0; } // increase MODULE use count RT_MOD_INC_USE_COUNT(); RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS); RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF); netif_start_queue(net_dev); netif_carrier_on(net_dev); netif_wake_queue(net_dev); } } DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2860_resume()\n")); return 0; }
/* Resets NIC to known state. This routine must be called in process * context and is allowed to sleep. */ static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method) { struct falcon_nic_data *nic_data = efx->nic_data; efx_oword_t glb_ctl_reg_ker; int rc; EFX_LOG(efx, "performing %s hardware reset\n", RESET_TYPE(method)); /* Initiate device reset */ if (method == RESET_TYPE_WORLD) { rc = pci_save_state(efx->pci_dev); if (rc) { EFX_ERR(efx, "failed to backup PCI state of primary " "function prior to hardware reset\n"); goto fail1; } if (efx_nic_is_dual_func(efx)) { rc = pci_save_state(nic_data->pci_dev2); if (rc) { EFX_ERR(efx, "failed to backup PCI state of " "secondary function prior to " "hardware reset\n"); goto fail2; } } EFX_POPULATE_OWORD_2(glb_ctl_reg_ker, FRF_AB_EXT_PHY_RST_DUR, FFE_AB_EXT_PHY_RST_DUR_10240US, FRF_AB_SWRST, 1); } else { EFX_POPULATE_OWORD_7(glb_ctl_reg_ker, /* exclude PHY from "invisible" reset */ FRF_AB_EXT_PHY_RST_CTL, method == RESET_TYPE_INVISIBLE, /* exclude EEPROM/flash and PCIe */ FRF_AB_PCIE_CORE_RST_CTL, 1, FRF_AB_PCIE_NSTKY_RST_CTL, 1, FRF_AB_PCIE_SD_RST_CTL, 1, FRF_AB_EE_RST_CTL, 1, FRF_AB_EXT_PHY_RST_DUR, FFE_AB_EXT_PHY_RST_DUR_10240US, FRF_AB_SWRST, 1); } efx_writeo(efx, &glb_ctl_reg_ker, FR_AB_GLB_CTL); EFX_LOG(efx, "waiting for hardware reset\n"); schedule_timeout_uninterruptible(HZ / 20); /* Restore PCI configuration if needed */ if (method == RESET_TYPE_WORLD) { if (efx_nic_is_dual_func(efx)) { rc = pci_restore_state(nic_data->pci_dev2); if (rc) { EFX_ERR(efx, "failed to restore PCI config for " "the secondary function\n"); goto fail3; } } rc = pci_restore_state(efx->pci_dev); if (rc) { EFX_ERR(efx, "failed to restore PCI config for the " "primary function\n"); goto fail4; } EFX_LOG(efx, "successfully restored PCI config\n"); } /* Assert that reset complete */ efx_reado(efx, &glb_ctl_reg_ker, FR_AB_GLB_CTL); if (EFX_OWORD_FIELD(glb_ctl_reg_ker, FRF_AB_SWRST) != 0) { rc = -ETIMEDOUT; EFX_ERR(efx, "timed out waiting for hardware reset\n"); goto fail5; } EFX_LOG(efx, "hardware reset complete\n"); return 0; /* pci_save_state() and pci_restore_state() MUST be called in pairs */ fail2: fail3: pci_restore_state(efx->pci_dev); fail1: fail4: fail5: return rc; }