Merge branch 'master' of /home/trondmy/kernel/linux-2.6/ into merge_linus
[linux-2.6] / kernel / power / disk.c
1 /*
2  * kernel/power/disk.c - Suspend-to-disk support.
3  *
4  * Copyright (c) 2003 Patrick Mochel
5  * Copyright (c) 2003 Open Source Development Lab
6  * Copyright (c) 2004 Pavel Machek <pavel@suse.cz>
7  *
8  * This file is released under the GPLv2.
9  *
10  */
11
12 #include <linux/suspend.h>
13 #include <linux/syscalls.h>
14 #include <linux/reboot.h>
15 #include <linux/string.h>
16 #include <linux/device.h>
17 #include <linux/delay.h>
18 #include <linux/fs.h>
19 #include <linux/mount.h>
20 #include <linux/pm.h>
21 #include <linux/console.h>
22 #include <linux/cpu.h>
23 #include <linux/freezer.h>
24
25 #include "power.h"
26
27
28 static int noresume = 0;
29 char resume_file[256] = CONFIG_PM_STD_PARTITION;
30 dev_t swsusp_resume_device;
31 sector_t swsusp_resume_block;
32
33 /**
34  *      platform_prepare - prepare the machine for hibernation using the
35  *      platform driver if so configured and return an error code if it fails
36  */
37
38 static inline int platform_prepare(void)
39 {
40         int error = 0;
41
42         if (pm_disk_mode == PM_DISK_PLATFORM) {
43                 if (pm_ops && pm_ops->prepare)
44                         error = pm_ops->prepare(PM_SUSPEND_DISK);
45         }
46         return error;
47 }
48
49 /**
50  *      power_down - Shut machine down for hibernate.
51  *      @mode:          Suspend-to-disk mode
52  *
53  *      Use the platform driver, if configured so, and return gracefully if it
54  *      fails.
55  *      Otherwise, try to power off and reboot. If they fail, halt the machine,
56  *      there ain't no turning back.
57  */
58
59 static void power_down(suspend_disk_method_t mode)
60 {
61         switch(mode) {
62         case PM_DISK_PLATFORM:
63                 kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
64                 pm_ops->enter(PM_SUSPEND_DISK);
65                 break;
66         case PM_DISK_SHUTDOWN:
67                 kernel_power_off();
68                 break;
69         case PM_DISK_REBOOT:
70                 kernel_restart(NULL);
71                 break;
72         }
73         kernel_halt();
74         /* Valid image is on the disk, if we continue we risk serious data corruption
75            after resume. */
76         printk(KERN_CRIT "Please power me down manually\n");
77         while(1);
78 }
79
80 static inline void platform_finish(void)
81 {
82         if (pm_disk_mode == PM_DISK_PLATFORM) {
83                 if (pm_ops && pm_ops->finish)
84                         pm_ops->finish(PM_SUSPEND_DISK);
85         }
86 }
87
88 static int prepare_processes(void)
89 {
90         int error = 0;
91
92         pm_prepare_console();
93
94         error = disable_nonboot_cpus();
95         if (error)
96                 goto enable_cpus;
97
98         if (freeze_processes()) {
99                 error = -EBUSY;
100                 goto thaw;
101         }
102
103         if (pm_disk_mode == PM_DISK_TESTPROC) {
104                 printk("swsusp debug: Waiting for 5 seconds.\n");
105                 mdelay(5000);
106                 goto thaw;
107         }
108
109         error = platform_prepare();
110         if (error)
111                 goto thaw;
112
113         /* Free memory before shutting down devices. */
114         if (!(error = swsusp_shrink_memory()))
115                 return 0;
116
117         platform_finish();
118  thaw:
119         thaw_processes();
120  enable_cpus:
121         enable_nonboot_cpus();
122         pm_restore_console();
123         return error;
124 }
125
126 static void unprepare_processes(void)
127 {
128         platform_finish();
129         thaw_processes();
130         enable_nonboot_cpus();
131         pm_restore_console();
132 }
133
134 /**
135  *      pm_suspend_disk - The granpappy of hibernation power management.
136  *
137  *      If we're going through the firmware, then get it over with quickly.
138  *
139  *      If not, then call swsusp to do its thing, then figure out how
140  *      to power down the system.
141  */
142
143 int pm_suspend_disk(void)
144 {
145         int error;
146
147         error = prepare_processes();
148         if (error)
149                 return error;
150
151         if (pm_disk_mode == PM_DISK_TESTPROC)
152                 return 0;
153
154         suspend_console();
155         error = device_suspend(PMSG_FREEZE);
156         if (error) {
157                 resume_console();
158                 printk("Some devices failed to suspend\n");
159                 goto Thaw;
160         }
161
162         if (pm_disk_mode == PM_DISK_TEST) {
163                 printk("swsusp debug: Waiting for 5 seconds.\n");
164                 mdelay(5000);
165                 goto Done;
166         }
167
168         pr_debug("PM: snapshotting memory.\n");
169         in_suspend = 1;
170         if ((error = swsusp_suspend()))
171                 goto Done;
172
173         if (in_suspend) {
174                 device_resume();
175                 resume_console();
176                 pr_debug("PM: writing image.\n");
177                 error = swsusp_write();
178                 if (!error)
179                         power_down(pm_disk_mode);
180                 else {
181                         swsusp_free();
182                         goto Thaw;
183                 }
184         } else {
185                 pr_debug("PM: Image restored successfully.\n");
186         }
187
188         swsusp_free();
189  Done:
190         device_resume();
191         resume_console();
192  Thaw:
193         unprepare_processes();
194         return error;
195 }
196
197
198 /**
199  *      software_resume - Resume from a saved image.
200  *
201  *      Called as a late_initcall (so all devices are discovered and
202  *      initialized), we call swsusp to see if we have a saved image or not.
203  *      If so, we quiesce devices, the restore the saved image. We will
204  *      return above (in pm_suspend_disk() ) if everything goes well.
205  *      Otherwise, we fail gracefully and return to the normally
206  *      scheduled program.
207  *
208  */
209
210 static int software_resume(void)
211 {
212         int error;
213
214         mutex_lock(&pm_mutex);
215         if (!swsusp_resume_device) {
216                 if (!strlen(resume_file)) {
217                         mutex_unlock(&pm_mutex);
218                         return -ENOENT;
219                 }
220                 swsusp_resume_device = name_to_dev_t(resume_file);
221                 pr_debug("swsusp: Resume From Partition %s\n", resume_file);
222         } else {
223                 pr_debug("swsusp: Resume From Partition %d:%d\n",
224                          MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
225         }
226
227         if (noresume) {
228                 /**
229                  * FIXME: If noresume is specified, we need to find the partition
230                  * and reset it back to normal swap space.
231                  */
232                 mutex_unlock(&pm_mutex);
233                 return 0;
234         }
235
236         pr_debug("PM: Checking swsusp image.\n");
237
238         if ((error = swsusp_check()))
239                 goto Done;
240
241         pr_debug("PM: Preparing processes for restore.\n");
242
243         if ((error = prepare_processes())) {
244                 swsusp_close();
245                 goto Done;
246         }
247
248         pr_debug("PM: Reading swsusp image.\n");
249
250         if ((error = swsusp_read())) {
251                 swsusp_free();
252                 goto Thaw;
253         }
254
255         pr_debug("PM: Preparing devices for restore.\n");
256
257         suspend_console();
258         if ((error = device_suspend(PMSG_PRETHAW))) {
259                 resume_console();
260                 printk("Some devices failed to suspend\n");
261                 swsusp_free();
262                 goto Thaw;
263         }
264
265         mb();
266
267         pr_debug("PM: Restoring saved image.\n");
268         swsusp_resume();
269         pr_debug("PM: Restore failed, recovering.n");
270         device_resume();
271         resume_console();
272  Thaw:
273         unprepare_processes();
274  Done:
275         /* For success case, the suspend path will release the lock */
276         mutex_unlock(&pm_mutex);
277         pr_debug("PM: Resume from disk failed.\n");
278         return 0;
279 }
280
281 late_initcall(software_resume);
282
283
284 static const char * const pm_disk_modes[] = {
285         [PM_DISK_FIRMWARE]      = "firmware",
286         [PM_DISK_PLATFORM]      = "platform",
287         [PM_DISK_SHUTDOWN]      = "shutdown",
288         [PM_DISK_REBOOT]        = "reboot",
289         [PM_DISK_TEST]          = "test",
290         [PM_DISK_TESTPROC]      = "testproc",
291 };
292
293 /**
294  *      disk - Control suspend-to-disk mode
295  *
296  *      Suspend-to-disk can be handled in several ways. The greatest
297  *      distinction is who writes memory to disk - the firmware or the OS.
298  *      If the firmware does it, we assume that it also handles suspending
299  *      the system.
300  *      If the OS does it, then we have three options for putting the system
301  *      to sleep - using the platform driver (e.g. ACPI or other PM registers),
302  *      powering off the system or rebooting the system (for testing).
303  *
304  *      The system will support either 'firmware' or 'platform', and that is
305  *      known a priori (and encoded in pm_ops). But, the user may choose
306  *      'shutdown' or 'reboot' as alternatives.
307  *
308  *      show() will display what the mode is currently set to.
309  *      store() will accept one of
310  *
311  *      'firmware'
312  *      'platform'
313  *      'shutdown'
314  *      'reboot'
315  *
316  *      It will only change to 'firmware' or 'platform' if the system
317  *      supports it (as determined from pm_ops->pm_disk_mode).
318  */
319
320 static ssize_t disk_show(struct subsystem * subsys, char * buf)
321 {
322         return sprintf(buf, "%s\n", pm_disk_modes[pm_disk_mode]);
323 }
324
325
326 static ssize_t disk_store(struct subsystem * s, const char * buf, size_t n)
327 {
328         int error = 0;
329         int i;
330         int len;
331         char *p;
332         suspend_disk_method_t mode = 0;
333
334         p = memchr(buf, '\n', n);
335         len = p ? p - buf : n;
336
337         mutex_lock(&pm_mutex);
338         for (i = PM_DISK_FIRMWARE; i < PM_DISK_MAX; i++) {
339                 if (!strncmp(buf, pm_disk_modes[i], len)) {
340                         mode = i;
341                         break;
342                 }
343         }
344         if (mode) {
345                 if (mode == PM_DISK_SHUTDOWN || mode == PM_DISK_REBOOT ||
346                      mode == PM_DISK_TEST || mode == PM_DISK_TESTPROC) {
347                         pm_disk_mode = mode;
348                 } else {
349                         if (pm_ops && pm_ops->enter &&
350                             (mode == pm_ops->pm_disk_mode))
351                                 pm_disk_mode = mode;
352                         else
353                                 error = -EINVAL;
354                 }
355         } else {
356                 error = -EINVAL;
357         }
358
359         pr_debug("PM: suspend-to-disk mode set to '%s'\n",
360                  pm_disk_modes[mode]);
361         mutex_unlock(&pm_mutex);
362         return error ? error : n;
363 }
364
365 power_attr(disk);
366
367 static ssize_t resume_show(struct subsystem * subsys, char *buf)
368 {
369         return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
370                        MINOR(swsusp_resume_device));
371 }
372
373 static ssize_t resume_store(struct subsystem *subsys, const char *buf, size_t n)
374 {
375         unsigned int maj, min;
376         dev_t res;
377         int ret = -EINVAL;
378
379         if (sscanf(buf, "%u:%u", &maj, &min) != 2)
380                 goto out;
381
382         res = MKDEV(maj,min);
383         if (maj != MAJOR(res) || min != MINOR(res))
384                 goto out;
385
386         mutex_lock(&pm_mutex);
387         swsusp_resume_device = res;
388         mutex_unlock(&pm_mutex);
389         printk("Attempting manual resume\n");
390         noresume = 0;
391         software_resume();
392         ret = n;
393  out:
394         return ret;
395 }
396
397 power_attr(resume);
398
399 static ssize_t image_size_show(struct subsystem * subsys, char *buf)
400 {
401         return sprintf(buf, "%lu\n", image_size);
402 }
403
404 static ssize_t image_size_store(struct subsystem * subsys, const char * buf, size_t n)
405 {
406         unsigned long size;
407
408         if (sscanf(buf, "%lu", &size) == 1) {
409                 image_size = size;
410                 return n;
411         }
412
413         return -EINVAL;
414 }
415
416 power_attr(image_size);
417
418 static struct attribute * g[] = {
419         &disk_attr.attr,
420         &resume_attr.attr,
421         &image_size_attr.attr,
422         NULL,
423 };
424
425
426 static struct attribute_group attr_group = {
427         .attrs = g,
428 };
429
430
431 static int __init pm_disk_init(void)
432 {
433         return sysfs_create_group(&power_subsys.kset.kobj,&attr_group);
434 }
435
436 core_initcall(pm_disk_init);
437
438
439 static int __init resume_setup(char *str)
440 {
441         if (noresume)
442                 return 1;
443
444         strncpy( resume_file, str, 255 );
445         return 1;
446 }
447
448 static int __init resume_offset_setup(char *str)
449 {
450         unsigned long long offset;
451
452         if (noresume)
453                 return 1;
454
455         if (sscanf(str, "%llu", &offset) == 1)
456                 swsusp_resume_block = offset;
457
458         return 1;
459 }
460
461 static int __init noresume_setup(char *str)
462 {
463         noresume = 1;
464         return 1;
465 }
466
467 __setup("noresume", noresume_setup);
468 __setup("resume_offset=", resume_offset_setup);
469 __setup("resume=", resume_setup);