static int vbox_drm_freeze(struct drm_device *dev) { drm_kms_helper_poll_disable(dev); pci_save_state(dev->pdev); console_lock(); vbox_fbdev_set_suspend(dev, 1); console_unlock(); return 0; }
static int agnx_pci_suspend(struct pci_dev *pdev, pm_message_t state) { struct ieee80211_hw *dev = pci_get_drvdata(pdev); AGNX_TRACE; ieee80211_stop_queues(dev); agnx_stop(dev); pci_save_state(pdev); pci_set_power_state(pdev, pci_choose_state(pdev, state)); return 0; }
static int vbox_drm_freeze(struct drm_device *dev) { struct vbox_private *vbox = dev->dev_private; drm_kms_helper_poll_disable(dev); pci_save_state(dev->pdev); drm_fb_helper_set_suspend_unlocked(&vbox->fbdev->helper, true); return 0; }
static int cs5520_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) { struct ata_host *host = pci_get_drvdata(pdev); int rc = 0; rc = ata_host_suspend(host, mesg); if (rc) return rc; pci_save_state(pdev); return 0; }
static int snd_vx222_suspend(struct pci_dev *pci, pm_message_t state) { struct snd_card *card = pci_get_drvdata(pci); struct snd_vx222 *vx = card->private_data; int err; err = snd_vx_suspend(&vx->core, state); pci_disable_device(pci); pci_save_state(pci); pci_set_power_state(pci, pci_choose_state(pci, state)); return err; }
void cnss_wlan_unregister_driver(struct cnss_wlan_driver *driver) { 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; wdrv = penv->driver; vreg_info = &penv->vreg_info; gpio_info = &penv->gpio_info; pdev = penv->pdev; if (!wdrv) { pr_err("driver not registered\n"); return; } if (penv->bus_client) msm_bus_scale_client_update_request(penv->bus_client, 0); if (!pdev) { pr_err("%d: invalid pdev\n", __LINE__); goto cut_power; } if (wdrv->remove) wdrv->remove(pdev); if (penv->pcie_link_state) { pci_save_state(pdev); penv->saved_state = pci_store_saved_state(pdev); if (msm_pcie_pm_control(MSM_PCIE_SUSPEND, cnss_get_pci_dev_bus_number(pdev), NULL, NULL, PM_OPTIONS)) { pr_debug("Failed to shutdown PCIe link\n"); return; } penv->pcie_link_state = PCIE_LINK_DOWN; } cut_power: penv->driver = NULL; cnss_wlan_gpio_set(gpio_info, WLAN_EN_LOW); if (cnss_wlan_vreg_set(vreg_info, VREG_OFF)) pr_err("wlan vreg OFF failed\n"); }
static s32 pch_suspend(struct pci_dev *pdev, pm_message_t state) { pci_disable_device(pdev); pci_enable_wake(pdev, PCI_D3hot, 0); if (pci_save_state(pdev) != 0) { dev_err(&pdev->dev, "could not save PCI config state\n"); return -ENOMEM; } pci_set_power_state(pdev, pci_choose_state(pdev, state)); return 0; }
static int spi_suspend(struct pci_dev *pdev, pm_message_t state) { struct dw_spi_pci *dwpci = pci_get_drvdata(pdev); int ret; ret = dw_spi_suspend_host(&dwpci->dws); if (ret) return ret; pci_save_state(pdev); pci_disable_device(pdev); pci_set_power_state(pdev, pci_choose_state(pdev, state)); return ret; }
void adf_dev_restore(struct adf_accel_dev *accel_dev) { struct adf_hw_device_data *hw_device = accel_dev->hw_device; struct pci_dev *pdev = accel_to_pci_dev(accel_dev); if (hw_device->reset_device) { dev_info(&GET_DEV(accel_dev), "Resetting device qat_dev%d\n", accel_dev->accel_id); hw_device->reset_device(accel_dev); pci_restore_state(pdev); pci_save_state(pdev); } }
/* * APM event handler, so the card is properly reinitialized after a power * event. */ static int nm256_suspend(struct pci_dev *pci, pm_message_t state) { struct snd_card *card = pci_get_drvdata(pci); struct nm256 *chip = card->private_data; snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); snd_ac97_suspend(chip->ac97); chip->coeffs_current = 0; pci_disable_device(pci); pci_save_state(pci); return 0; }
static int vmw_pci_suspend(struct pci_dev *pdev, pm_message_t state) { struct drm_device *dev = pci_get_drvdata(pdev); struct vmw_private *dev_priv = vmw_priv(dev); if (dev_priv->refuse_hibernation) return -EBUSY; pci_save_state(pdev); pci_disable_device(pdev); pci_set_power_state(pdev, PCI_D3hot); return 0; }
static int snd_vx222_suspend(struct device *dev) { struct pci_dev *pci = to_pci_dev(dev); struct snd_card *card = dev_get_drvdata(dev); struct snd_vx222 *vx = card->private_data; int err; err = snd_vx_suspend(&vx->core); pci_disable_device(pci); pci_save_state(pci); pci_set_power_state(pci, PCI_D3hot); return err; }
static int rt2860_suspend(struct pci_dev *pci_dev, pm_message_t state) { struct net_device *net_dev = pci_get_drvdata(pci_dev); struct rt_rtmp_adapter *pAd = (struct rt_rtmp_adapter *)NULL; int retval = 0; DBGPRINT(RT_DEBUG_TRACE, ("===> rt2860_suspend()\n")); if (net_dev == NULL) { DBGPRINT(RT_DEBUG_ERROR, ("net_dev == NULL!\n")); } else { GET_PAD_FROM_NET_DEV(pAd, net_dev); /* 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) { /* avoid users do suspend after interface is down */ /* stop interface */ netif_carrier_off(net_dev); netif_stop_queue(net_dev); /* mark device as removed from system and therefore no longer available */ netif_device_detach(net_dev); /* mark halt flag */ RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS); RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF); /* take down the device */ rt28xx_close((struct net_device *)net_dev); RT_MOD_DEC_USE_COUNT(); } } /* reference to http://vovo2000.com/type-lab/linux/kernel-api/linux-kernel-api.html */ /* enable device to generate PME# when suspended */ /* pci_choose_state(): Choose the power state of a PCI device to be suspended */ retval = pci_enable_wake(pci_dev, pci_choose_state(pci_dev, state), 1); /* save the PCI configuration space of a device before suspending */ pci_save_state(pci_dev); /* disable PCI device after use */ pci_disable_device(pci_dev); retval = pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state)); DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2860_suspend()\n")); return retval; }
/* * test_save_state * make call to pci_save_state, takes in a u32* * buffer */ static int test_save_state(void) { struct pci_dev *dev = ltp_pci.dev; prk_info("save state"); if (pci_save_state(dev)) { prk_err("failed save state"); return TFAIL; } prk_info("saved state of device"); return TPASS; }
static int snd_als300_suspend(struct pci_dev *pci, pm_message_t state) { struct snd_card *card = pci_get_drvdata(pci); struct snd_als300 *chip = card->private_data; snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); snd_ac97_suspend(chip->ac97); pci_disable_device(pci); pci_save_state(pci); pci_set_power_state(pci, pci_choose_state(pci, state)); return 0; }
static int spi_suspend(struct device *dev) { struct pci_dev *pdev = to_pci_dev(dev); struct dw_spi_pci *dwpci = pci_get_drvdata(pdev); int ret; ret = dw_spi_suspend_host(&dwpci->dws); if (ret) return ret; pci_save_state(pdev); pci_disable_device(pdev); pci_set_power_state(pdev, PCI_D3hot); return ret; }
/** * intel_mid_i2s_driver_suspend - driver power management suspend activity * @device_ptr : pointer of the device to resume * * Output parameters * error : 0 means no error */ static int intel_mid_i2s_driver_suspend(struct pci_dev *dev, pm_message_t state) { struct intel_mid_i2s_hdl *drv_data = pci_get_drvdata(dev); WARN(!drv_data, "Driver data=NULL\n"); if (!drv_data) return 0; dev_dbg(&dev->dev, "SUSPEND SSP ID %d\n", dev->device); drv_data->in_suspend = 1; pci_save_state(dev); pci_disable_device(dev); pci_set_power_state(dev, PCI_D3hot); return 0; }
static int ath_pci_suspend(struct pci_dev *pdev, pm_message_t state) { struct ieee80211_hw *hw = pci_get_drvdata(pdev); struct ath_wiphy *aphy = hw->priv; struct ath_softc *sc = aphy->sc; ath9k_hw_set_gpio(sc->sc_ah, sc->sc_ah->led_pin, 1); pci_save_state(pdev); pci_disable_device(pdev); pci_set_power_state(pdev, PCI_D3hot); return 0; }
static int ssb_pcihost_suspend(struct pci_dev *dev, pm_message_t state) { struct ssb_bus *ssb = pci_get_drvdata(dev); int err; err = ssb_bus_suspend(ssb); if (err) return err; pci_save_state(dev); pci_disable_device(dev); pci_set_power_state(dev, pci_choose_state(dev, state)); return 0; }
int rt2x00pci_suspend(struct pci_dev *pci_dev, pm_message_t state) { struct ieee80211_hw *hw = pci_get_drvdata(pci_dev); struct rt2x00_dev *rt2x00dev = hw->priv; int retval; retval = rt2x00lib_suspend(rt2x00dev, state); if (retval) return retval; pci_save_state(pci_dev); pci_disable_device(pci_dev); return pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state)); }
static int p54p_suspend(struct pci_dev *pdev, pm_message_t state) { struct ieee80211_hw *dev = pci_get_drvdata(pdev); struct p54p_priv *priv = dev->priv; if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED) { ieee80211_stop_queues(dev); p54p_stop(dev); } pci_save_state(pdev); pci_set_power_state(pdev, pci_choose_state(pdev, state)); return 0; }
static int prism2_pci_suspend(struct pci_dev *pdev, pm_message_t state) { struct net_device *dev = pci_get_drvdata(pdev); if (netif_running(dev)) { netif_stop_queue(dev); netif_device_detach(dev); } prism2_suspend(dev); pci_save_state(pdev); pci_disable_device(pdev); pci_set_power_state(pdev, PCI_D3hot); return 0; }
static int serial_hsu_suspend(struct pci_dev *pdev, pm_message_t state) { void *priv = pci_get_drvdata(pdev); struct uart_hsu_port *up; /* Make sure this is not the internal dma controller */ if (priv && (pdev->device != 0x081E)) { up = priv; uart_suspend_port(&serial_hsu_reg, &up->port); } pci_save_state(pdev); pci_set_power_state(pdev, pci_choose_state(pdev, state)); return 0; }
static int vbox_pm_suspend(struct device *dev) { struct vbox_private *vbox = dev_get_drvdata(dev); int error; error = drm_mode_config_helper_suspend(&vbox->ddev); if (error) return error; pci_save_state(vbox->ddev.pdev); pci_disable_device(vbox->ddev.pdev); pci_set_power_state(vbox->ddev.pdev, PCI_D3hot); return 0; }
static int intelce_wdt_suspend(struct pci_dev *pdev, pm_message_t state) { /* Save watchdog state */ wtctrl_save = readl(INTELCE_WDT_CTRL); wtreload_save = readl(INTELCE_WDT_RELOAD); /* Stop watchdog */ intelce_wdt_stop(); /*PCI device save*/ pci_save_state(pdev); pci_disable_device(pdev); pci_set_power_state(pdev, pci_choose_state(pdev, state)); return 0; }
static int i915_drm_freeze(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; struct drm_crtc *crtc; intel_runtime_pm_get(dev_priv); /* ignore lid events during suspend */ mutex_lock(&dev_priv->modeset_restore_lock); dev_priv->modeset_restore = MODESET_SUSPENDED; mutex_unlock(&dev_priv->modeset_restore_lock); /* We do a lot of poking in a lot of registers, make sure they work * properly. */ intel_display_set_init_power(dev_priv, true); drm_kms_helper_poll_disable(dev); pci_save_state(dev->pdev); /* If KMS is active, we do the leavevt stuff here */ if (drm_core_check_feature(dev, DRIVER_MODESET)) { int error; error = i915_gem_suspend(dev); if (error) { dev_err(&dev->pdev->dev, "GEM idle failed, resume might fail\n"); return error; } intel_disable_gt_powersave(dev); /* * Disable CRTCs directly since we want to preserve sw state * for _thaw. */ drm_modeset_lock_all(dev); for_each_crtc(dev, crtc) { dev_priv->display.crtc_disable(crtc); } drm_modeset_unlock_all(dev); intel_dp_mst_suspend(dev); drm_irq_uninstall(dev); intel_modeset_suspend_hw(dev); }
static int pch_phub_suspend(struct pci_dev *pdev, pm_message_t state) { int ret; pch_phub_save_reg_conf(pdev); ret = pci_save_state(pdev); if (ret) { dev_err(&pdev->dev, " %s -pci_save_state returns %d\n", __func__, ret); return ret; } pci_enable_wake(pdev, PCI_D3hot, 0); pci_disable_device(pdev); pci_set_power_state(pdev, pci_choose_state(pdev, state)); return 0; }
int rtl8192E_suspend(struct pci_dev *pdev, pm_message_t state) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); u32 ulRegRead; netdev_info(dev, "============> r8192E suspend call.\n"); del_timer_sync(&priv->gpio_polling_timer); cancel_delayed_work(&priv->gpio_change_rf_wq); priv->polling_timer_on = 0; if (!netif_running(dev)) { netdev_info(dev, "RTL819XE:UI is open out of suspend function\n"); goto out_pci_suspend; } if (dev->netdev_ops->ndo_stop) dev->netdev_ops->ndo_stop(dev); netif_device_detach(dev); if (!priv->rtllib->bSupportRemoteWakeUp) { MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT, true); ulRegRead = read_nic_dword(dev, CPU_GEN); ulRegRead |= CPU_GEN_SYSTEM_RESET; write_nic_dword(dev, CPU_GEN, ulRegRead); } else { write_nic_dword(dev, WFCRC0, 0xffffffff); write_nic_dword(dev, WFCRC1, 0xffffffff); write_nic_dword(dev, WFCRC2, 0xffffffff); write_nic_byte(dev, PMR, 0x5); write_nic_byte(dev, MacBlkCtrl, 0xa); } out_pci_suspend: netdev_info(dev, "WOL is %s\n", priv->rtllib->bSupportRemoteWakeUp ? "Supported" : "Not supported"); pci_save_state(pdev); pci_disable_device(pdev); pci_enable_wake(pdev, pci_choose_state(pdev, state), priv->rtllib->bSupportRemoteWakeUp ? 1 : 0); pci_set_power_state(pdev, pci_choose_state(pdev, state)); mdelay(20); return 0; }
static int i915_drm_freeze(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; drm_kms_helper_poll_disable(dev); #ifndef __NetBSD__ /* pmf handles this for us. */ pci_save_state(dev->pdev); #endif /* If KMS is active, we do the leavevt stuff here */ if (drm_core_check_feature(dev, DRIVER_MODESET)) { int error = i915_gem_idle(dev); if (error) { #ifdef __NetBSD__ dev_err(pci_dev_dev(dev->pdev), "GEM idle failed, resume might fail\n"); #else dev_err(&dev->pdev->dev, "GEM idle failed, resume might fail\n"); #endif return error; } cancel_delayed_work_sync(&dev_priv->rps.delayed_resume_work); intel_modeset_disable(dev); drm_irq_uninstall(dev); } i915_save_state(dev); intel_opregion_fini(dev); /* Modeset on resume, not lid events */ dev_priv->modeset_on_lid = 0; #ifndef __NetBSD__ /* XXX fb */ console_lock(); intel_fbdev_set_suspend(dev, 1); console_unlock(); #endif return 0; }
static int triflex_ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) { struct ata_host *host = dev_get_drvdata(&pdev->dev); int rc = 0; rc = ata_host_suspend(host, mesg); if (rc) return rc; /* */ pci_save_state(pdev); return 0; }