} static int dsi_dev_remove(struct platform_device *pdev) { DBG(""); component_del(&pdev->dev, &dsi_ops); return 0; } static const struct of_device_id dt_match[] = { { .compatible = "qcom,mdss-dsi-ctrl" }, {} }; static const struct dev_pm_ops dsi_pm_ops = { SET_RUNTIME_PM_OPS(msm_dsi_runtime_suspend, msm_dsi_runtime_resume, NULL) }; static struct platform_driver dsi_driver = { .probe = dsi_dev_probe, .remove = dsi_dev_remove, .driver = { .name = "msm_dsi", .of_match_table = dt_match, .pm = &dsi_pm_ops, }, }; void __init msm_dsi_register(void) { DBG("");
*/ WARN(pm_runtime_set_active(dev), "Could not set %s runtime state active\n", dev_name(dev)); pm_generic_runtime_resume(dev); } return pm_generic_resume_noirq(dev); } #else #define _od_suspend_noirq NULL #define _od_resume_noirq NULL #endif struct dev_pm_domain omap_device_fail_pm_domain = { .ops = { SET_RUNTIME_PM_OPS(_od_fail_runtime_suspend, _od_fail_runtime_resume, NULL) } }; struct dev_pm_domain omap_device_pm_domain = { .ops = { SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, NULL) USE_PLATFORM_PM_SLEEP_OPS .suspend_noirq = _od_suspend_noirq, .resume_noirq = _od_resume_noirq, } }; /** * omap_device_register - register an omap_device with one omap_hwmod
if (host->bus_ops->runtime_resume) ret = host->bus_ops->runtime_resume(host); return ret; } static int mmc_runtime_idle(struct device *dev) { return pm_runtime_suspend(dev); } #endif /* !CONFIG_PM_RUNTIME */ static const struct dev_pm_ops mmc_bus_pm_ops = { SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, mmc_runtime_idle) SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume) }; static struct bus_type mmc_bus_type = { .name = "mmc", .dev_attrs = mmc_dev_attrs, .match = mmc_bus_match, .uevent = mmc_bus_uevent, .probe = mmc_bus_probe, .remove = mmc_bus_remove, .shutdown = mmc_bus_shutdown, .pm = &mmc_bus_pm_ops, }; int mmc_register_bus(void)
tegra_pcm_platform_unregister(&pdev->dev); snd_soc_unregister_component(&pdev->dev); clk_put(i2s->clk_i2s); return 0; } static const struct of_device_id tegra20_i2s_of_match[] = { { .compatible = "nvidia,tegra20-i2s", }, {}, }; static const struct dev_pm_ops tegra20_i2s_pm_ops = { SET_RUNTIME_PM_OPS(tegra20_i2s_runtime_suspend, tegra20_i2s_runtime_resume, NULL) }; static struct platform_driver tegra20_i2s_driver = { .driver = { .name = DRV_NAME, .of_match_table = tegra20_i2s_of_match, .pm = &tegra20_i2s_pm_ops, }, .probe = tegra20_i2s_platform_probe, .remove = tegra20_i2s_platform_remove, }; module_platform_driver(tegra20_i2s_driver); MODULE_AUTHOR("Stephen Warren <*****@*****.**>"); MODULE_DESCRIPTION("Tegra20 I2S ASoC driver");
static int spi_st_resume(struct device *dev) { struct spi_master *master = dev_get_drvdata(dev); int ret; ret = spi_master_resume(master); if (ret) return ret; return pm_runtime_force_resume(dev); } #endif static const struct dev_pm_ops spi_st_pm = { SET_SYSTEM_SLEEP_PM_OPS(spi_st_suspend, spi_st_resume) SET_RUNTIME_PM_OPS(spi_st_runtime_suspend, spi_st_runtime_resume, NULL) }; static const struct of_device_id stm_spi_match[] = { { .compatible = "st,comms-ssc4-spi", }, {}, }; MODULE_DEVICE_TABLE(of, stm_spi_match); static struct platform_driver spi_st_driver = { .driver = { .name = "spi-st", .pm = &spi_st_pm, .of_match_table = of_match_ptr(stm_spi_match), }, .probe = spi_st_probe,
return pm_generic_resume_noirq(dev); if ((od->flags & OMAP_DEVICE_SUSPENDED) && !pm_runtime_status_suspended(dev)) { od->flags &= ~OMAP_DEVICE_SUSPENDED; omap_device_enable(pdev); pm_generic_runtime_resume(dev); } return pm_generic_resume_noirq(dev); } #endif static struct dev_pm_domain omap_device_pm_domain = { .ops = { SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, _od_runtime_idle) USE_PLATFORM_PM_SLEEP_OPS .suspend_noirq = _od_suspend_noirq, .resume_noirq = _od_resume_noirq, } }; /** * omap_device_register - register an omap_device with one omap_hwmod * @od: struct omap_device * to register * * Register the omap_device structure. This currently just calls * platform_device_register() on the underlying platform_device. * Returns the return value of platform_device_register(). */ int omap_device_register(struct omap_device *od)
struct sdhci_host *host = dev_get_drvdata(dev); struct sdhci_s3c *ourhost = to_s3c(host); struct clk *busclk = ourhost->clk_io; int ret; clk_prepare_enable(busclk); clk_prepare_enable(ourhost->clk_bus[ourhost->cur_clk]); ret = sdhci_runtime_resume_host(host); return ret; } #endif #ifdef CONFIG_PM static const struct dev_pm_ops sdhci_s3c_pmops = { SET_SYSTEM_SLEEP_PM_OPS(sdhci_s3c_suspend, sdhci_s3c_resume) SET_RUNTIME_PM_OPS(sdhci_s3c_runtime_suspend, sdhci_s3c_runtime_resume, NULL) }; #define SDHCI_S3C_PMOPS (&sdhci_s3c_pmops) #else #define SDHCI_S3C_PMOPS NULL #endif #if defined(CONFIG_CPU_EXYNOS4210) || defined(CONFIG_SOC_EXYNOS4212) static struct sdhci_s3c_drv_data exynos4_sdhci_drv_data = { .sdhci_quirks = SDHCI_QUIRK_NONSTANDARD_CLOCK, }; #define EXYNOS4_SDHCI_DRV_DATA ((kernel_ulong_t)&exynos4_sdhci_drv_data) #else #define EXYNOS4_SDHCI_DRV_DATA ((kernel_ulong_t)NULL)
ret = clk_prepare_enable(rs->apb_pclk); if (ret) return ret; ret = clk_prepare_enable(rs->spiclk); if (ret) clk_disable_unprepare(rs->apb_pclk); return ret; } #endif /* CONFIG_PM */ static const struct dev_pm_ops rockchip_spi_pm = { SET_SYSTEM_SLEEP_PM_OPS(rockchip_spi_suspend, rockchip_spi_resume) SET_RUNTIME_PM_OPS(rockchip_spi_runtime_suspend, rockchip_spi_runtime_resume, NULL) }; static const struct of_device_id rockchip_spi_dt_match[] = { { .compatible = "rockchip,rk3066-spi", }, { .compatible = "rockchip,rk3188-spi", }, { .compatible = "rockchip,rk3288-spi", }, { }, }; MODULE_DEVICE_TABLE(of, rockchip_spi_dt_match); static struct platform_driver rockchip_spi_driver = { .driver = { .name = DRIVER_NAME, .pm = &rockchip_spi_pm, .of_match_table = of_match_ptr(rockchip_spi_dt_match),
struct platform_device *pdev = to_platform_device(dev); struct cdns_i2c *xi2c = platform_get_drvdata(pdev); int ret; ret = clk_enable(xi2c->clk); if (ret) { dev_err(dev, "Cannot enable clock.\n"); return ret; } cdns_i2c_init(xi2c); return 0; } static const struct dev_pm_ops cdns_i2c_dev_pm_ops = { SET_RUNTIME_PM_OPS(cdns_i2c_runtime_suspend, cdns_i2c_runtime_resume, NULL) }; static const struct cdns_platform_data r1p10_i2c_def = { .quirks = CDNS_I2C_BROKEN_HOLD_BIT, }; static const struct of_device_id cdns_i2c_of_match[] = { { .compatible = "cdns,i2c-r1p10", .data = &r1p10_i2c_def }, { .compatible = "cdns,i2c-r1p14",}, { /* end of table */ } }; MODULE_DEVICE_TABLE(of, cdns_i2c_of_match); /** * cdns_i2c_probe - Platform registration call
ret); return ret; } if (cs35l32->reset_gpio) gpiod_set_value_cansleep(cs35l32->reset_gpio, 1); regcache_cache_only(cs35l32->regmap, false); regcache_sync(cs35l32->regmap); return 0; } #endif static const struct dev_pm_ops cs35l32_runtime_pm = { SET_RUNTIME_PM_OPS(cs35l32_runtime_suspend, cs35l32_runtime_resume, NULL) }; static const struct of_device_id cs35l32_of_match[] = { { .compatible = "cirrus,cs35l32", }, {}, }; MODULE_DEVICE_TABLE(of, cs35l32_of_match); static const struct i2c_device_id cs35l32_id[] = { {"cs35l32", 0}, {} }; MODULE_DEVICE_TABLE(i2c, cs35l32_id);
{ int ret; ret = msm_xo_mode_vote(smsc_hub->xo_handle, MSM_XO_MODE_ON); if (ret) { pr_err("%s: failed to vote for TCXO" "D1 buffer%d\n", __func__, ret); } return ret; } #endif #ifdef CONFIG_PM static const struct dev_pm_ops smsc_hub_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(smsc_hub_lpm_enter, smsc_hub_lpm_exit) SET_RUNTIME_PM_OPS(smsc_hub_lpm_enter, smsc_hub_lpm_exit, msm_smsc_runtime_idle) }; #endif static struct platform_driver smsc_hub_driver = { .driver = { .name = "msm_smsc_hub", .owner = THIS_MODULE, #ifdef CONFIG_PM .pm = &smsc_hub_dev_pm_ops, #endif }, .remove = smsc_hub_remove, }; static int __init smsc_hub_init(void)
return -ENODEV; pm_runtime_disable(&pdev->dev); if (!pm_runtime_status_suspended(&pdev->dev)) tegra30_ahub_runtime_suspend(&pdev->dev); clk_put(ahub->clk_apbif); clk_put(ahub->clk_d_audio); ahub = NULL; return 0; } static const struct dev_pm_ops tegra30_ahub_pm_ops = { SET_RUNTIME_PM_OPS(tegra30_ahub_runtime_suspend, tegra30_ahub_runtime_resume, NULL) }; static struct platform_driver tegra30_ahub_driver = { .probe = tegra30_ahub_probe, .remove = tegra30_ahub_remove, .driver = { .name = DRV_NAME, .owner = THIS_MODULE, .of_match_table = tegra30_ahub_of_match, .pm = &tegra30_ahub_pm_ops, }, }; module_platform_driver(tegra30_ahub_driver); MODULE_AUTHOR("Stephen Warren <*****@*****.**>");
int rc; rc = ahci_resume_common(dev); if (!rc) { pm_runtime_disable(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); } return rc; } #endif static const struct dev_pm_ops ahci_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(ahci_suspend, ahci_resume) SET_RUNTIME_PM_OPS(ahci_suspend, ahci_resume_common, NULL) }; static const struct of_device_id ahci_of_match[] = { { .compatible = "snps,spear-ahci", }, {}, }; MODULE_DEVICE_TABLE(of, ahci_of_match); static struct platform_driver ahci_driver = { .probe = ahci_probe, .remove = ata_platform_remove_one, .driver = { .name = "ahci", .owner = THIS_MODULE, .of_match_table = ahci_of_match,
struct dwc3_pci *dwc = dev_get_drvdata(dev); return dwc3_pci_dsm(dwc, PCI_INTEL_BXT_STATE_D3); } static int dwc3_pci_resume(struct device *dev) { struct dwc3_pci *dwc = dev_get_drvdata(dev); return dwc3_pci_dsm(dwc, PCI_INTEL_BXT_STATE_D0); } #endif /* CONFIG_PM_SLEEP */ static const struct dev_pm_ops dwc3_pci_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(dwc3_pci_suspend, dwc3_pci_resume) SET_RUNTIME_PM_OPS(dwc3_pci_runtime_suspend, dwc3_pci_runtime_resume, NULL) }; static struct pci_driver dwc3_pci_driver = { .name = "dwc3-pci", .id_table = dwc3_pci_id_table, .probe = dwc3_pci_probe, .remove = dwc3_pci_remove, .driver = { .pm = &dwc3_pci_dev_pm_ops, } }; MODULE_AUTHOR("Felipe Balbi <*****@*****.**>"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("DesignWare USB3 PCI Glue Layer");
dev_err(dev, "Failed to enable supplies: %d\n", ret); return ret; } regcache_cache_only(pcm512x->regmap, false); ret = regcache_sync(pcm512x->regmap); if (ret != 0) { dev_err(dev, "Failed to sync cache: %d\n", ret); return ret; } ret = regmap_update_bits(pcm512x->regmap, PCM512x_POWER, PCM512x_RQPD, 0); if (ret != 0) { dev_err(dev, "Failed to remove power down: %d\n", ret); return ret; } return 0; } #endif const struct dev_pm_ops pcm512x_pm_ops = { SET_RUNTIME_PM_OPS(pcm512x_suspend, pcm512x_resume, NULL) }; EXPORT_SYMBOL_GPL(pcm512x_pm_ops); MODULE_DESCRIPTION("ASoC PCM512x codec driver"); MODULE_AUTHOR("Mark Brown <*****@*****.**>"); MODULE_LICENSE("GPL v2");
/** * mei_me_unset_pm_domain - clean pm domain structure for device * * @dev: mei_device */ static inline void mei_me_unset_pm_domain(struct mei_device *dev) { /* stop using pm callbacks if any */ dev->dev->pm_domain = NULL; } static const struct dev_pm_ops mei_me_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(mei_me_pci_suspend, mei_me_pci_resume) SET_RUNTIME_PM_OPS( mei_me_pm_runtime_suspend, mei_me_pm_runtime_resume, mei_me_pm_runtime_idle) }; #define MEI_ME_PM_OPS (&mei_me_pm_ops) #else #define MEI_ME_PM_OPS NULL #endif /* CONFIG_PM */ /* * PCI driver structure */ static struct pci_driver mei_me_driver = { .name = KBUILD_MODNAME, .id_table = mei_me_pci_tbl, .probe = mei_me_probe, .remove = mei_me_remove,
dev_dbg(dev, "pm_runtime: suspending...\n"); if (mdata->clk_ena) { pr_err("MDP suspend failed\n"); return -EBUSY; } mdss_mdp_footswitch_ctrl(mdata, false); return 0; } #endif static const struct dev_pm_ops mdss_mdp_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(mdss_mdp_pm_suspend, mdss_mdp_pm_resume) SET_RUNTIME_PM_OPS(mdss_mdp_runtime_suspend, mdss_mdp_runtime_resume, mdss_mdp_runtime_idle) }; static int mdss_mdp_remove(struct platform_device *pdev) { struct mdss_data_type *mdata = platform_get_drvdata(pdev); if (!mdata) return -ENODEV; pm_runtime_disable(&pdev->dev); mdss_mdp_pp_term(&pdev->dev); mdss_mdp_bus_scale_unregister(mdata); mdss_debugfs_remove(mdata); return 0; }
[1] = &fimc_lite0_variant_exynos4, }, }; static struct platform_device_id fimc_lite_driver_ids[] = { { .name = "exynos-fimc-lite", .driver_data = (unsigned long)&fimc_lite_drvdata_exynos4, }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(platform, fimc_lite_driver_ids); static const struct dev_pm_ops fimc_lite_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(fimc_lite_suspend, fimc_lite_resume) SET_RUNTIME_PM_OPS(fimc_lite_runtime_suspend, fimc_lite_runtime_resume, NULL) }; static struct platform_driver fimc_lite_driver = { .probe = fimc_lite_probe, .remove = fimc_lite_remove, .id_table = fimc_lite_driver_ids, .driver = { .name = FIMC_LITE_DRV_NAME, .owner = THIS_MODULE, .pm = &fimc_lite_pm_ops, } }; module_platform_driver(fimc_lite_driver); MODULE_LICENSE("GPL"); MODULE_ALIAS("platform:" FIMC_LITE_DRV_NAME);
if (up->use_dma && pdata->set_noidle && (up->errata & UART_ERRATA_i291_DMA_FORCEIDLE)) pdata->set_noidle(up->pdev); up->latency = up->calc_latency; schedule_work(&up->qos_work); } return 0; } #endif static const struct dev_pm_ops serial_omap_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(serial_omap_suspend, serial_omap_resume) SET_RUNTIME_PM_OPS(serial_omap_runtime_suspend, serial_omap_runtime_resume, NULL) }; #if defined(CONFIG_OF) static const struct of_device_id omap_serial_of_match[] = { { .compatible = "ti,omap2-uart" }, { .compatible = "ti,omap3-uart" }, { .compatible = "ti,omap4-uart" }, {}, }; MODULE_DEVICE_TABLE(of, omap_serial_of_match); #endif static struct platform_driver serial_omap_driver = { .probe = serial_omap_probe, .remove = serial_omap_remove,
static int psh_runtime_suspend(struct device *dev) { dev_dbg(dev, "runtime suspend called\n"); return 0; } static int psh_runtime_resume(struct device *dev) { dev_dbg(dev, "runtime resume called\n"); return 0; } static const struct dev_pm_ops psh_drv_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(psh_suspend, psh_resume) SET_RUNTIME_PM_OPS(psh_runtime_suspend, psh_runtime_resume, NULL) }; static DEFINE_PCI_DEVICE_TABLE(pci_ids) = { {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x11a4)}, { 0,} }; MODULE_DEVICE_TABLE(pci, pci_ids); static struct pci_driver psh_driver = { .name = "psh", .driver = { .pm = &psh_drv_pm_ops, }, .id_table = pci_ids,
return 0; } static int __maybe_unused xylon_drm_pm_resume(struct device *dev) { struct xylon_drm_device *xdev = dev_get_drvdata(dev); drm_helper_connector_dpms(xdev->connector, DRM_MODE_DPMS_ON); drm_kms_helper_poll_enable(xdev->dev); return 0; } static const struct dev_pm_ops xylon_drm_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(xylon_drm_pm_suspend, xylon_drm_pm_resume) SET_RUNTIME_PM_OPS(xylon_drm_pm_suspend, xylon_drm_pm_resume, NULL) }; static int xylon_drm_platform_probe(struct platform_device *pdev) { return drm_platform_init(&xylon_drm_driver, pdev); } static int xylon_drm_platform_remove(struct platform_device *pdev) { struct xylon_drm_device *xdev = platform_get_drvdata(pdev); drm_put_dev(xdev->dev); return 0; }
} static int arizona_resume(struct device *dev) { struct arizona *arizona = dev_get_drvdata(dev); dev_dbg(arizona->dev, "Resume, reenabling IRQ\n"); enable_irq(arizona->irq); return 0; } #endif const struct dev_pm_ops arizona_pm_ops = { SET_RUNTIME_PM_OPS(arizona_runtime_suspend, arizona_runtime_resume, NULL) SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend, arizona_resume) }; EXPORT_SYMBOL_GPL(arizona_pm_ops); static struct mfd_cell early_devs[] = { { .name = "arizona-ldo1" }, }; static struct mfd_cell wm5102_devs[] = { { .name = "arizona-micsupp" }, { .name = "arizona-extcon" }, { .name = "arizona-gpio" }, { .name = "arizona-pwm" }, { .name = "wm5102-codec" },
samsung_clk_register_gate(ctx, exynos4x12_isp_gate_clks, ARRAY_SIZE(exynos4x12_isp_gate_clks)); samsung_clk_of_add_provider(np, ctx); pm_runtime_put(dev); return 0; } static const struct of_device_id exynos4x12_isp_clk_of_match[] = { { .compatible = "samsung,exynos4412-isp-clock", }, { }, }; static const struct dev_pm_ops exynos4x12_isp_pm_ops = { SET_RUNTIME_PM_OPS(exynos4x12_isp_clk_suspend, exynos4x12_isp_clk_resume, NULL) SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) }; static struct platform_driver exynos4x12_isp_clk_driver __refdata = { .driver = { .name = "exynos4x12-isp-clk", .of_match_table = exynos4x12_isp_clk_of_match, .suppress_bind_attrs = true, .pm = &exynos4x12_isp_pm_ops, }, .probe = exynos4x12_isp_clk_probe, }; static int __init exynos4x12_isp_clk_init(void)
if (!pm_runtime_status_suspended(&pdev->dev)) i2s_runtime_suspend(&pdev->dev); clk_disable_unprepare(i2s->mclk); clk_disable_unprepare(i2s->hclk); return 0; } static const struct of_device_id rockchip_i2s_match[] = { { .compatible = "rockchip,rk3066-i2s", }, {}, }; static const struct dev_pm_ops rockchip_i2s_pm_ops = { SET_RUNTIME_PM_OPS(i2s_runtime_suspend, i2s_runtime_resume, NULL) }; static struct platform_driver rockchip_i2s_driver = { .probe = rockchip_i2s_probe, .remove = rockchip_i2s_remove, .driver = { .name = DRV_NAME, .of_match_table = of_match_ptr(rockchip_i2s_match), .pm = &rockchip_i2s_pm_ops, }, }; module_platform_driver(rockchip_i2s_driver); MODULE_DESCRIPTION("ROCKCHIP IIS ASoC Interface"); MODULE_AUTHOR("jianqun <*****@*****.**>");
struct ti_pipe3 *phy = dev_get_drvdata(dev); int ret; ret = ti_pipe3_enable_clocks(phy); if (ret) return ret; pm_runtime_disable(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); return 0; } #endif static const struct dev_pm_ops ti_pipe3_pm_ops = { SET_RUNTIME_PM_OPS(ti_pipe3_runtime_suspend, ti_pipe3_runtime_resume, NULL) SET_SYSTEM_SLEEP_PM_OPS(ti_pipe3_suspend, ti_pipe3_resume) }; #ifdef CONFIG_OF static const struct of_device_id ti_pipe3_id_table[] = { { .compatible = "ti,phy-usb3", .data = dpll_map_usb, }, { .compatible = "ti,omap-usb3", .data = dpll_map_usb, }, { .compatible = "ti,phy-pipe3-sata",
{ struct dw8250_data *data = dev_get_drvdata(dev); if (!IS_ERR(data->pclk)) clk_prepare_enable(data->pclk); if (!IS_ERR(data->clk)) clk_prepare_enable(data->clk); return 0; } #endif static const struct dev_pm_ops dw8250_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(dw8250_suspend, dw8250_resume) SET_RUNTIME_PM_OPS(dw8250_runtime_suspend, dw8250_runtime_resume, NULL) }; static const struct of_device_id dw8250_of_match[] = { { .compatible = "snps,dw-apb-uart" }, { .compatible = "cavium,octeon-3860-uart" }, { /* Sentinel */ } }; MODULE_DEVICE_TABLE(of, dw8250_of_match); static const struct acpi_device_id dw8250_acpi_match[] = { { "INT33C4", 0 }, { "INT33C5", 0 }, { "INT3434", 0 }, { "INT3435", 0 }, { "80860F0A", 0 },
return 0; } static int etm_runtime_resume(struct device *dev) { struct etm_drvdata *drvdata = dev_get_drvdata(dev); if (drvdata && !IS_ERR(drvdata->atclk)) clk_prepare_enable(drvdata->atclk); return 0; } #endif static const struct dev_pm_ops etm_dev_pm_ops = { SET_RUNTIME_PM_OPS(etm_runtime_suspend, etm_runtime_resume, NULL) }; static struct amba_id etm_ids[] = { { /* ETM 3.3 */ .id = 0x0003b921, .mask = 0x0003ffff, .data = "ETM 3.3", }, { /* ETM 3.5 */ .id = 0x0003b956, .mask = 0x0003ffff, .data = "ETM 3.5", }, { /* PTM 1.0 */ .id = 0x0003b950,
return xhci_suspend(xhci, true); } static int __maybe_unused xhci_plat_runtime_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct xhci_hcd *xhci = hcd_to_xhci(hcd); return xhci_resume(xhci, 0); } static const struct dev_pm_ops xhci_plat_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(xhci_plat_suspend, xhci_plat_resume) SET_RUNTIME_PM_OPS(xhci_plat_runtime_suspend, xhci_plat_runtime_resume, NULL) }; static const struct acpi_device_id usb_xhci_acpi_match[] = { /* XHCI-compliant USB Controller */ { "PNP0D10", }, { } }; MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match); static struct platform_driver usb_xhci_driver = { .probe = xhci_plat_probe, .remove = xhci_plat_remove, .shutdown = usb_hcd_platform_shutdown, .driver = {
rc = hda_tegra_enable_clocks(hda); if (rc != 0) return rc; if (chip && chip->running) { hda_tegra_init(hda); azx_init_chip(chip, 1); } return 0; } static const struct dev_pm_ops hda_tegra_pm = { SET_SYSTEM_SLEEP_PM_OPS(hda_tegra_suspend, hda_tegra_resume) SET_RUNTIME_PM_OPS(hda_tegra_runtime_suspend, hda_tegra_runtime_resume, NULL) }; static int hda_tegra_dev_disconnect(struct snd_device *device) { struct azx *chip = device->device_data; chip->bus.shutdown = 1; return 0; } /* * destructor */ static int hda_tegra_dev_free(struct snd_device *device)
/* This is called as a counterpart to the prepare op. It is * called either when suspending fails or when suspend * completed successfully. Now there's no risk of grabbing * the wakelock anymore, so we can release the suspending * flag. */ trans->suspending = false; } #endif /* CONFIG_IWLWIFI_PCIE_RTPM */ static const struct dev_pm_ops iwl_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(iwl_pci_suspend, iwl_pci_resume) #ifdef CONFIG_IWLWIFI_PCIE_RTPM SET_RUNTIME_PM_OPS(iwl_pci_runtime_suspend, iwl_pci_runtime_resume, NULL) .prepare = iwl_pci_system_prepare, .complete = iwl_pci_system_complete, #endif /* CONFIG_IWLWIFI_PCIE_RTPM */ }; #define IWL_PM_OPS (&iwl_dev_pm_ops) #else /* CONFIG_PM_SLEEP */ #define IWL_PM_OPS NULL #endif /* CONFIG_PM_SLEEP */ static struct pci_driver iwl_pci_driver = { .name = DRV_NAME,