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