PM core: rename suspend and resume functions
[sfrench/cifs-2.6.git] / drivers / base / power / main.c
index c5a35bc9d63b37aea24585763f2fc518a9583177..1f3d82260db41d5fef70895db9d158325c5c3440 100644 (file)
@@ -315,13 +315,13 @@ static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
 /*------------------------- Resume routines -------------------------*/
 
 /**
- *     __device_resume_noirq - Power on one device (early resume).
+ *     device_resume_noirq - Power on one device (early resume).
  *     @dev:   Device.
  *     @state: PM transition of the system being carried out.
  *
  *     Must be called with interrupts disabled.
  */
-static int __device_resume_noirq(struct device *dev, pm_message_t state)
+static int device_resume_noirq(struct device *dev, pm_message_t state)
 {
        int error = 0;
 
@@ -344,16 +344,16 @@ static int __device_resume_noirq(struct device *dev, pm_message_t state)
 }
 
 /**
- *     dpm_power_up - Power on all regular (non-sysdev) devices.
+ *     dpm_resume_noirq - Power on all regular (non-sysdev) devices.
  *     @state: PM transition of the system being carried out.
  *
- *     Execute the appropriate "noirq resume" callback for all devices marked
- *     as DPM_OFF_IRQ.
+ *     Call the "noirq" resume handlers for all devices marked as
+ *     DPM_OFF_IRQ and enable device drivers to receive interrupts.
  *
  *     Must be called under dpm_list_mtx.  Device drivers should not receive
  *     interrupts while it's being executed.
  */
-static void dpm_power_up(pm_message_t state)
+void dpm_resume_noirq(pm_message_t state)
 {
        struct device *dev;
 
@@ -363,33 +363,21 @@ static void dpm_power_up(pm_message_t state)
                        int error;
 
                        dev->power.status = DPM_OFF;
-                       error = __device_resume_noirq(dev, state);
+                       error = device_resume_noirq(dev, state);
                        if (error)
                                pm_dev_err(dev, state, " early", error);
                }
        mutex_unlock(&dpm_list_mtx);
-}
-
-/**
- *     device_resume_noirq - Turn on all devices that need special attention.
- *     @state: PM transition of the system being carried out.
- *
- *     Call the "early" resume handlers and enable device drivers to receive
- *     interrupts.
- */
-void device_resume_noirq(pm_message_t state)
-{
-       dpm_power_up(state);
        resume_device_irqs();
 }
-EXPORT_SYMBOL_GPL(device_resume_noirq);
+EXPORT_SYMBOL_GPL(dpm_resume_noirq);
 
 /**
- *     resume_device - Restore state for one device.
+ *     device_resume - Restore state for one device.
  *     @dev:   Device.
  *     @state: PM transition of the system being carried out.
  */
-static int resume_device(struct device *dev, pm_message_t state)
+static int device_resume(struct device *dev, pm_message_t state)
 {
        int error = 0;
 
@@ -462,7 +450,7 @@ static void dpm_resume(pm_message_t state)
                        dev->power.status = DPM_RESUMING;
                        mutex_unlock(&dpm_list_mtx);
 
-                       error = resume_device(dev, state);
+                       error = device_resume(dev, state);
 
                        mutex_lock(&dpm_list_mtx);
                        if (error)
@@ -480,11 +468,11 @@ static void dpm_resume(pm_message_t state)
 }
 
 /**
- *     complete_device - Complete a PM transition for given device
+ *     device_complete - Complete a PM transition for given device
  *     @dev:   Device.
  *     @state: PM transition of the system being carried out.
  */
-static void complete_device(struct device *dev, pm_message_t state)
+static void device_complete(struct device *dev, pm_message_t state)
 {
        down(&dev->sem);
 
@@ -527,7 +515,7 @@ static void dpm_complete(pm_message_t state)
                        dev->power.status = DPM_ON;
                        mutex_unlock(&dpm_list_mtx);
 
-                       complete_device(dev, state);
+                       device_complete(dev, state);
 
                        mutex_lock(&dpm_list_mtx);
                }
@@ -540,19 +528,19 @@ static void dpm_complete(pm_message_t state)
 }
 
 /**
- *     device_resume - Restore state of each device in system.
+ *     dpm_resume_end - Restore state of each device in system.
  *     @state: PM transition of the system being carried out.
  *
  *     Resume all the devices, unlock them all, and allow new
  *     devices to be registered once again.
  */
-void device_resume(pm_message_t state)
+void dpm_resume_end(pm_message_t state)
 {
        might_sleep();
        dpm_resume(state);
        dpm_complete(state);
 }
