Merge branch 'hwmon-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6

[powerpc.git] / kernel / power / user.c

diff --git a/kernel/power/user.c b/kernel/power/user.c
index 4f21768..040560d 100644 (file)
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -33,24 +33,29 @@
 static struct snapshot_data {
        struct snapshot_handle handle;
        int swap;
-       struct bitmap_page *bitmap;
        int mode;
        char frozen;
        char ready;
+       char platform_suspend;
 } snapshot_state;
 
-static atomic_t device_available = ATOMIC_INIT(1);
+atomic_t snapshot_device_available = ATOMIC_INIT(1);
 
 static int snapshot_open(struct inode *inode, struct file *filp)
 {
        struct snapshot_data *data;
 
-       if (!atomic_add_unless(&device_available, -1, 0))
+       if (!atomic_add_unless(&snapshot_device_available, -1, 0))
                return -EBUSY;
 
-       if ((filp->f_flags & O_ACCMODE) == O_RDWR)
+       if ((filp->f_flags & O_ACCMODE) == O_RDWR) {
+               atomic_inc(&snapshot_device_available);
                return -ENOSYS;
-
+       }
+       if(create_basic_memory_bitmaps()) {
+               atomic_inc(&snapshot_device_available);
+               return -ENOMEM;
+       }
        nonseekable_open(inode, filp);
        data = &snapshot_state;
        filp->private_data = data;
@@ -63,9 +68,9 @@ static int snapshot_open(struct inode *inode, struct file *filp)
                data->swap = -1;
                data->mode = O_WRONLY;
        }
-       data->bitmap = NULL;
        data->frozen = 0;
        data->ready = 0;
+       data->platform_suspend = 0;
 
        return 0;
 }
@@ -75,16 +80,15 @@ static int snapshot_release(struct inode *inode, struct file *filp)
        struct snapshot_data *data;
 
        swsusp_free();
+       free_basic_memory_bitmaps();
        data = filp->private_data;
-       free_all_swap_pages(data->swap, data->bitmap);
-       free_bitmap(data->bitmap);
+       free_all_swap_pages(data->swap);
        if (data->frozen) {
                mutex_lock(&pm_mutex);
                thaw_processes();
-               enable_nonboot_cpus();
                mutex_unlock(&pm_mutex);
        }
-       atomic_inc(&device_available);
+       atomic_inc(&snapshot_device_available);
        return 0;
 }
 
@@ -122,7 +126,23 @@ static ssize_t snapshot_write(struct file *filp, const char __user *buf,
        return res;
 }
 
-static inline int snapshot_suspend(void)
+static inline int platform_prepare(void)
+{
+       int error = 0;
+
+       if (pm_ops && pm_ops->prepare)
+               error = pm_ops->prepare(PM_SUSPEND_DISK);
+
+       return error;
+}
+
+static inline void platform_finish(void)
+{
+       if (pm_ops && pm_ops->finish)
+               pm_ops->finish(PM_SUSPEND_DISK);
+}
+
+static inline int snapshot_suspend(int platform_suspend)
 {
        int error;
 
@@ -132,6 +152,11 @@ static inline int snapshot_suspend(void)
        if (error)
                goto Finish;
 
+       if (platform_suspend) {
+               error = platform_prepare();
+               if (error)
+                       goto Finish;
+       }
        suspend_console();
        error = device_suspend(PMSG_FREEZE);
        if (error)
@@ -144,6 +169,9 @@ static inline int snapshot_suspend(void)
        }
        enable_nonboot_cpus();
  Resume_devices:
+       if (platform_suspend)
+               platform_finish();
+
        device_resume();
        resume_console();
  Finish:
@@ -151,12 +179,17 @@ static inline int snapshot_suspend(void)
        return error;
 }
 
