Hi Rafael.
Is it possible to extend this in some way so we avoid the
#ifdef stuff in the drivers?
We could introduce a few special sections that we discard if
PM is not in use.
We have a reliable build time infrastructure to detect
inconsistencies if needed.
Something like:
#define __suspend __section(.suspend.text)
#define __suspenddata __section(.suspend.data)
#define __hibernate __section(.hibernate.text)
#define __hibernatedata __section(.hibernate.data)
A few more tricks will be needed when we assign the functon pointers.
We have __devexit_p(*) and we may use something similar.
Sam
> Index: linux-2.6/include/linux/pm.h
> ===================================================================
> --- linux-2.6.orig/include/linux/pm.h
> +++ linux-2.6/include/linux/pm.h
> @@ -114,7 +114,9 @@ typedef struct pm_message {
> int event;
> } pm_message_t;
>
> -/*
> +/**
> + * struct pm_ops - device PM callbacks
> + *
> * Several driver power state transitions are externally visible, affecting
> * the state of pending I/O queues and (for drivers that touch hardware)
> * interrupts, wakeups, DMA, and other hardware state. There may also be
> @@ -122,6 +124,245 @@ typedef struct pm_message {
> * to the rest of the driver stack (such as a driver that's ON gating off
> * clocks which are not in active use).
> *
> + * The externally visible transitions are handled with the help of the following
> + * callbacks included in this structure:
> + *
> + * @prepare: Prepare the device for the upcoming transition, but do NOT change
> + * its hardware state. Prevent new children of the device from being
> + * registered and prevent new calls to the probe method from being made
> + * after @prepare() returns. If @prepare() detects a situation it cannot
> + * handle (e.g. registration of a child already in progress), it may return
> + * -EAGAIN, so that the PM core can execute it once again (e.g. after the
> + * new child has been registered) to recover from the race condition. This
> + * method is executed for all kinds of suspend transitions and is followed
> + * by one of the suspend callbacks: @suspend(), @freeze(), or @poweroff().
> + * The PM core executes @prepare() for all devices before starting to
> + * execute suspend callbacks for any of them, so drivers may assume all of
> + * the other devices to be present and functional while @prepare() is being
> + * executed. However, they may NOT assume anything about the availability
> + * of the user space at that time.
> + *
> + * @complete: Undo the changes made by @prepare(). This method is executed for
> + * all kinds of resume transitions, following one of the resume callbacks:
> + * @resume(), @thaw(), @restore(). Also called if the state transition
> + * fails before the driver's suspend callback (@suspend(), @freeze(),
> + * @poweroff()) can be executed (e.g. if the suspend callback fails for one
> + * of the other devices that the PM core has unsucessfully attempted to
> + * suspend earlier). Also executed if a new child of the device has been
> + * registered during a successful @prepare() (in that case @prepare() will
> + * be executed once again for the device).
> + * The PM core executes @complete() after it has executed the appropriate
> + * resume callback for all devices.
> + *
> + * @suspend: Executed before putting the system into a sleep state in which the
> + * contents of main memory are preserved. Quiesce the device, put it into
> + * a low power state appropriate for the upcoming system state (such as
> + * PCI_D3hot), and enable wakeup events as appropriate.
> + *
> + * @resume: Executed after waking the system up from a sleep state in which the
> + * contents of main memory were preserved. Put the device into the
> + * appropriate state, according to the information saved in memory by the
> + * preceding @suspend(). The driver starts working again, responding to
> + * hardware events and software requests. The hardware may have gone
> + * through a power-off reset, or it may have maintained state from the
> + * previous suspend() which the driver may rely on while resuming. On most
> + * platforms, there are no restrictions on availability of resources like
> + * clocks during @resume().
> + *
> + * @freeze: Hibernation-specific, executed before creating a hibernation image.
> + * Quiesce operations so that a consistent image can be created, but do NOT
> + * otherwise put the device into a low power device state and do NOT emit
> + * system wakeup events. Save in main memory the device settings to be
> + * used by @restore() during the subsequent resume from hibernation or by
> + * the subsequent @thaw(), if the creation of the image or the restoration
> + * of main memory contents from it fails.
> + *
> + * @thaw: Hibernation-specific, executed after creating a hibernation image OR
> + * if the creation of the image fails. Also executed after a failing
> + * attempt to restore the contents of main memory from such an image.
> + * Undo the changes made by the preceding @freeze(), so the device can be
> + * operated in the same way as immediately before the call to @freeze().
> + *
> + * @poweroff: Hibernation-specific, executed after saving a hibernation image.
> + * Quiesce the device, put it into a low power state appropriate for the
> + * upcoming system state (such as PCI_D3hot), and enable wakeup events as
> + * appropriate.
> + *
> + * @restore: Hibernation-specific, executed after restoring the contents of main
> + * memory from a hibernation image. Driver starts working again,
> + * responding to hardware events and software requests. Drivers may NOT
> + * make ANY assumptions about the hardware state right prior to @restore().
> + * On most platforms, there are no restrictions on availability of
> + * resources like clocks during @restore().
> + *
> + * All of the above callbacks, except for @complete(), return error codes.
> + * However, the error codes returned by the resume operations, @resume(),
> + * @thaw(), and @restore(), are only printed in the system logs, since the PM
> + * core cannot do anything else about them.
> + */
> +
> +struct pm_ops {
> + int (*prepare)(struct device *dev);
> + void (*complete)(struct device *dev);
> + int (*suspend)(struct device *dev);
> + int (*resume)(struct device *dev);
> + int (*freeze)(struct device *dev);
> + int (*thaw)(struct device *dev);
> + int (*poweroff)(struct device *dev);
> + int (*restore)(struct device *dev);
> +};
> +
> +/**
> + * struct pm_noirq_ops - device PM callbacks executed with interrupts disabled
> + *
> + * The following callbacks included in 'struct pm_noirq_ops' are executed with
> + * interrupts disabled and with the nonboot CPUs switched off:
> + *
> + * @suspend_noirq: Complete the operations of ->suspend() by carrying out any
> + * actions required for suspending the device that need interrupts to be
> + * disabled
> + *
> + * @resume_noirq: Prepare for the execution of ->resume() by carrying out any
> + * actions required for resuming the device that need interrupts to be
> + * disabled
> + *
> + * @freeze_noirq: Complete the operations of ->freeze() by carrying out any
> + * actions required for freezing the device that need interrupts to be
> + * disabled
> + *
> + * @thaw_noirq: Prepare for the execution of ->thaw() by carrying out any
> + * actions required for thawing the device that need interrupts to be
> + * disabled
> + *
> + * @poweroff_noirq: Complete the operations of ->poweroff() by carrying out any
> + * actions required for handling the device that need interrupts to be
> + * disabled
> + *
> + * @restore_noirq: Prepare for the execution of ->restore() by carrying out any
> + * actions required for restoring the operations of the device that need
> + * interrupts to be disabled
> + *
> + * All of the above callbacks, return error codes, but the error codes returned
> + * by the resume operations, @resume_noirq(), @thaw_noirq(), and
> + * @restore_noirq(), are only printed in the system logs, since the PM core
> + * cannot do anything else about them.
> + */
> +
> +struct pm_noirq_ops {
> + int (*suspend_noirq)(struct device *dev);
> + int (*resume_noirq)(struct device *dev);
> + int (*freeze_noirq)(struct device *dev);
> + int (*thaw_noirq)(struct device *dev);
> + int (*poweroff_noirq)(struct device *dev);
> + int (*restore_noirq)(struct device *dev);
> +};
> +
> +/**
> + * PM_EVENT_ messages
> + *
> + * The following PM_EVENT_ messages are defined for the internal use of the PM
> + * core, in order to provide a mechanism allowing the high level suspend and
> + * hibernation code to convey the necessary information to the device PM core
> + * code:
> + *
> + * ON No transition.
> + *
> + * FREEZE System is going to hibernate, call ->prepare() and ->freeze()
> + * for all devices.
> + *
> + * SUSPEND System is going to suspend, call ->prepare() and ->suspend()
> + * for all devices.
> + *
> + * HIBERNATE Hibernation image has been saved, call ->prepare() and
> + * ->poweroff() for all devices.
> + *
> + * QUIESCE Contents of main memory are going to be restored from a (loaded)
> + * hibernation image, call ->prepare() and ->freeze() for all
> + * devices.
> + *
> + * RESUME System is resuming, call ->resume() and ->complete() for all
> + * devices.
> + *
> + * THAW Hibernation image has been created, call ->thaw() and
> + * ->complete() for all devices.
> + *
> + * RESTORE Contents of main memory have been restored from a hibernation
> + * image, call ->restore() and ->complete() for all devices.
> + *
> + * RECOVER Creation of a hibernation image or restoration of the main
> + * memory contents from a hibernation image has failed, call
> + * ->thaw() and ->complete() for all devices.
> + */
> +
> +#define PM_EVENT_ON 0x0000
> +#define PM_EVENT_FREEZE 0x0001
> +#define PM_EVENT_SUSPEND 0x0002
> +#define PM_EVENT_HIBERNATE 0x0004
> +#define PM_EVENT_QUIESCE 0x0008
> +#define PM_EVENT_RESUME 0x0010
> +#define PM_EVENT_THAW 0x0020
> +#define PM_EVENT_RESTORE 0x0040
> +#define PM_EVENT_RECOVER 0x0080
> +
> +#define PM_EVENT_SLEEP (PM_EVENT_SUSPEND | PM_EVENT_HIBERNATE)
> +
> +#define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, })
> +#define PMSG_QUIESCE ((struct pm_message){ .event = PM_EVENT_QUIESCE, })
> +#define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, })
> +#define PMSG_HIBERNATE ((struct pm_message){ .event = PM_EVENT_HIBERNATE, })
> +#define PMSG_RESUME ((struct pm_message){ .event = PM_EVENT_RESUME, })
> +#define PMSG_THAW ((struct pm_message){ .event = PM_EVENT_THAW, })
> +#define PMSG_RESTORE ((struct pm_message){ .event = PM_EVENT_RESTORE, })
> +#define PMSG_RECOVER ((struct pm_message){ .event = PM_EVENT_RECOVER, })
> +#define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, })
> +
> +/**
> + * Device power management states
> + *
> + * These state labels are used internally by the PM core to indicate the current
> + * status of a device with respect to the PM core operations.
> + *
> + * DPM_ON Device is regarded as operational. Set this way
> + * initially and when ->resume(), ->thaw(), or ->restore()
> + * (or ->complete() in case of an error) is about to be
> + * called. Also set when ->prepare() fails.
> + *
> + * DPM_PREPARING Device is currently being prepared for power transition.
> + * Set when ->prepare() is about to be called for the
> + * device.
> + *
> + * DPM_OFF Device is regarded as not fully operational. Set
> + * immediately after a successful call to ->prepare(),
> + * prior to calling ->suspend(), ->freeze(), or
> + * ->poweroff() for all devices.
> + */
> +
> +enum dpm_state {
> + DPM_ON,
> + DPM_PREPARING,
> + DPM_OFF,
> +};
> +
> +struct dev_pm_info {
> + pm_message_t power_state;
> + unsigned can_wakeup:1;
> + unsigned should_wakeup:1;
> + enum dpm_state status:2; /* Owned by the PM core */
> +#ifdef CONFIG_PM_SLEEP
> + struct list_head entry;
> +#endif
> +};
> +
> +/*
> + * The PM_EVENT_ messages are also used by drivers implementing the legacy
> + * suspend framework, based on the ->suspend() and ->resume() callbacks common
> + * for suspend and hibernation transitions, according to the rules below.
> + */
> +
> +/* Necessary, because several drivers use PM_EVENT_PRETHAW */
> +#define PM_EVENT_PRETHAW PM_EVENT_QUIESCE
> +
> +/*
> * One transition is triggered by resume(), after a suspend() call; the
> * message is implicit:
> *
> @@ -166,35 +407,11 @@ typedef struct pm_message {
> * or from system low-power states such as standby or suspend-to-RAM.
> */
>
> -#define PM_EVENT_ON 0
> -#define PM_EVENT_FREEZE 1
> -#define PM_EVENT_SUSPEND 2
> -#define PM_EVENT_HIBERNATE 4
> -#define PM_EVENT_PRETHAW 8
> -
> -#define PM_EVENT_SLEEP (PM_EVENT_SUSPEND | PM_EVENT_HIBERNATE)
> -
> -#define PMSG_FREEZE ((struct pm_message){ .event = PM_EVENT_FREEZE, })
> -#define PMSG_PRETHAW ((struct pm_message){ .event = PM_EVENT_PRETHAW, })
> -#define PMSG_SUSPEND ((struct pm_message){ .event = PM_EVENT_SUSPEND, })
> -#define PMSG_HIBERNATE ((struct pm_message){ .event = PM_EVENT_HIBERNATE, })
> -#define PMSG_ON ((struct pm_message){ .event = PM_EVENT_ON, })
> -
> -struct dev_pm_info {
> - pm_message_t power_state;
> - unsigned can_wakeup:1;
> - unsigned should_wakeup:1;
> - bool sleeping:1; /* Owned by the PM core */
> -#ifdef CONFIG_PM_SLEEP
> - struct list_head entry;
> -#endif
> -};
> +#ifdef CONFIG_PM_SLEEP
> +extern void device_power_up(pm_message_t state);
> +extern void device_resume(pm_message_t state);
>
> extern int device_power_down(pm_message_t state);
> -extern void device_power_up(void);
> -extern void device_resume(void);
> -
> -#ifdef CONFIG_PM_SLEEP
> extern int device_suspend(pm_message_t state);
> extern int device_prepare_suspend(pm_message_t state);
>
> Index: linux-2.6/drivers/base/power/main.c
> ===================================================================
> --- linux-2.6.orig/drivers/base/power/main.c
> +++ linux-2.6/drivers/base/power/main.c
> @@ -48,6 +48,7 @@
> */
>
> LIST_HEAD(dpm_active);
> +static LIST_HEAD(dpm_in_transit);
> static LIST_HEAD(dpm_off);
> static LIST_HEAD(dpm_off_irq);
> static LIST_HEAD(dpm_destroy);
> @@ -55,7 +56,7 @@ static LIST_HEAD(dpm_destroy);
> static DEFINE_MUTEX(dpm_list_mtx);
>
> /* 'true' if all devices have been suspended, protected by dpm_list_mtx */
> -static bool all_sleeping;
> +static bool all_inactive;
>
> /**
> * device_pm_add - add a device to the list of active devices
> @@ -69,22 +70,30 @@ int device_pm_add(struct device *dev)
> dev->bus ? dev->bus->name : "No Bus",
> kobject_name(&dev->kobj));
> mutex_lock(&dpm_list_mtx);
> - if ((dev->parent && dev->parent->power.sleeping) || all_sleeping) {
> - if (dev->parent->power.sleeping)
> - dev_warn(dev,
> - "parent %s is sleeping, will not add\n",
> + if (all_inactive) {
> + dev_warn(dev, "all devices are sleeping, will not add\n");
> + goto Refuse;
> + }
> + if (dev->parent)
> + switch (dev->parent->power.status) {
> + case DPM_OFF:
> + dev_warn(dev, "parent %s is sleeping, will not add\n",
> dev->parent->bus_id);
> - else
> - dev_warn(dev, "devices are sleeping, will not add\n");
> - WARN_ON(true);
> - error = -EBUSY;
> - } else {
> - error = dpm_sysfs_add(dev);
> - if (!error)
> - list_add_tail(&dev->power.entry, &dpm_active);
> - }
> + goto Refuse;
> + case DPM_PREPARING:
> + dev->parent->power.status = DPM_ON;
> + break;
> + }
> + error = dpm_sysfs_add(dev);
> + if (!error)
> + list_add_tail(&dev->power.entry, &dpm_active);
> + End:
> mutex_unlock(&dpm_list_mtx);
> return error;
> + Refuse:
> + WARN_ON(true);
> + error = -EBUSY;
> + goto End;
> }
>
> /**
> @@ -122,26 +131,184 @@ void device_pm_schedule_removal(struct d
> }
> EXPORT_SYMBOL_GPL(device_pm_schedule_removal);
>
> +/**
> + * pm_op - execute the PM operation appropiate for given PM event
> + * @dev: Device.
> + * @ops: PM operations to choose from.
> + * @state: PM event message.
> + */
> +static int pm_op(struct device *dev, struct pm_ops *ops, pm_message_t state)
> +{
> + int error = 0;
> +
> + switch (state.event) {
> +#ifdef CONFIG_SUSPEND
> + case PM_EVENT_SUSPEND:
> + if (ops->suspend) {
> + error = ops->suspend(dev);
> + suspend_report_result(ops->suspend, error);
> + }
> + break;
> + case PM_EVENT_RESUME:
> + if (ops->resume) {
> + error = ops->resume(dev);
> + suspend_report_result(ops->resume, error);
> + }
> + break;
> +#endif /* CONFIG_SUSPEND */
> +#ifdef CONFIG_HIBERNATION
> + case PM_EVENT_FREEZE:
> + case PM_EVENT_QUIESCE:
> + if (ops->freeze) {
> + error = ops->freeze(dev);
> + suspend_report_result(ops->freeze, error);
> + }
> + break;
> + case PM_EVENT_HIBERNATE:
> + if (ops->poweroff) {
> + error = ops->poweroff(dev);
> + suspend_report_result(ops->poweroff, error);
> + }
> + break;
> + case PM_EVENT_THAW:
> + case PM_EVENT_RECOVER:
> + if (ops->thaw) {
> + error = ops->thaw(dev);
> + suspend_report_result(ops->thaw, error);
> + }
> + break;
> + case PM_EVENT_RESTORE:
> + if (ops->restore) {
> + error = ops->restore(dev);
> + suspend_report_result(ops->restore, error);
> + }
> + break;
> +#endif /* CONFIG_HIBERNATION */
> + default:
> + error = -EINVAL;
> + }
> + return error;
> +}
> +
> +/**
> + * pm_noirq_op - execute the PM operation appropiate for given PM event
> + * @dev: Device.
> + * @ops: PM operations to choose from.
> + * @state: PM event message.
> + *
> + * The operation is executed with interrupts disabled by the only remaining
> + * functional CPU in the system.
> + */
> +static int pm_noirq_op(struct device *dev, struct pm_noirq_ops *ops,
> + pm_message_t state)
> +{
> + int error = 0;
> +
> + switch (state.event) {
> +#ifdef CONFIG_SUSPEND
> + case PM_EVENT_SUSPEND:
> + if (ops->suspend_noirq) {
> + error = ops->suspend_noirq(dev);
> + suspend_report_result(ops->suspend_noirq, error);
> + }
> + break;
> + case PM_EVENT_RESUME:
> + if (ops->resume_noirq) {
> + error = ops->resume_noirq(dev);
> + suspend_report_result(ops->resume_noirq, error);
> + }
> + break;
> +#endif /* CONFIG_SUSPEND */
> +#ifdef CONFIG_HIBERNATION
> + case PM_EVENT_FREEZE:
> + case PM_EVENT_QUIESCE:
> + if (ops->freeze_noirq) {
> + error = ops->freeze_noirq(dev);
> + suspend_report_result(ops->freeze_noirq, error);
> + }
> + break;
> + case PM_EVENT_HIBERNATE:
> + if (ops->poweroff_noirq) {
> + error = ops->poweroff_noirq(dev);
> + suspend_report_result(ops->poweroff_noirq, error);
> + }
> + break;
> + case PM_EVENT_THAW:
> + case PM_EVENT_RECOVER:
> + if (ops->thaw_noirq) {
> + error = ops->thaw_noirq(dev);
> + suspend_report_result(ops->thaw_noirq, error);
> + }
> + break;
> + case PM_EVENT_RESTORE:
> + if (ops->restore_noirq) {
> + error = ops->restore_noirq(dev);
> + suspend_report_result(ops->restore_noirq, error);
> + }
> + break;
> +#endif /* CONFIG_HIBERNATION */
> + default:
> + error = -EINVAL;
> + }
> + return error;
> +}
> +
> +static char *pm_verb(int event)
> +{
> + switch (event) {
> + case PM_EVENT_SUSPEND:
> + return "suspend";
> + case PM_EVENT_RESUME:
> + return "resume";
> + case PM_EVENT_FREEZE:
> + return "freeze";
> + case PM_EVENT_QUIESCE:
> + return "quiesce";
> + case PM_EVENT_HIBERNATE:
> + return "hibernate";
> + case PM_EVENT_THAW:
> + return "thaw";
> + case PM_EVENT_RESTORE:
> + return "restore";
> + default:
> + return "(unknown PM event)";
> + }
> +}
> +
> +static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
> +{
> + dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
> + ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
> + ", may wakeup" : "");
> +}
> +
> /*------------------------- Resume routines -------------------------*/
>
> /**
> - * resume_device_early - Power on one device (early resume).
> + * resume_device_noirq - Power on one device (early resume).
> * @dev: Device.
> + * @state: Operation to carry out.
> *
> * Must be called with interrupts disabled.
> */
> -static int resume_device_early(struct device *dev)
> +static int resume_device_noirq(struct device *dev, pm_message_t state)
> {
> int error = 0;
>
> TRACE_DEVICE(dev);
> TRACE_RESUME(0);
>
> - if (dev->bus && dev->bus->resume_early) {
> - dev_dbg(dev, "EARLY resume\n");
> + if (!dev->bus)
> + goto End;
> +
> + if (dev->bus->pm_noirq) {
> + pm_dev_dbg(dev, state, "EARLY ");
> + error = pm_noirq_op(dev, dev->bus->pm_noirq, state);
> + } else if (dev->bus->resume_early) {
> + pm_dev_dbg(dev, state, "legacy EARLY ");
> error = dev->bus->resume_early(dev);
> }
> -
> + End:
> TRACE_RESUME(error);
> return error;
> }
> @@ -156,7 +323,7 @@ static int resume_device_early(struct de
> *
> * Must be called with interrupts disabled and only one CPU running.
> */
> -static void dpm_power_up(void)
> +static void dpm_power_up(pm_message_t state)
> {
>
> while (!list_empty(&dpm_off_irq)) {
> @@ -164,7 +331,7 @@ static void dpm_power_up(void)
> struct device *dev = to_device(entry);
>
> list_move_tail(entry, &dpm_off);
> - resume_device_early(dev);
> + resume_device_noirq(dev, state);
> }
> }
>
> @@ -176,19 +343,19 @@ static void dpm_power_up(void)
> *
> * Must be called with interrupts disabled.
> */
> -void device_power_up(void)
> +void device_power_up(pm_message_t state)
> {
> sysdev_resume();
> - dpm_power_up();
> + dpm_power_up(state);
> }
> EXPORT_SYMBOL_GPL(device_power_up);
>
> /**
> * resume_device - Restore state for one device.
> * @dev: Device.
> - *
> + * @state: Operation to carry out.
> */
> -static int resume_device(struct device *dev)
> +static int resume_device(struct device *dev, pm_message_t state)
> {
> int error = 0;
>
> @@ -197,21 +364,40 @@ static int resume_device(struct device *
>
> down(&dev->sem);
>
> - if (dev->bus && dev->bus->resume) {
> - dev_dbg(dev,"resuming\n");
> - error = dev->bus->resume(dev);
> + if (dev->bus) {
> + if (dev->bus->pm) {
> + pm_dev_dbg(dev, state, "");
> + error = pm_op(dev, dev->bus->pm, state);
> + } else if (dev->bus->resume) {
> + pm_dev_dbg(dev, state, "legacy ");
> + error = dev->bus->resume(dev);
> + }
> + if (error)
> + goto End;
> }
>
> - if (!error && dev->type && dev->type->resume) {
> - dev_dbg(dev,"resuming\n");
> - error = dev->type->resume(dev);
> + if (dev->type) {
> + if (dev->type->pm) {
> + pm_dev_dbg(dev, state, "type ");
> + error = pm_op(dev, dev->type->pm, state);
> + } else if (dev->type->resume) {
> + pm_dev_dbg(dev, state, "legacy type ");
> + error = dev->type->resume(dev);
> + }
> + if (error)
> + goto End;
> }
>
> - if (!error && dev->class && dev->class->resume) {
> - dev_dbg(dev,"class resume\n");
> - error = dev->class->resume(dev);
> + if (dev->class) {
> + if (dev->class->pm) {
> + pm_dev_dbg(dev, state, "class ");
> + error = pm_op(dev, dev->class->pm, state);
> + } else if (dev->class->resume) {
> + pm_dev_dbg(dev, state, "legacy class ");
> + error = dev->class->resume(dev);
> + }
> }
> -
> + End:
> up(&dev->sem);
>
> TRACE_RESUME(error);
> @@ -226,20 +412,73 @@ static int resume_device(struct device *
> * went through the early resume.
> *
> * Take devices from the dpm_off_list, resume them,
> - * and put them on the dpm_locked list.
> + * and put them on the dpm_in_transit list.
> */
> -static void dpm_resume(void)
> +static void dpm_resume(pm_message_t state)
> {
> mutex_lock(&dpm_list_mtx);
> - all_sleeping = false;
> while(!list_empty(&dpm_off)) {
> struct list_head *entry = dpm_off.next;
> struct device *dev = to_device(entry);
>
> + list_move_tail(entry, &dpm_in_transit);
> + mutex_unlock(&dpm_list_mtx);
> +
> + resume_device(dev, state);
> +
> + mutex_lock(&dpm_list_mtx);
> + }
> + mutex_unlock(&dpm_list_mtx);
> +}
> +
> +/**
> + * complete_device - Complete a PM transition for given device
> + * @dev: Device.
> + * @state: Power transition we are completing.
> + */
> +static void complete_device(struct device *dev, pm_message_t state)
> +{
> + down(&dev->sem);
> +
> + if (dev->bus && dev->bus->pm && dev->bus->pm->complete) {
> + pm_dev_dbg(dev, state, "completing ");
> + dev->bus->pm->complete(dev);
> + }
> +
> + if (dev->type && dev->type->pm && dev->type->pm->complete) {
> + pm_dev_dbg(dev, state, "completing type ");
> + dev->type->pm->complete(dev);
> + }
> +
> + if (dev->class && dev->class->pm && dev->class->pm->complete) {
> + pm_dev_dbg(dev, state, "completing class ");
> + dev->class->pm->complete(dev);
> + }
> +
> + up(&dev->sem);
> +}
> +
> +/**
> + * dpm_complete - Complete a PM transition for all devices.
> + * @state: Power transition we are completing.
> + *
> + * Take devices from the dpm_in_transit, complete the transition for each
> + * of them and put them on the dpm_active list.
> + */
> +static void dpm_complete(pm_message_t state)
> +{
> + mutex_lock(&dpm_list_mtx);
> + all_inactive = false;
> + while(!list_empty(&dpm_in_transit)) {
> + struct list_head *entry = dpm_in_transit.next;
> + struct device *dev = to_device(entry);
> +
> list_move_tail(entry, &dpm_active);
> - dev->power.sleeping = false;
> + dev->power.status = DPM_ON;
> mutex_unlock(&dpm_list_mtx);
> - resume_device(dev);
> +
> + complete_device(dev, state);
> +
> mutex_lock(&dpm_list_mtx);
> }
> mutex_unlock(&dpm_list_mtx);
> @@ -267,14 +506,16 @@ static void unregister_dropped_devices(v
>
> /**
> * device_resume - Restore state of each device in system.
> + * @state: Operation to carry out.
> *
> * Resume all the devices, unlock them all, and allow new
> * devices to be registered once again.
> */
> -void device_resume(void)
> +void device_resume(pm_message_t state)
> {
> might_sleep();
> - dpm_resume();
> + dpm_resume(state);
> + dpm_complete(state);
> unregister_dropped_devices();
> }
> EXPORT_SYMBOL_GPL(device_resume);
> @@ -282,37 +523,44 @@ EXPORT_SYMBOL_GPL(device_resume);
>
> /*------------------------- Suspend routines -------------------------*/
>
> -static inline char *suspend_verb(u32 event)
> +/**
> + * resume_event - return a PM message representing the resume event
> + * corresponding to given sleep state.
> + * @sleep_state - PM message representing a sleep state
> + */
> +static pm_message_t resume_event(pm_message_t sleep_state)
> {
> - switch (event) {
> - case PM_EVENT_SUSPEND: return "suspend";
> - case PM_EVENT_FREEZE: return "freeze";
> - case PM_EVENT_PRETHAW: return "prethaw";
> - default: return "(unknown suspend event)";
> + switch (sleep_state.event) {
> + case PM_EVENT_SUSPEND:
> + return PMSG_RESUME;
> + case PM_EVENT_FREEZE:
> + case PM_EVENT_QUIESCE:
> + return PMSG_RECOVER;
> + case PM_EVENT_HIBERNATE:
> + return PMSG_RESTORE;
> }
> -}
> -
> -static void
> -suspend_device_dbg(struct device *dev, pm_message_t state, char *info)
> -{
> - dev_dbg(dev, "%s%s%s\n", info, suspend_verb(state.event),
> - ((state.event == PM_EVENT_SUSPEND) && device_may_wakeup(dev)) ?
> - ", may wakeup" : "");
> + return PMSG_ON;
> }
>
> /**
> - * suspend_device_late - Shut down one device (late suspend).
> + * suspend_device_noirq - Shut down one device (late suspend).
> * @dev: Device.
> - * @state: Power state device is entering.
> + * @state: PM message representing the operation to perform.
> *
> * This is called with interrupts off and only a single CPU running.
> */
> -static int suspend_device_late(struct device *dev, pm_message_t state)
> +static int suspend_device_noirq(struct device *dev, pm_message_t state)
> {
> int error = 0;
>
> - if (dev->bus && dev->bus->suspend_late) {
> - suspend_device_dbg(dev, state, "LATE ");
> + if (!dev->bus)
> + return 0;
> +
> + if (dev->bus->pm_noirq) {
> + pm_dev_dbg(dev, state, "LATE ");
> + error = pm_noirq_op(dev, dev->bus->pm_noirq, state);
> + } else if (dev->bus->suspend_late) {
> + pm_dev_dbg(dev, state, "legacy LATE ");
> error = dev->bus->suspend_late(dev, state);
> suspend_report_result(dev->bus->suspend_late, error);
> }
> @@ -321,7 +569,7 @@ static int suspend_device_late(struct de
>
> /**
> * device_power_down - Shut down special devices.
> - * @state: Power state to enter.
> + * @state: PM message representing the operation to perform.
> *
> * Power down devices that require interrupts to be disabled
> * and move them from the dpm_off list to the dpm_off_irq list.
> @@ -337,7 +585,7 @@ int device_power_down(pm_message_t state
> struct list_head *entry = dpm_off.prev;
> struct device *dev = to_device(entry);
>
> - error = suspend_device_late(dev, state);
> + error = suspend_device_noirq(dev, state);
> if (error) {
> printk(KERN_ERR "Could not power down device %s: "
> "error %d\n",
> @@ -351,7 +599,7 @@ int device_power_down(pm_message_t state
> if (!error)
> error = sysdev_suspend(state);
> if (error)
> - dpm_power_up();
> + dpm_power_up(resume_event(state));
> return error;
> }
> EXPORT_SYMBOL_GPL(device_power_down);
> @@ -367,29 +615,43 @@ static int suspend_device(struct device
>
> down(&dev->sem);
>
> - if (dev->power.power_state.event) {
> - dev_dbg(dev, "PM: suspend %d-->%d\n",
> - dev->power.power_state.event, state.event);
> - }
> -
> - if (dev->class && dev->class->suspend) {
> - suspend_device_dbg(dev, state, "class ");
> - error = dev->class->suspend(dev, state);
> - suspend_report_result(dev->class->suspend, error);
> + if (dev->class) {
> + if (dev->class->pm) {
> + pm_dev_dbg(dev, state, "class ");
> + error = pm_op(dev, dev->class->pm, state);
> + } else if (dev->class->suspend) {
> + pm_dev_dbg(dev, state, "legacy class ");
> + error = dev->class->suspend(dev, state);
> + suspend_report_result(dev->class->suspend, error);
> + }
> + if (error)
> + goto End;
> }
>
> - if (!error && dev->type && dev->type->suspend) {
> - suspend_device_dbg(dev, state, "type ");
> - error = dev->type->suspend(dev, state);
> - suspend_report_result(dev->type->suspend, error);
> + if (dev->type) {
> + if (dev->type->pm) {
> + pm_dev_dbg(dev, state, "type ");
> + error = pm_op(dev, dev->type->pm, state);
> + } else if (dev->type->suspend) {
> + pm_dev_dbg(dev, state, "legacy type ");
> + error = dev->type->suspend(dev, state);
> + suspend_report_result(dev->type->suspend, error);
> + }
> + if (error)
> + goto End;
> }
>
> - if (!error && dev->bus && dev->bus->suspend) {
> - suspend_device_dbg(dev, state, "");
> - error = dev->bus->suspend(dev, state);
> - suspend_report_result(dev->bus->suspend, error);
> + if (dev->bus) {
> + if (dev->bus->pm) {
> + pm_dev_dbg(dev, state, "");
> + error = pm_op(dev, dev->bus->pm, state);
> + } else if (dev->bus->suspend) {
> + pm_dev_dbg(dev, state, "legacy ");
> + error = dev->bus->suspend(dev, state);
> + suspend_report_result(dev->bus->suspend, error);
> + }
> }
> -
> + End:
> up(&dev->sem);
>
> return error;
> @@ -399,65 +661,140 @@ static int suspend_device(struct device
> * dpm_suspend - Suspend every device.
> * @state: Power state to put each device in.
> *
> - * Walk the dpm_locked list. Suspend each device and move it
> - * to the dpm_off list.
> - *
> - * (For historical reasons, if it returns -EAGAIN, that used to mean
> - * that the device would be called again with interrupts disabled.
> - * These days, we use the "suspend_late()" callback for that, so we
> - * print a warning and consider it an error).
> + * Walk the dpm_in_transit list. Suspend each device and move it to the
> + * dpm_off list.
> */
> static int dpm_suspend(pm_message_t state)
> {
> int error = 0;
>
> mutex_lock(&dpm_list_mtx);
> - while (!list_empty(&dpm_active)) {
> - struct list_head *entry = dpm_active.prev;
> + while (!list_empty(&dpm_in_transit)) {
> + struct list_head *entry = dpm_in_transit.prev;
> struct device *dev = to_device(entry);
>
> - WARN_ON(dev->parent && dev->parent->power.sleeping);
> -
> - dev->power.sleeping = true;
> mutex_unlock(&dpm_list_mtx);
> +
> error = suspend_device(dev, state);
> +
> mutex_lock(&dpm_list_mtx);
> if (error) {
> printk(KERN_ERR "Could not suspend device %s: "
> - "error %d%s\n",
> - kobject_name(&dev->kobj),
> - error,
> - (error == -EAGAIN ?
> - " (please convert to suspend_late)" :
> - ""));
> - dev->power.sleeping = false;
> + "error %d\n", kobject_name(&dev->kobj), error);
> break;
> }
> if (!list_empty(&dev->power.entry))
> list_move(&dev->power.entry, &dpm_off);
> }
> - if (!error)
> - all_sleeping = true;
> mutex_unlock(&dpm_list_mtx);
> + return error;
> +}
> +
> +/**
> + * prepare_device - Execute the ->prepare() callback(s) for given device.
> + * @dev: Device.
> + * @state: PM operation we are preparing for.
> + */
> +static int prepare_device(struct device *dev, pm_message_t state)
> +{
> + int error = 0;
> +
> + down(&dev->sem);
> +
> + if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
> + pm_dev_dbg(dev, state, "preparing ");
> + error = dev->bus->pm->prepare(dev);
> + suspend_report_result(dev->bus->pm->prepare, error);
> + if (error)
> + goto End;
> + }
> +
> + if (dev->type && dev->type->pm && dev->type->pm->prepare) {
> + pm_dev_dbg(dev, state, "preparing type ");
> + error = dev->type->pm->prepare(dev);
> + suspend_report_result(dev->type->pm->prepare, error);
> + if (error)
> + goto End;
> + }
> +
> + if (dev->class && dev->class->pm && dev->class->pm->prepare) {
> + pm_dev_dbg(dev, state, "preparing class ");
> + error = dev->class->pm->prepare(dev);
> + suspend_report_result(dev->class->pm->prepare, error);
> + }
> + End:
> + up(&dev->sem);
>
> return error;
> }
>
> /**
> + * dpm_prepare - Prepare all devices for a PM transition.
> + * @state: Power state to put each device in.
> + *
> + * Walk the dpm_active list. Prepare each device and move it to the
> + * dpm_in_transit list.
> + */
> +static int dpm_prepare(pm_message_t state)
> +{
> + int error = 0;
> +
> + mutex_lock(&dpm_list_mtx);
> + while (!list_empty(&dpm_active)) {
> + struct list_head *entry = dpm_active.prev;
> + struct device *dev = to_device(entry);
> +
> + WARN_ON(dev->parent && dev->parent->power.status == DPM_OFF);
> + dev->power.status = DPM_PREPARING;
> + mutex_unlock(&dpm_list_mtx);
> +
> + error = prepare_device(dev, state);
> +
> + mutex_lock(&dpm_list_mtx);
> + if (error) {
> + dev->power.status = DPM_ON;
> + if (error == -EAGAIN)
> + continue;
> + printk(KERN_ERR "Could not prepare device %s "
> + "for suspend: error %d\n",
> + kobject_name(&dev->kobj), error);
> + goto End;
> + }
> + if (dev->power.status == DPM_ON) {
> + /* Child added during prepare_device() */
> + mutex_unlock(&dpm_list_mtx);
> +
> + complete_device(dev, resume_event(state));
> +
> + mutex_lock(&dpm_list_mtx);
> + continue;
> + }
> + dev->power.status = DPM_OFF;
> + if (!list_empty(&dev->power.entry))
> + list_move(&dev->power.entry, &dpm_in_transit);
> + }
> + all_inactive = true;
> + End:
> + mutex_unlock(&dpm_list_mtx);
> + return error;
> +}
> +
> +/**
> * device_suspend - Save state and stop all devices in system.
> * @state: new power management state
> *
> - * Prevent new devices from being registered, then lock all devices
> - * and suspend them.
> + * Prepare and suspend all devices.
> */
> int device_suspend(pm_message_t state)
> {
> int error;
>
> might_sleep();
> - error = dpm_suspend(state);
> + error = dpm_prepare(state);
> + if (!error)
> + error = dpm_suspend(state);
> if (error)
> - device_resume();
> + device_resume(resume_event(state));
> return error;
> }
> EXPORT_SYMBOL_GPL(device_suspend);
> Index: linux-2.6/include/linux/device.h
> ===================================================================
> --- linux-2.6.orig/include/linux/device.h
> +++ linux-2.6/include/linux/device.h
> @@ -69,6 +69,9 @@ struct bus_type {
> int (*resume_early)(struct device *dev);
> int (*resume)(struct device *dev);
>
> + struct pm_ops *pm;
> + struct pm_noirq_ops *pm_noirq;
> +
> struct bus_type_private *p;
> };
>
> @@ -202,6 +205,8 @@ struct class {
>
> int (*suspend)(struct device *dev, pm_message_t state);
> int (*resume)(struct device *dev);
> +
> + struct pm_ops *pm;
> };
>
> extern int __must_check class_register(struct class *class);
> @@ -345,8 +350,11 @@ struct device_type {
> struct attribute_group **groups;
> int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
> void (*release)(struct device *dev);
> +
> int (*suspend)(struct device *dev, pm_message_t state);
> int (*resume)(struct device *dev);
> +
> + struct pm_ops *pm;
> };
>
> /* interface for exporting device attributes */
> Index: linux-2.6/kernel/power/disk.c
> ===================================================================
> --- linux-2.6.orig/kernel/power/disk.c
> +++ linux-2.6/kernel/power/disk.c
> @@ -224,7 +224,7 @@ static int create_image(int platform_mod
> /* NOTE: device_power_up() is just a resume() for devices
> * that suspended with irqs off ... no overall powerup.
> */
> - device_power_up();
> + device_power_up(in_suspend ? PMSG_RECOVER : PMSG_RESTORE);
> Enable_irqs:
> local_irq_enable();
> return error;
> @@ -280,7 +280,7 @@ int hibernation_snapshot(int platform_mo
> Finish:
> platform_finish(platform_mode);
> Resume_devices:
> - device_resume();
> + device_resume(in_suspend ? PMSG_RECOVER : PMSG_RESTORE);
> Resume_console:
> resume_console();
> Close:
> @@ -301,7 +301,7 @@ static int resume_target_kernel(void)
> int error;
>
> local_irq_disable();
> - error = device_power_down(PMSG_PRETHAW);
> + error = device_power_down(PMSG_QUIESCE);
> if (error) {
> printk(KERN_ERR "PM: Some devices failed to power down, "
> "aborting resume\n");
> @@ -329,7 +329,7 @@ static int resume_target_kernel(void)
> swsusp_free();
> restore_processor_state();
> touch_softlockup_watchdog();
> - device_power_up();
> + device_power_up(PMSG_THAW);
> Enable_irqs:
> local_irq_enable();
> return error;
> @@ -350,7 +350,7 @@ int hibernation_restore(int platform_mod
>
> pm_prepare_console();
> suspend_console();
> - error = device_suspend(PMSG_PRETHAW);
> + error = device_suspend(PMSG_QUIESCE);
> if (error)
> goto Finish;
>
> @@ -362,7 +362,7 @@ int hibernation_restore(int platform_mod
> enable_nonboot_cpus();
> }
> platform_restore_cleanup(platform_mode);
> - device_resume();
> + device_resume(PMSG_RECOVER);
> Finish:
> resume_console();
> pm_restore_console();
> @@ -419,7 +419,7 @@ int hibernation_platform_enter(void)
> Finish:
> hibernation_ops->finish();
> Resume_devices:
> - device_resume();
> + device_resume(PMSG_RESTORE);
> Resume_console:
> resume_console();
> Close:
> Index: linux-2.6/kernel/power/main.c
> ===================================================================
> --- linux-2.6.orig/kernel/power/main.c
> +++ linux-2.6/kernel/power/main.c
> @@ -239,7 +239,7 @@ static int suspend_enter(suspend_state_t
> if (!suspend_test(TEST_CORE))
> error = suspend_ops->enter(state);
>
> - device_power_up();
> + device_power_up(PMSG_RESUME);
> Done:
> arch_suspend_enable_irqs();
> BUG_ON(irqs_disabled());
> @@ -291,7 +291,7 @@ int suspend_devices_and_enter(suspend_st
> if (suspend_ops->finish)
> suspend_ops->finish();
> Resume_devices:
> - device_resume();
> + device_resume(PMSG_RESUME);
> Resume_console:
> resume_console();
> Close:
> Index: linux-2.6/arch/x86/kernel/apm_32.c
> ===================================================================
> --- linux-2.6.orig/arch/x86/kernel/apm_32.c
> +++ linux-2.6/arch/x86/kernel/apm_32.c
> @@ -1208,9 +1208,9 @@ static int suspend(int vetoable)
> if (err != APM_SUCCESS)
> apm_error("suspend", err);
> err = (err == APM_SUCCESS) ? 0 : -EIO;
> - device_power_up();
> + device_power_up(PMSG_RESUME);
> local_irq_enable();
> - device_resume();
> + device_resume(PMSG_RESUME);
> queue_event(APM_NORMAL_RESUME, NULL);
> out:
> spin_lock(&user_list_lock);
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/
--
To unsubscribe from this list: send the line "unsubscribe linux-acpi" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
