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