-static inline int snapshot_restore(void)
+static inline int snapshot_restore(int platform_suspend)
 {
        int error;
 
        mutex_lock(&pm_mutex);
        pm_prepare_console();
+       if (platform_suspend) {
+               error = platform_prepare();
+               if (error)
+                       goto Finish;
+       }
        suspend_console();
        error = device_suspend(PMSG_PRETHAW);
        if (error)
@@ -168,8 +201,12 @@ static inline int snapshot_restore(void)
 
        enable_nonboot_cpus();
  Resume_devices:
+       if (platform_suspend)
+               platform_finish();
+
        device_resume();
        resume_console();
+ Finish:
        pm_restore_console();
        mutex_unlock(&pm_mutex);
        return error;
@@ -221,7 +258,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                        error = -EPERM;
                        break;
                }
-               error = snapshot_suspend();
+               error = snapshot_suspend(data->platform_suspend);
                if (!error)
                        error = put_user(in_suspend, (unsigned int __user *)arg);
                if (!error)
@@ -235,7 +272,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                        error = -EPERM;
                        break;
                }
-               error = snapshot_restore();
+               error = snapshot_restore(data->platform_suspend);
                break;
 
        case SNAPSHOT_FREE:
@@ -259,14 +296,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                        error = -ENODEV;
                        break;
                }
-               if (!data->bitmap) {
-                       data->bitmap = alloc_bitmap(count_swap_pages(data->swap, 0));
-                       if (!data->bitmap) {
-                               error = -ENOMEM;
-                               break;
-                       }
-               }
-               offset = alloc_swapdev_block(data->swap, data->bitmap);
+               offset = alloc_swapdev_block(data->swap);
                if (offset) {
                        offset <<= PAGE_SHIFT;
                        error = put_user(offset, (sector_t __user *)arg);
@@ -280,13 +310,11 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                        error = -ENODEV;
                        break;
                }
-               free_all_swap_pages(data->swap, data->bitmap);
-               free_bitmap(data->bitmap);
-               data->bitmap = NULL;
+               free_all_swap_pages(data->swap);
                break;
 
        case SNAPSHOT_SET_SWAP_FILE:
-               if (!data->bitmap) {
+               if (!swsusp_swap_in_use()) {
                        /*
                         * User space encodes device types as two-byte values,
                         * so we need to recode them
@@ -306,6 +334,11 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                break;
 
        case SNAPSHOT_S2RAM:
+               if (!pm_ops) {
+                       error = -ENOSYS;
+                       break;
+               }
+
                if (!data->frozen) {
                        error = -EPERM;
                        break;
@@ -328,9 +361,12 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                if (error) {
                        printk(KERN_ERR "Failed to suspend some devices.\n");
                } else {
-                       /* Enter S3, system is already frozen */
-                       suspend_enter(PM_SUSPEND_MEM);
-
+                       error = disable_nonboot_cpus();
+                       if (!error) {
+                               /* Enter S3, system is already frozen */
+                               suspend_enter(PM_SUSPEND_MEM);
+                               enable_nonboot_cpus();
+                       }
                        /* Wake up devices */
                        device_resume();
                }
@@ -343,34 +379,41 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                break;
 
        case SNAPSHOT_PMOPS:
+               error = -EINVAL;
+
                switch (arg) {
 
                case PMOPS_PREPARE:
-                       if (pm_ops->prepare) {
-                               error = pm_ops->prepare(PM_SUSPEND_DISK);
+                       if (pm_ops && pm_ops->enter) {
+                               data->platform_suspend = 1;
+                               error = 0;
+                       } else {
+                               error = -ENOSYS;
                        }
                        break;
 
                case PMOPS_ENTER:
-                       kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
-                       error = pm_ops->enter(PM_SUSPEND_DISK);
+                       if (data->platform_suspend) {
+                               kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
+                               error = pm_ops->enter(PM_SUSPEND_DISK);
+                               error = 0;
+                       }
                        break;
 
                case PMOPS_FINISH:
-                       if (pm_ops && pm_ops->finish) {
-                               pm_ops->finish(PM_SUSPEND_DISK);
-                       }
+                       if (data->platform_suspend)
+                               error = 0;
+
                        break;
 
                default:
                        printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
-                       error = -EINVAL;
 
                }
                break;
 
        case SNAPSHOT_SET_SWAP_AREA:
-               if (data->bitmap) {
+               if (swsusp_swap_in_use()) {
                        error = -EPERM;
                } else {
                        struct resume_swap_area swap_area;