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