loss_cntx = omap8250_lost_context(up); if (loss_cntx) omap8250_restore_regs(up); if (up->dma) omap_8250_rx_dma(up, 0); priv->latency = priv->calc_latency; schedule_work(&priv->qos_work); return 0; } #endif static const struct dev_pm_ops omap8250_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(omap8250_suspend, omap8250_resume) SET_RUNTIME_PM_OPS(omap8250_runtime_suspend, omap8250_runtime_resume, NULL) .prepare = omap8250_prepare, .complete = omap8250_complete, }; static const struct of_device_id omap8250_dt_ids[] = { { .compatible = "ti,omap2-uart" }, { .compatible = "ti,omap3-uart" }, { .compatible = "ti,omap4-uart" }, {}, }; MODULE_DEVICE_TABLE(of, omap8250_dt_ids); static struct platform_driver omap8250_platform_driver = {
bh1770_chip_on(chip); return 0; } #endif static const struct i2c_device_id bh1770_id[] = { {"bh1770glc", 0 }, {"sfh7770", 0 }, {} }; MODULE_DEVICE_TABLE(i2c, bh1770_id); static const struct dev_pm_ops bh1770_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(bh1770_suspend, bh1770_resume) SET_RUNTIME_PM_OPS(bh1770_runtime_suspend, bh1770_runtime_resume, NULL) }; static struct i2c_driver bh1770_driver = { .driver = { .name = "bh1770glc", .owner = THIS_MODULE, .pm = &bh1770_pm_ops, }, .probe = bh1770_probe, .remove = bh1770_remove, .id_table = bh1770_id, }; module_i2c_driver(bh1770_driver);
.unload = cirrus_driver_unload, .fops = &cirrus_driver_fops, .name = DRIVER_NAME, .desc = DRIVER_DESC, .date = DRIVER_DATE, .major = DRIVER_MAJOR, .minor = DRIVER_MINOR, .patchlevel = DRIVER_PATCHLEVEL, .gem_free_object = cirrus_gem_free_object, .dumb_create = cirrus_dumb_create, .dumb_map_offset = cirrus_dumb_mmap_offset, .dumb_destroy = drm_gem_dumb_destroy, }; static const struct dev_pm_ops cirrus_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(cirrus_pm_suspend, cirrus_pm_resume) }; static struct pci_driver cirrus_pci_driver = { .name = DRIVER_NAME, .id_table = pciidlist, .probe = cirrus_pci_probe, .remove = cirrus_pci_remove, .driver.pm = &cirrus_pm_ops, }; static int __init cirrus_init(void) { #ifdef CONFIG_VGA_CONSOLE if (vgacon_text_force() && cirrus_modeset == -1) return -EINVAL;
return 0; } static int ds3232_resume(struct device *dev) { struct ds3232 *ds3232 = dev_get_drvdata(dev); if (device_may_wakeup(dev)) disable_irq_wake(ds3232->irq); return 0; } #endif static const struct dev_pm_ops ds3232_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(ds3232_suspend, ds3232_resume) }; #if IS_ENABLED(CONFIG_I2C) static int ds3232_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct regmap *regmap; static const struct regmap_config config = { .reg_bits = 8, .val_bits = 8, .max_register = 0x13, }; regmap = devm_regmap_init_i2c(client, &config);
static int dw8250_runtime_resume(struct device *dev) { 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 },
lis3lv02d_poweron(lis3); return 0; } #endif /* CONFIG_PM */ static const struct i2c_device_id lis3lv02d_id[] = { {"lis3lv02d", LIS3LV02D}, {"lis331dlh", LIS331DLH}, {} }; MODULE_DEVICE_TABLE(i2c, lis3lv02d_id); static const struct dev_pm_ops lis3_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(lis3lv02d_i2c_suspend, lis3lv02d_i2c_resume) SET_RUNTIME_PM_OPS(lis3_i2c_runtime_suspend, lis3_i2c_runtime_resume, NULL) }; static struct i2c_driver lis3lv02d_i2c_driver = { .driver = { .name = DRV_NAME, .pm = &lis3_pm_ops, .of_match_table = of_match_ptr(lis3lv02d_i2c_dt_ids), }, .probe = lis3lv02d_i2c_probe, .remove = lis3lv02d_i2c_remove, .id_table = lis3lv02d_id, };
} } /** * 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_pm_domain_set(dev->dev, 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,
return armada_37xx_wdt_stop(wdt); } static int __maybe_unused armada_37xx_wdt_resume(struct device *dev) { struct watchdog_device *wdt = dev_get_drvdata(dev); if (watchdog_active(wdt)) return armada_37xx_wdt_start(wdt); return 0; } static const struct dev_pm_ops armada_37xx_wdt_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(armada_37xx_wdt_suspend, armada_37xx_wdt_resume) }; #ifdef CONFIG_OF static const struct of_device_id armada_37xx_wdt_match[] = { { .compatible = "marvell,armada-3700-wdt", }, {}, }; MODULE_DEVICE_TABLE(of, armada_37xx_wdt_match); #endif static struct platform_driver armada_37xx_wdt_driver = { .probe = armada_37xx_wdt_probe, .remove = armada_37xx_wdt_remove, .shutdown = armada_37xx_wdt_shutdown, .driver = {
ret = clk_prepare(fsl_dev->clk); if (ret < 0) { dev_err(dev, "failed to prepare dcu clk\n"); return ret; } drm_kms_helper_poll_enable(fsl_dev->drm); regcache_cache_only(fsl_dev->regmap, false); regcache_sync(fsl_dev->regmap); return 0; } #endif static const struct dev_pm_ops fsl_dcu_drm_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(fsl_dcu_drm_pm_suspend, fsl_dcu_drm_pm_resume) }; static const struct fsl_dcu_soc_data fsl_dcu_ls1021a_data = { .name = "ls1021a", .total_layer = 16, .max_layer = 4, }; static const struct fsl_dcu_soc_data fsl_dcu_vf610_data = { .name = "vf610", .total_layer = 64, .max_layer = 6, }; static const struct of_device_id fsl_dcu_of_match[] = {
return msm_ehci_suspend(mhcd); } static int ehci_msm2_runtime_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct msm_hcd *mhcd = hcd_to_mhcd(hcd); dev_dbg(dev, "EHCI runtime resume\n"); return msm_ehci_resume(mhcd); } #endif #ifdef CONFIG_PM static const struct dev_pm_ops ehci_msm2_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(ehci_msm2_pm_suspend, ehci_msm2_pm_resume) SET_RUNTIME_PM_OPS(ehci_msm2_runtime_suspend, ehci_msm2_runtime_resume, ehci_msm2_runtime_idle) }; #endif static struct platform_driver ehci_msm2_driver = { .probe = ehci_msm2_probe, .remove = __devexit_p(ehci_msm2_remove), .driver = { .name = "msm_ehci_host", #ifdef CONFIG_PM .pm = &ehci_msm2_dev_pm_ops, #endif }, };
int ret; ret = pm_runtime_get_sync(dev); if (ret) return ret; spfi_reset(spfi); pm_runtime_put(dev); return spi_master_resume(master); } #endif /* CONFIG_PM_SLEEP */ static const struct dev_pm_ops img_spfi_pm_ops = { SET_RUNTIME_PM_OPS(img_spfi_runtime_suspend, img_spfi_runtime_resume, NULL) SET_SYSTEM_SLEEP_PM_OPS(img_spfi_suspend, img_spfi_resume) }; static const struct of_device_id img_spfi_of_match[] = { { .compatible = "img,spfi", }, { }, }; MODULE_DEVICE_TABLE(of, img_spfi_of_match); static struct platform_driver img_spfi_driver = { .driver = { .name = "img-spfi", .pm = &img_spfi_pm_ops, .of_match_table = of_match_ptr(img_spfi_of_match), }, .probe = img_spfi_probe,
int ret; ret = pm_runtime_get_sync(dev); if (ret < 0) return ret; ret = regcache_sync(i2s->regmap); pm_runtime_put(dev); return ret; } #endif static const struct dev_pm_ops tegra30_i2s_pm_ops = { SET_RUNTIME_PM_OPS(tegra30_i2s_runtime_suspend, tegra30_i2s_runtime_resume, NULL) SET_SYSTEM_SLEEP_PM_OPS(tegra30_i2s_suspend, tegra30_i2s_resume) }; static struct platform_driver tegra30_i2s_driver = { .driver = { .name = DRV_NAME, .owner = THIS_MODULE, .of_match_table = tegra30_i2s_of_match, .pm = &tegra30_i2s_pm_ops, }, .probe = tegra30_i2s_platform_probe, .remove = tegra30_i2s_platform_remove, }; module_platform_driver(tegra30_i2s_driver); MODULE_AUTHOR("Stephen Warren <*****@*****.**>");
pm_runtime_put_noidle(&pdev->dev); pm_runtime_disable(&pdev->dev); return 0; } static const struct of_device_id spi_qup_dt_match[] = { { .compatible = "qcom,spi-qup-v1.1.1", }, { .compatible = "qcom,spi-qup-v2.1.1", }, { .compatible = "qcom,spi-qup-v2.2.1", }, { } }; MODULE_DEVICE_TABLE(of, spi_qup_dt_match); static const struct dev_pm_ops spi_qup_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(spi_qup_suspend, spi_qup_resume) SET_RUNTIME_PM_OPS(spi_qup_pm_suspend_runtime, spi_qup_pm_resume_runtime, NULL) }; static struct platform_driver spi_qup_driver = { .driver = { .name = "spi_qup", .owner = THIS_MODULE, .pm = &spi_qup_dev_pm_ops, .of_match_table = spi_qup_dt_match, }, .probe = spi_qup_probe, .remove = spi_qup_remove, };
dev_dbg(dev, "restoring ape state\n"); nvadsp_amc_restore(pdev); nvadsp_aram_restore(pdev); nvadsp_amisc_restore(pdev); skip: return ret; } static int nvadsp_runtime_idle(struct device *dev) { return 0; } #endif /* CONFIG_PM_RUNTIME */ static const struct dev_pm_ops nvadsp_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(nvadsp_suspend, nvadsp_resume) SET_RUNTIME_PM_OPS(nvadsp_runtime_suspend, nvadsp_runtime_resume, nvadsp_runtime_idle) }; uint64_t nvadsp_get_timestamp_counter(void) { uint32_t count_low = 0; uint32_t count_high = 0; uint64_t tsc = 0; void __iomem *base = nvadsp_drv_data->base_regs[AMISC]; unsigned long flags; spin_lock_irqsave(&tsc_lock, flags); read_again: /* read MSB 32 bits */
{ 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)
/* Errata i291 */ 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 = {
static int cyttsp_i2c_resume(struct device *dev) { void *ts = dev_get_drvdata(dev);//struct cyttsp_i2c *ts = dev_get_drvdata(dev); int rc; //pr_info("%s: cyttsp_i2c = %p\n", __func__, ts); rc = cyttsp_resume(ts); if (rc == 0) pr_info("%s\n", __func__);//_cyttsp3_force_function.FT_ready_flag = true; else pr_err("%s: ERROR ztemt resume false\n", __func__); return rc; } const struct dev_pm_ops cyttsp3_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(cyttsp_i2c_suspend, cyttsp_i2c_resume) }; #else #if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND) static int cyttsp_i2c_suspend(struct i2c_client *client, pm_message_t message) { // struct cyttsp_i2c *ts = i2c_get_clientdata(client); // pr_info("%s: ztemt cyttsp_i2c_suspend\n",__func__); // return cyttsp_suspend(ts); return 0; } static int cyttsp_i2c_resume(struct i2c_client *client) { // struct cyttsp_i2c *ts = i2c_get_clientdata(client); // pr_info("%s: ztemt cyttsp_i2c_resume\n",__func__);
*/ static int __maybe_unused cnds_runtime_suspend(struct device *dev) { struct spi_master *master = dev_get_drvdata(dev); struct cdns_spi *xspi = spi_master_get_devdata(master); clk_disable_unprepare(xspi->ref_clk); clk_disable_unprepare(xspi->pclk); return 0; } static const struct dev_pm_ops cdns_spi_dev_pm_ops = { SET_RUNTIME_PM_OPS(cnds_runtime_suspend, cnds_runtime_resume, NULL) SET_SYSTEM_SLEEP_PM_OPS(cdns_spi_suspend, cdns_spi_resume) }; static const struct of_device_id cdns_spi_of_match[] = { { .compatible = "xlnx,zynq-spi-r1p6" }, { .compatible = "cdns,spi-r1p6" }, { /* end of table */ } }; MODULE_DEVICE_TABLE(of, cdns_spi_of_match); /* cdns_spi_driver - This structure defines the SPI subsystem platform driver */ static struct platform_driver cdns_spi_driver = { .probe = cdns_spi_probe, .remove = cdns_spi_remove, .driver = { .name = CDNS_SPI_NAME,
dev_err(dev, "clk_enable failed for core_clk: %d\n", ret); return ret; } ret = clk_prepare_enable(msm_host->pclk); if (ret) { dev_err(dev, "clk_enable failed for iface_clk: %d\n", ret); clk_disable_unprepare(msm_host->clk); return ret; } return 0; } #endif static const struct dev_pm_ops sdhci_msm_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) SET_RUNTIME_PM_OPS(sdhci_msm_runtime_suspend, sdhci_msm_runtime_resume, NULL) }; static struct platform_driver sdhci_msm_driver = { .probe = sdhci_msm_probe, .remove = sdhci_msm_remove, .driver = { .name = "sdhci_msm", .of_match_table = sdhci_msm_dt_match, .pm = &sdhci_msm_pm_ops, }, };
return ret; /* * Runtime PM Documentation recommends bringing the * device to full powered state upon resume. */ pm_runtime_disable(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); return 0; } #endif static const struct dev_pm_ops msm_otg_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(msm_otg_pm_suspend, msm_otg_pm_resume) SET_RUNTIME_PM_OPS(msm_otg_runtime_suspend, msm_otg_runtime_resume, msm_otg_runtime_idle) }; static struct platform_driver msm_otg_driver = { .probe = msm_otg_probe, .remove = msm_otg_remove, .driver = { .name = DRIVER_NAME, .owner = THIS_MODULE, .pm = &msm_otg_dev_pm_ops, .of_match_table = msm_otg_dt_match, }, };
struct xi2cps *xi2c = platform_get_drvdata(pdev); int ret; ret = clk_enable(xi2c->clk); if (ret) { dev_err(_dev, "Cannot enable clock.\n"); return ret; } xi2c->suspended = 0; return 0; } static const struct dev_pm_ops xi2cps_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(xi2cps_suspend, xi2cps_resume) }; #define XI2CPS_PM (&xi2cps_dev_pm_ops) #else /* ! CONFIG_PM_SLEEP */ #define XI2CPS_PM NULL #endif /* ! CONFIG_PM_SLEEP */ /************************/ /* Platform bus binding */ /************************/ /** * xi2cps_probe - Platform registration call * @pdev: Handle to the platform device structure *
struct mmc_card *card = mmc_dev_to_card(dev); return mmc_power_restore_host(card->host); } 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, .pm = &mmc_bus_pm_ops, }; int mmc_register_bus(void) { return bus_register(&mmc_bus_type);
dev_dbg(dev, "%s\n", __func__); if (!pm_runtime_suspended(dev)) { rc = ak89xx_power_supply(st, 1); } else { dev_info(dev, "%s: was runtime-suspended.\n", __func__); rc = 0; } return rc ? -EAGAIN : 0; } #else #define ak89xx_suspend NULL #define ak89xx_resume NULL #endif static const struct dev_pm_ops ak89xx_pm = { SET_SYSTEM_SLEEP_PM_OPS(ak89xx_suspend, ak89xx_resume) SET_RUNTIME_PM_OPS(ak89xx_runtime_suspend, ak89xx_runtime_resume, NULL) }; static struct i2c_driver inv_ak89xx_driver = { .class = I2C_CLASS_HWMON, .probe = inv_ak89xx_probe, .remove = inv_ak89xx_remove, .id_table = inv_ak89xx_id, .driver = { .owner = THIS_MODULE, .name = "inv-ak89xx-iio", .pm = &ak89xx_pm, }, .address_list = normal_i2c, };
static int lsm303cmp_suspend(struct device *dev) { struct lsm303cmp_driver_data *drv_data = dev_get_drvdata(dev); mutex_lock(&drv_data->lock); drv_data->need_resume = drv_data->enabled; if (drv_data->enabled) lsm303cmp_disable(drv_data); mutex_unlock(&drv_data->lock); return 0; } static const struct dev_pm_ops lsm303cmp_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(lsm303cmp_suspend, lsm303cmp_resume) }; #endif /* CONFIG_PM_SLEEP */ static struct i2c_device_id lsm303cmp_id[2] = { { DRIVER_NAME, 0 }, { }, }; static struct i2c_driver lsm303cmp_driver = { .driver = { .owner = THIS_MODULE, .name = DRIVER_NAME, #ifdef CONFIG_PM_SLEEP .pm = &lsm303cmp_pm_ops, #endif /* CONFIG_PM_SLEEP */
fimc_is_debugfs_remove(is); if (is->fw.f_w) release_firmware(is->fw.f_w); fimc_is_free_cpu_memory(is); return 0; } static const struct of_device_id fimc_is_of_match[] = { { .compatible = "samsung,exynos4212-fimc-is" }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(of, fimc_is_of_match); static const struct dev_pm_ops fimc_is_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(fimc_is_suspend, fimc_is_resume) SET_RUNTIME_PM_OPS(fimc_is_runtime_suspend, fimc_is_runtime_resume, NULL) }; static struct platform_driver fimc_is_driver = { .probe = fimc_is_probe, .remove = fimc_is_remove, .driver = { .of_match_table = fimc_is_of_match, .name = FIMC_IS_DRV_NAME, .owner = THIS_MODULE, .pm = &fimc_is_pm_ops, } };
pinctrl_pm_select_default_state(dev); ret = dwc3_resume_common(dwc); if (ret) return ret; pm_runtime_disable(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); return 0; } #endif /* CONFIG_PM_SLEEP */ static const struct dev_pm_ops dwc3_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(dwc3_suspend, dwc3_resume) SET_RUNTIME_PM_OPS(dwc3_runtime_suspend, dwc3_runtime_resume, dwc3_runtime_idle) }; #ifdef CONFIG_OF static const struct of_device_id of_dwc3_match[] = { { .compatible = "snps,dwc3" }, { .compatible = "synopsys,dwc3" }, { }, }; MODULE_DEVICE_TABLE(of, of_dwc3_match);
static int dwc3_exynos_resume(struct device *dev) { struct dwc3_exynos *exynos = dev_get_drvdata(dev); clk_enable(exynos->clk); /* runtime set active to reflect active state. */ pm_runtime_disable(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); return 0; } static const struct dev_pm_ops dwc3_exynos_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(dwc3_exynos_suspend, dwc3_exynos_resume) }; #define DEV_PM_OPS (&dwc3_exynos_dev_pm_ops) #else #define DEV_PM_OPS NULL #endif /* CONFIG_PM_SLEEP */ static struct platform_driver dwc3_exynos_driver = { .probe = dwc3_exynos_probe, .remove = dwc3_exynos_remove, .driver = { .name = "exynos-dwc3", .of_match_table = of_match_ptr(exynos_dwc3_match), .pm = DEV_PM_OPS, },
ret = msm_xo_mode_vote(smsc_hub->xo_handle, MSM_XO_MODE_ON); if (ret) { pr_err("%s: failed to vote for TCXO\n" "D1 buffer%d\n", __func__, ret); } } else if (smsc_hub->pdata->xo_clk_gpio) { gpio_direction_output(smsc_hub->pdata->xo_clk_gpio, 1); } 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 const struct of_device_id hsic_hub_dt_match[] = { { .compatible = "qcom,hsic-smsc-hub", }, {} }; MODULE_DEVICE_TABLE(of, hsic_hub_dt_match); static struct platform_driver smsc_hub_driver = { .driver = { .name = "msm_smsc_hub",
static int xhci_msm_pm_resume(struct device *dev) { dev_dbg(dev, "xhci-msm PM resume\n"); if (pm_runtime_suspended(dev)) return 0; if (phy) return usb_phy_set_suspend(phy, 0); return 0; } #endif static const struct dev_pm_ops xhci_msm_dev_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(xhci_msm_pm_suspend, xhci_msm_pm_resume) SET_RUNTIME_PM_OPS(xhci_msm_runtime_suspend, xhci_msm_runtime_resume, xhci_msm_runtime_idle) }; static struct platform_driver usb_xhci_driver = { .probe = xhci_plat_probe, .remove = xhci_plat_remove, .driver = { .name = "xhci-hcd", .pm = &xhci_msm_dev_pm_ops, }, }; MODULE_ALIAS("platform:xhci-hcd"); int xhci_register_plat(void)
{ struct sdhci_host *host = dev_get_drvdata(dev); struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); struct sdhci_pxa *pxa = pltfm_host->priv; clk_prepare_enable(pxa->clk_io); if (!IS_ERR(pxa->clk_core)) clk_prepare_enable(pxa->clk_core); return sdhci_runtime_resume_host(host); } #endif #ifdef CONFIG_PM static const struct dev_pm_ops sdhci_pxav3_pmops = { SET_SYSTEM_SLEEP_PM_OPS(sdhci_pxav3_suspend, sdhci_pxav3_resume) SET_RUNTIME_PM_OPS(sdhci_pxav3_runtime_suspend, sdhci_pxav3_runtime_resume, NULL) }; #define SDHCI_PXAV3_PMOPS (&sdhci_pxav3_pmops) #else #define SDHCI_PXAV3_PMOPS NULL #endif static struct platform_driver sdhci_pxav3_driver = { .driver = { .name = "sdhci-pxav3", .of_match_table = of_match_ptr(sdhci_pxav3_of_match), .pm = SDHCI_PXAV3_PMOPS,