-EXPORT_SYMBOL_GPL(device_resume);
+EXPORT_SYMBOL_GPL(dpm_resume_end);
 
 
 /*------------------------- Suspend routines -------------------------*/
@@ -577,13 +565,13 @@ static pm_message_t resume_event(pm_message_t sleep_state)
 }
 
 /**
- *     __device_suspend_noirq - Shut down one device (late suspend).
+ *     device_suspend_noirq - Shut down one device (late suspend).
  *     @dev:   Device.
  *     @state: PM transition of the system being carried out.
  *
  *     This is called with interrupts off and only a single CPU running.
  */
-static int __device_suspend_noirq(struct device *dev, pm_message_t state)
+static int device_suspend_noirq(struct device *dev, pm_message_t state)
 {
        int error = 0;
 
@@ -602,15 +590,15 @@ static int __device_suspend_noirq(struct device *dev, pm_message_t state)
 }
 
 /**
- *     device_suspend_noirq - Shut down special devices.
+ *     dpm_suspend_noirq - Power down all regular (non-sysdev) devices.
  *     @state: PM transition of the system being carried out.
  *
- *     Prevent device drivers from receiving interrupts and call the "late"
+ *     Prevent device drivers from receiving interrupts and call the "noirq"
  *     suspend handlers.
  *
  *     Must be called under dpm_list_mtx.
  */
-int device_suspend_noirq(pm_message_t state)
+int dpm_suspend_noirq(pm_message_t state)
 {
        struct device *dev;
        int error = 0;
@@ -618,7 +606,7 @@ int device_suspend_noirq(pm_message_t state)
        suspend_device_irqs();
        mutex_lock(&dpm_list_mtx);
        list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
-               error = __device_suspend_noirq(dev, state);
+               error = device_suspend_noirq(dev, state);
                if (error) {
                        pm_dev_err(dev, state, " late", error);
                        break;
@@ -627,17 +615,17 @@ int device_suspend_noirq(pm_message_t state)
        }
        mutex_unlock(&dpm_list_mtx);
        if (error)
-               device_resume_noirq(resume_event(state));
+               dpm_resume_noirq(resume_event(state));
        return error;
 }
-EXPORT_SYMBOL_GPL(device_suspend_noirq);
+EXPORT_SYMBOL_GPL(dpm_suspend_noirq);
 
 /**
- *     suspend_device - Save state of one device.
+ *     device_suspend - Save state of one device.
  *     @dev:   Device.
  *     @state: PM transition of the system being carried out.
  */
-static int suspend_device(struct device *dev, pm_message_t state)
+static int device_suspend(struct device *dev, pm_message_t state)
 {
        int error = 0;
 
@@ -704,7 +692,7 @@ static int dpm_suspend(pm_message_t state)
                get_device(dev);
                mutex_unlock(&dpm_list_mtx);
 
-               error = suspend_device(dev, state);
+               error = device_suspend(dev, state);
 
                mutex_lock(&dpm_list_mtx);
                if (error) {
@@ -723,11 +711,11 @@ static int dpm_suspend(pm_message_t state)
 }
 
 /**
- *     prepare_device - Execute the ->prepare() callback(s) for given device.
+ *     device_prepare - Execute the ->prepare() callback(s) for given device.
  *     @dev:   Device.
  *     @state: PM transition of the system being carried out.
  */
-static int prepare_device(struct device *dev, pm_message_t state)
+static int device_prepare(struct device *dev, pm_message_t state)
 {
        int error = 0;
 
@@ -781,7 +769,7 @@ static int dpm_prepare(pm_message_t state)
                dev->power.status = DPM_PREPARING;
                mutex_unlock(&dpm_list_mtx);
 
-               error = prepare_device(dev, state);
+               error = device_prepare(dev, state);
 
                mutex_lock(&dpm_list_mtx);
                if (error) {
@@ -807,12 +795,12 @@ static int dpm_prepare(pm_message_t state)
 }
 
 /**
- *     device_suspend - Save state and stop all devices in system.
+ *     dpm_suspend_start - Save state and stop all devices in system.
  *     @state: PM transition of the system being carried out.
  *
  *     Prepare and suspend all devices.
  */
-int device_suspend(pm_message_t state)
+int dpm_suspend_start(pm_message_t state)
 {
        int error;
 
@@ -822,7 +810,7 @@ int device_suspend(pm_message_t state)
                error = dpm_suspend(state);
        return error;
 }
-EXPORT_SYMBOL_GPL(device_suspend);
+EXPORT_SYMBOL_GPL(dpm_suspend_start);
 
 void __suspend_report_result(const char *function, void *fn, int ret)
 {