lkml.org 
[lkml]   [2008]   [Apr]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[RFC][PATCH 2/3] PM: New suspend and hibernation callbacks for platform bus type (rev. 3)
    Date
    From: Rafael J. Wysocki <rjw@sisk.pl>

    Implement new suspend and hibernation callbacks for the platform bus
    type.

    Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
    ---
    drivers/base/platform.c | 296 ++++++++++++++++++++++++++++++++++++++--
    include/linux/platform_device.h | 1
    2 files changed, 289 insertions(+), 8 deletions(-)

    Index: linux-2.6/include/linux/platform_device.h
    ===================================================================
    --- linux-2.6.orig/include/linux/platform_device.h
    +++ linux-2.6/include/linux/platform_device.h
    @@ -53,6 +53,7 @@ struct platform_driver {
    int (*suspend_late)(struct platform_device *, pm_message_t state);
    int (*resume_early)(struct platform_device *);
    int (*resume)(struct platform_device *);
    + struct pm_ext_ops *pm;
    struct device_driver driver;
    };

    Index: linux-2.6/drivers/base/platform.c
    ===================================================================
    --- linux-2.6.orig/drivers/base/platform.c
    +++ linux-2.6/drivers/base/platform.c
    @@ -453,6 +453,8 @@ int platform_driver_register(struct plat
    drv->driver.suspend = platform_drv_suspend;
    if (drv->resume)
    drv->driver.resume = platform_drv_resume;
    + if (drv->pm)
    + drv->driver.pm = &drv->pm->base;
    return driver_register(&drv->driver);
    }
    EXPORT_SYMBOL_GPL(platform_driver_register);
    @@ -560,7 +562,9 @@ static int platform_match(struct device
    return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
    }

    -static int platform_suspend(struct device *dev, pm_message_t mesg)
    +#ifdef CONFIG_PM_SLEEP
    +
    +static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
    {
    int ret = 0;

    @@ -570,7 +574,7 @@ static int platform_suspend(struct devic
    return ret;
    }

    -static int platform_suspend_late(struct device *dev, pm_message_t mesg)
    +static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
    {
    struct platform_driver *drv = to_platform_driver(dev->driver);
    struct platform_device *pdev;
    @@ -583,7 +587,7 @@ static int platform_suspend_late(struct
    return ret;
    }

    -static int platform_resume_early(struct device *dev)
    +static int platform_legacy_resume_early(struct device *dev)
    {
    struct platform_driver *drv = to_platform_driver(dev->driver);
    struct platform_device *pdev;
    @@ -596,7 +600,7 @@ static int platform_resume_early(struct
    return ret;
    }

    -static int platform_resume(struct device *dev)
    +static int platform_legacy_resume(struct device *dev)
    {
    int ret = 0;

    @@ -606,15 +610,291 @@ static int platform_resume(struct device
    return ret;
    }

    +static int platform_pm_prepare(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    + int ret = 0;
    +
    + if (drv && drv->pm && drv->pm->prepare)
    + ret = drv->pm->prepare(dev);
    +
    + return ret;
    +}
    +
    +static void platform_pm_complete(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    +
    + if (drv && drv->pm && drv->pm->complete)
    + drv->pm->complete(dev);
    +}
    +
    +#ifdef CONFIG_SUSPEND
    +
    +static int platform_pm_suspend(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    + int ret = 0;
    +
    + if (drv && drv->pm) {
    + if (drv->pm->suspend)
    + ret = drv->pm->suspend(dev);
    + } else {
    + ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_suspend_noirq(struct device *dev)
    +{
    + struct platform_driver *pdrv;
    + int ret = 0;
    +
    + if (!dev->driver)
    + return 0;
    +
    + pdrv = to_platform_driver(dev->driver);
    + if (pdrv->pm) {
    + if (pdrv->pm->suspend_noirq)
    + ret = pdrv->pm->suspend_noirq(dev);
    + } else {
    + ret = platform_legacy_suspend_late(dev, PMSG_SUSPEND);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_resume(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    + int ret = 0;
    +
    + if (drv && drv->pm) {
    + if (drv->pm->resume)
    + ret = drv->pm->resume(dev);
    + } else {
    + ret = platform_legacy_resume(dev);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_resume_noirq(struct device *dev)
    +{
    + struct platform_driver *pdrv;
    + int ret = 0;
    +
    + if (!dev->driver)
    + return 0;
    +
    + pdrv = to_platform_driver(dev->driver);
    + if (pdrv->pm) {
    + if (pdrv->pm->resume_noirq)
    + ret = pdrv->pm->resume_noirq(dev);
    + } else {
    + ret = platform_legacy_resume_early(dev);
    + }
    +
    + return ret;
    +}
    +
    +#else /* !CONFIG_SUSPEND */
    +
    +#define platform_pm_suspend NULL
    +#define platform_pm_resume NULL
    +#define platform_pm_suspend_noirq NULL
    +#define platform_pm_resume_noirq NULL
    +
    +#endif /* !CONFIG_SUSPEND */
    +
    +#ifdef CONFIG_HIBERNATION
    +
    +static int platform_pm_freeze(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    + int ret = 0;
    +
    + if (!drv)
    + return 0;
    +
    + if (drv->pm) {
    + if (drv->pm->freeze)
    + ret = drv->pm->freeze(dev);
    + } else {
    + ret = platform_legacy_suspend(dev, PMSG_FREEZE);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_freeze_noirq(struct device *dev)
    +{
    + struct platform_driver *pdrv;
    + int ret = 0;
    +
    + if (!dev->driver)
    + return 0;
    +
    + pdrv = to_platform_driver(dev->driver);
    + if (pdrv->pm) {
    + if (pdrv->pm->freeze_noirq)
    + ret = pdrv->pm->freeze_noirq(dev);
    + } else {
    + ret = platform_legacy_suspend_late(dev, PMSG_FREEZE);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_thaw(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    + int ret = 0;
    +
    + if (drv && drv->pm) {
    + if (drv->pm->thaw)
    + ret = drv->pm->thaw(dev);
    + } else {
    + ret = platform_legacy_resume(dev);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_thaw_noirq(struct device *dev)
    +{
    + struct platform_driver *pdrv;
    + int ret = 0;
    +
    + if (!dev->driver)
    + return 0;
    +
    + pdrv = to_platform_driver(dev->driver);
    + if (pdrv->pm) {
    + if (pdrv->pm->thaw_noirq)
    + ret = pdrv->pm->thaw_noirq(dev);
    + } else {
    + ret = platform_legacy_resume_early(dev);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_poweroff(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    + int ret = 0;
    +
    + if (drv && drv->pm) {
    + if (drv->pm->poweroff)
    + ret = drv->pm->poweroff(dev);
    + } else {
    + ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_poweroff_noirq(struct device *dev)
    +{
    + struct platform_driver *pdrv;
    + int ret = 0;
    +
    + if (!dev->driver)
    + return 0;
    +
    + pdrv = to_platform_driver(dev->driver);
    + if (pdrv->pm) {
    + if (pdrv->pm->poweroff_noirq)
    + ret = pdrv->pm->poweroff_noirq(dev);
    + } else {
    + ret = platform_legacy_suspend_late(dev, PMSG_HIBERNATE);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_restore(struct device *dev)
    +{
    + struct device_driver *drv = dev->driver;
    + int ret = 0;
    +
    + if (drv && drv->pm) {
    + if (drv->pm->restore)
    + ret = drv->pm->restore(dev);
    + } else {
    + ret = platform_legacy_resume(dev);
    + }
    +
    + return ret;
    +}
    +
    +static int platform_pm_restore_noirq(struct device *dev)
    +{
    + struct platform_driver *pdrv;
    + int ret = 0;
    +
    + if (!dev->driver)
    + return 0;
    +
    + pdrv = to_platform_driver(dev->driver);
    + if (pdrv->pm) {
    + if (pdrv->pm->restore_noirq)
    + ret = pdrv->pm->restore_noirq(dev);
    + } else {
    + ret = platform_legacy_resume_early(dev);
    + }
    +
    + return ret;
    +}
    +
    +#else /* !CONFIG_HIBERNATION */
    +
    +#define platform_pm_freeze NULL
    +#define platform_pm_thaw NULL
    +#define platform_pm_poweroff NULL
    +#define platform_pm_restore NULL
    +#define platform_pm_freeze_noirq NULL
    +#define platform_pm_thaw_noirq NULL
    +#define platform_pm_poweroff_noirq NULL
    +#define platform_pm_restore_noirq NULL
    +
    +#endif /* !CONFIG_HIBERNATION */
    +
    +struct pm_ext_ops platform_pm_ops = {
    + .base = {
    + .prepare = platform_pm_prepare,
    + .complete = platform_pm_complete,
    + .suspend = platform_pm_suspend,
    + .resume = platform_pm_resume,
    + .freeze = platform_pm_freeze,
    + .thaw = platform_pm_thaw,
    + .poweroff = platform_pm_poweroff,
    + .restore = platform_pm_restore,
    + },
    + .suspend_noirq = platform_pm_suspend_noirq,
    + .resume_noirq = platform_pm_resume_noirq,
    + .freeze_noirq = platform_pm_freeze_noirq,
    + .thaw_noirq = platform_pm_thaw_noirq,
    + .poweroff_noirq = platform_pm_poweroff_noirq,
    + .restore_noirq = platform_pm_restore_noirq,
    +};
    +
    +#define PLATFORM_PM_OPS_PTR &platform_pm_ops
    +
    +#else /* !CONFIG_PM_SLEEP */
    +
    +#define PLATFORM_PM_OPS_PTR NULL
    +
    +#endif /* !CONFIG_PM_SLEEP */
    +
    struct bus_type platform_bus_type = {
    .name = "platform",
    .dev_attrs = platform_dev_attrs,
    .match = platform_match,
    .uevent = platform_uevent,
    - .suspend = platform_suspend,
    - .suspend_late = platform_suspend_late,
    - .resume_early = platform_resume_early,
    - .resume = platform_resume,
    + .pm = PLATFORM_PM_OPS_PTR,
    };
    EXPORT_SYMBOL_GPL(platform_bus_type);



    \
     
     \ /
      Last update: 2008-04-02 02:15    [W:0.036 / U:120.596 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site