Driver Core: switch all dynamic ksets to kobj_sysfs_ops

[linux-2.6-omap-h63xx.git] / kernel / power / main.c

diff --git a/kernel/power/main.c b/kernel/power/main.c
index 350b485b3b60bdc7679cbd9963ef4ba4b64ed4f3..b8139493b856bcdad1ead4010efaa790a95422f4 100644 (file)
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -20,6 +20,7 @@
 #include <linux/resume-trace.h>
 #include <linux/freezer.h>
 #include <linux/vmstat.h>
+#include <linux/syscalls.h>
 
 #include "power.h"
 
@@ -27,44 +28,40 @@ BLOCKING_NOTIFIER_HEAD(pm_chain_head);
 
 DEFINE_MUTEX(pm_mutex);
 
+unsigned int pm_flags;
+EXPORT_SYMBOL(pm_flags);
+
 #ifdef CONFIG_SUSPEND
 
 /* This is just an arbitrary number */
 #define FREE_PAGE_NUMBER (100)
 
-struct pm_ops *pm_ops;
+static struct platform_suspend_ops *suspend_ops;
 
 /**
- *     pm_set_ops - Set the global power method table. 
+ *     suspend_set_ops - Set the global suspend method table.
  *     @ops:   Pointer to ops structure.
  */
 
-void pm_set_ops(struct pm_ops * ops)
+void suspend_set_ops(struct platform_suspend_ops *ops)
 {
        mutex_lock(&pm_mutex);
-       pm_ops = ops;
+       suspend_ops = ops;
        mutex_unlock(&pm_mutex);
 }
 
 /**
- * pm_valid_only_mem - generic memory-only valid callback
+ * suspend_valid_only_mem - generic memory-only valid callback
  *
- * pm_ops drivers that implement mem suspend only and only need
+ * Platform drivers that implement mem suspend only and only need
  * to check for that in their .valid callback can use this instead
  * of rolling their own .valid callback.
  */
-int pm_valid_only_mem(suspend_state_t state)
+int suspend_valid_only_mem(suspend_state_t state)
 {
        return state == PM_SUSPEND_MEM;
 }
 
-
-static inline void pm_finish(suspend_state_t state)
-{
-       if (pm_ops->finish)
-               pm_ops->finish(state);
-}
-
 /**
  *     suspend_prepare - Do prep work before entering low-power state.
  *
@@ -76,7 +73,7 @@ static int suspend_prepare(void)
        int error;
        unsigned int free_pages;
 
-       if (!pm_ops || !pm_ops->enter)
+       if (!suspend_ops || !suspend_ops->enter)
                return -EPERM;
 
        error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
@@ -128,7 +125,7 @@ void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
  *
  *     This function should be called after devices have been suspended.
  */
-int suspend_enter(suspend_state_t state)
+static int suspend_enter(suspend_state_t state)
 {
        int error = 0;
 
@@ -139,7 +136,7 @@ int suspend_enter(suspend_state_t state)
                printk(KERN_ERR "Some devices failed to power down\n");
                goto Done;
        }
-       error = pm_ops->enter(state);
+       error = suspend_ops->enter(state);
        device_power_up();
  Done:
        arch_suspend_enable_irqs();
@@ -156,11 +153,11 @@ int suspend_devices_and_enter(suspend_state_t state)
 {
        int error;
 
-       if (!pm_ops)
+       if (!suspend_ops)
                return -ENOSYS;
 
-       if (pm_ops->set_target) {
-               error = pm_ops->set_target(state);
+       if (suspend_ops->set_target) {
+               error = suspend_ops->set_target(state);
                if (error)
                        return error;
        }
@@ -170,8 +167,8 @@ int suspend_devices_and_enter(suspend_state_t state)
                printk(KERN_ERR "Some devices failed to suspend\n");
                goto Resume_console;
        }
-       if (pm_ops->prepare) {
-               error = pm_ops->prepare(state);
+       if (suspend_ops->prepare) {
+               error = suspend_ops->prepare();
                if (error)
                        goto Resume_devices;
        }
@@ -180,7 +177,8 @@ int suspend_devices_and_enter(suspend_state_t state)
                suspend_enter(state);
 
        enable_nonboot_cpus();
-       pm_finish(state);
+       if (suspend_ops->finish)
+               suspend_ops->finish();
  Resume_devices:
        device_resume();
  Resume_console:
@@ -214,7 +212,7 @@ static inline int valid_state(suspend_state_t state)
        /* All states need lowlevel support and need to be valid
         * to the lowlevel implementation, no valid callback
         * implies that none are valid. */
-       if (!pm_ops || !pm_ops->valid || !pm_ops->valid(state))
+       if (!suspend_ops || !suspend_ops->valid || !suspend_ops->valid(state))
                return 0;
        return 1;
 }
@@ -236,9 +234,14 @@ static int enter_state(suspend_state_t state)
 
        if (!valid_state(state))
                return -ENODEV;
+
        if (!mutex_trylock(&pm_mutex))
                return -EBUSY;
 
+       printk("Syncing filesystems ... ");
+       sys_sync();
+       printk("done.\n");
+
        pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
        if ((error = suspend_prepare()))
                goto Unlock;
@@ -273,8 +276,7 @@ EXPORT_SYMBOL(pm_suspend);
 
 #endif /* CONFIG_SUSPEND */
 
-decl_subsys(power,NULL,NULL);
-
+struct kset *power_kset;
 
 /**
  *     state - control system power state.
@@ -287,7 +289,8 @@ decl_subsys(power,NULL,NULL);
  *     proper enumerated value, and initiates a suspend transition.
  */
 
-static ssize_t state_show(struct kset *kset, char *buf)
+static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
+                         char *buf)
 {
        char *s = buf;
 #ifdef CONFIG_SUSPEND
@@ -308,7 +311,8 @@ static ssize_t state_show(struct kset *kset, char *buf)
        return (s - buf);
 }
 
-static ssize_t state_store(struct kset *kset, const char *buf, size_t n)
+static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
+                          const char *buf, size_t n)
 {
 #ifdef CONFIG_SUSPEND
        suspend_state_t state = PM_SUSPEND_STANDBY;
@@ -345,13 +349,15 @@ power_attr(state);
 #ifdef CONFIG_PM_TRACE
 int pm_trace_enabled;
 
-static ssize_t pm_trace_show(struct kset *kset, char *buf)
+static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
+                            char *buf)
 {
        return sprintf(buf, "%d\n", pm_trace_enabled);
 }
 
 static ssize_t
-pm_trace_store(struct kset *kset, const char *buf, size_t n)
+pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
+              const char *buf, size_t n)
 {
        int val;
 
@@ -383,10 +389,10 @@ static struct attribute_group attr_group = {
 
 static int __init pm_init(void)
 {
-       int error = subsystem_register(&power_subsys);
-       if (!error)
-               error = sysfs_create_group(&power_subsys.kobj,&attr_group);
-       return error;
+       power_kset = kset_create_and_add("power", NULL, NULL);
+       if (!power_kset)
+               return -ENOMEM;
+       return sysfs_create_group(&power_kset->kobj, &attr_group);
 }
 
 core_initcall(pm_init);