lib: cordic: add library module providing cordic angle calculation
[linux-2.6.git] / kernel / power / hibernate.c
1 /*
2  * kernel/power/hibernate.c - Hibernation (a.k.a 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@ucw.cz>
7  * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
8  *
9  * This file is released under the GPLv2.
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/kmod.h>
18 #include <linux/delay.h>
19 #include <linux/fs.h>
20 #include <linux/mount.h>
21 #include <linux/pm.h>
22 #include <linux/console.h>
23 #include <linux/cpu.h>
24 #include <linux/freezer.h>
25 #include <linux/gfp.h>
26 #include <linux/syscore_ops.h>
27 #include <scsi/scsi_scan.h>
28 #include <asm/suspend.h>
29
30 #include "power.h"
31
32
33 static int nocompress = 0;
34 static int noresume = 0;
35 static char resume_file[256] = CONFIG_PM_STD_PARTITION;
36 dev_t swsusp_resume_device;
37 sector_t swsusp_resume_block;
38 int in_suspend __nosavedata = 0;
39
40 enum {
41         HIBERNATION_INVALID,
42         HIBERNATION_PLATFORM,
43         HIBERNATION_TEST,
44         HIBERNATION_TESTPROC,
45         HIBERNATION_SHUTDOWN,
46         HIBERNATION_REBOOT,
47         /* keep last */
48         __HIBERNATION_AFTER_LAST
49 };
50 #define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
51 #define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
52
53 static int hibernation_mode = HIBERNATION_SHUTDOWN;
54
55 static const struct platform_hibernation_ops *hibernation_ops;
56
57 /**
58  * hibernation_set_ops - set the global hibernate operations
59  * @ops: the hibernation operations to use in subsequent hibernation transitions
60  */
61
62 void hibernation_set_ops(const struct platform_hibernation_ops *ops)
63 {
64         if (ops && !(ops->begin && ops->end &&  ops->pre_snapshot
65             && ops->prepare && ops->finish && ops->enter && ops->pre_restore
66             && ops->restore_cleanup && ops->leave)) {
67                 WARN_ON(1);
68                 return;
69         }
70         mutex_lock(&pm_mutex);
71         hibernation_ops = ops;
72         if (ops)
73                 hibernation_mode = HIBERNATION_PLATFORM;
74         else if (hibernation_mode == HIBERNATION_PLATFORM)
75                 hibernation_mode = HIBERNATION_SHUTDOWN;
76
77         mutex_unlock(&pm_mutex);
78 }
79
80 static bool entering_platform_hibernation;
81
82 bool system_entering_hibernation(void)
83 {
84         return entering_platform_hibernation;
85 }
86 EXPORT_SYMBOL(system_entering_hibernation);
87
88 #ifdef CONFIG_PM_DEBUG
89 static void hibernation_debug_sleep(void)
90 {
91         printk(KERN_INFO "hibernation debug: Waiting for 5 seconds.\n");
92         mdelay(5000);
93 }
94
95 static int hibernation_testmode(int mode)
96 {
97         if (hibernation_mode == mode) {
98                 hibernation_debug_sleep();
99                 return 1;
100         }
101         return 0;
102 }
103
104 static int hibernation_test(int level)
105 {
106         if (pm_test_level == level) {
107                 hibernation_debug_sleep();
108                 return 1;
109         }
110         return 0;
111 }
112 #else /* !CONFIG_PM_DEBUG */
113 static int hibernation_testmode(int mode) { return 0; }
114 static int hibernation_test(int level) { return 0; }
115 #endif /* !CONFIG_PM_DEBUG */
116
117 /**
118  *      platform_begin - tell the platform driver that we're starting
119  *      hibernation
120  */
121
122 static int platform_begin(int platform_mode)
123 {
124         return (platform_mode && hibernation_ops) ?
125                 hibernation_ops->begin() : 0;
126 }
127
128 /**
129  *      platform_end - tell the platform driver that we've entered the
130  *      working state
131  */
132
133 static void platform_end(int platform_mode)
134 {
135         if (platform_mode && hibernation_ops)
136                 hibernation_ops->end();
137 }
138
139 /**
140  *      platform_pre_snapshot - prepare the machine for hibernation using the
141  *      platform driver if so configured and return an error code if it fails
142  */
143
144 static int platform_pre_snapshot(int platform_mode)
145 {
146         return (platform_mode && hibernation_ops) ?
147                 hibernation_ops->pre_snapshot() : 0;
148 }
149
150 /**
151  *      platform_leave - prepare the machine for switching to the normal mode
152  *      of operation using the platform driver (called with interrupts disabled)
153  */
154
155 static void platform_leave(int platform_mode)
156 {
157         if (platform_mode && hibernation_ops)
158                 hibernation_ops->leave();
159 }
160
161 /**
162  *      platform_finish - switch the machine to the normal mode of operation
163  *      using the platform driver (must be called after platform_prepare())
164  */
165
166 static void platform_finish(int platform_mode)
167 {
168         if (platform_mode && hibernation_ops)
169                 hibernation_ops->finish();
170 }
171
172 /**
173  *      platform_pre_restore - prepare the platform for the restoration from a
174  *      hibernation image.  If the restore fails after this function has been
175  *      called, platform_restore_cleanup() must be called.
176  */
177
178 static int platform_pre_restore(int platform_mode)
179 {
180         return (platform_mode && hibernation_ops) ?
181                 hibernation_ops->pre_restore() : 0;
182 }
183
184 /**
185  *      platform_restore_cleanup - switch the platform to the normal mode of
186  *      operation after a failing restore.  If platform_pre_restore() has been
187  *      called before the failing restore, this function must be called too,
188  *      regardless of the result of platform_pre_restore().
189  */
190
191 static void platform_restore_cleanup(int platform_mode)
192 {
193         if (platform_mode && hibernation_ops)
194                 hibernation_ops->restore_cleanup();
195 }
196
197 /**
198  *      platform_recover - recover the platform from a failure to suspend
199  *      devices.
200  */
201
202 static void platform_recover(int platform_mode)
203 {
204         if (platform_mode && hibernation_ops && hibernation_ops->recover)
205                 hibernation_ops->recover();
206 }
207
208 /**
209  *      swsusp_show_speed - print the time elapsed between two events.
210  *      @start: Starting event.
211  *      @stop: Final event.
212  *      @nr_pages -     number of pages processed between @start and @stop
213  *      @msg -          introductory message to print
214  */
215
216 void swsusp_show_speed(struct timeval *start, struct timeval *stop,
217                         unsigned nr_pages, char *msg)
218 {
219         s64 elapsed_centisecs64;
220         int centisecs;
221         int k;
222         int kps;
223
224         elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
225         do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
226         centisecs = elapsed_centisecs64;
227         if (centisecs == 0)
228                 centisecs = 1;  /* avoid div-by-zero */
229         k = nr_pages * (PAGE_SIZE / 1024);
230         kps = (k * 100) / centisecs;
231         printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
232                         msg, k,
233                         centisecs / 100, centisecs % 100,
234                         kps / 1000, (kps % 1000) / 10);
235 }
236
237 /**
238  *      create_image - freeze devices that need to be frozen with interrupts
239  *      off, create the hibernation image and thaw those devices.  Control
240  *      reappears in this routine after a restore.
241  */
242
243 static int create_image(int platform_mode)
244 {
245         int error;
246
247         error = arch_prepare_suspend();
248         if (error)
249                 return error;
250
251         /* At this point, dpm_suspend_start() has been called, but *not*
252          * dpm_suspend_noirq(). We *must* call dpm_suspend_noirq() now.
253          * Otherwise, drivers for some devices (e.g. interrupt controllers)
254          * become desynchronized with the actual state of the hardware
255          * at resume time, and evil weirdness ensues.
256          */
257         error = dpm_suspend_noirq(PMSG_FREEZE);
258         if (error) {
259                 printk(KERN_ERR "PM: Some devices failed to power down, "
260                         "aborting hibernation\n");
261                 return error;
262         }
263
264         error = platform_pre_snapshot(platform_mode);
265         if (error || hibernation_test(TEST_PLATFORM))
266                 goto Platform_finish;
267
268         error = disable_nonboot_cpus();
269         if (error || hibernation_test(TEST_CPUS)
270             || hibernation_testmode(HIBERNATION_TEST))
271                 goto Enable_cpus;
272
273         local_irq_disable();
274
275         error = syscore_suspend();
276         if (error) {
277                 printk(KERN_ERR "PM: Some system devices failed to power down, "
278                         "aborting hibernation\n");
279                 goto Enable_irqs;
280         }
281
282         if (hibernation_test(TEST_CORE) || pm_wakeup_pending())
283                 goto Power_up;
284
285         in_suspend = 1;
286         save_processor_state();
287         error = swsusp_arch_suspend();
288         if (error)
289                 printk(KERN_ERR "PM: Error %d creating hibernation image\n",
290                         error);
291         /* Restore control flow magically appears here */
292         restore_processor_state();
293         if (!in_suspend) {
294                 events_check_enabled = false;
295                 platform_leave(platform_mode);
296         }
297
298  Power_up:
299         syscore_resume();
300         /* NOTE:  dpm_resume_noirq() is just a resume() for devices
301          * that suspended with irqs off ... no overall powerup.
302          */
303
304  Enable_irqs:
305         local_irq_enable();
306
307  Enable_cpus:
308         enable_nonboot_cpus();
309
310  Platform_finish:
311         platform_finish(platform_mode);
312
313         dpm_resume_noirq(in_suspend ?
314                 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
315
316         return error;
317 }
318
319 /**
320  *      hibernation_snapshot - quiesce devices and create the hibernation
321  *      snapshot image.
322  *      @platform_mode - if set, use the platform driver, if available, to
323  *                       prepare the platform firmware for the power transition.
324  *
325  *      Must be called with pm_mutex held
326  */
327
328 int hibernation_snapshot(int platform_mode)
329 {
330         pm_message_t msg = PMSG_RECOVER;
331         int error;
332
333         error = platform_begin(platform_mode);
334         if (error)
335                 goto Close;
336
337         error = dpm_prepare(PMSG_FREEZE);
338         if (error)
339                 goto Complete_devices;
340
341         /* Preallocate image memory before shutting down devices. */
342         error = hibernate_preallocate_memory();
343         if (error)
344                 goto Complete_devices;
345
346         suspend_console();
347         pm_restrict_gfp_mask();
348         error = dpm_suspend(PMSG_FREEZE);
349         if (error)
350                 goto Recover_platform;
351
352         if (hibernation_test(TEST_DEVICES))
353                 goto Recover_platform;
354
355         error = create_image(platform_mode);
356         /*
357          * Control returns here (1) after the image has been created or the
358          * image creation has failed and (2) after a successful restore.
359          */
360
361  Resume_devices:
362         /* We may need to release the preallocated image pages here. */
363         if (error || !in_suspend)
364                 swsusp_free();
365
366         msg = in_suspend ? (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE;
367         dpm_resume(msg);
368
369         if (error || !in_suspend)
370                 pm_restore_gfp_mask();
371
372         resume_console();
373
374  Complete_devices:
375         dpm_complete(msg);
376
377  Close:
378         platform_end(platform_mode);
379         return error;
380
381  Recover_platform:
382         platform_recover(platform_mode);
383         goto Resume_devices;
384 }
385
386 /**
387  *      resume_target_kernel - prepare devices that need to be suspended with
388  *      interrupts off, restore the contents of highmem that have not been
389  *      restored yet from the image and run the low level code that will restore
390  *      the remaining contents of memory and switch to the just restored target
391  *      kernel.
392  */
393
394 static int resume_target_kernel(bool platform_mode)
395 {
396         int error;
397
398         error = dpm_suspend_noirq(PMSG_QUIESCE);
399         if (error) {
400                 printk(KERN_ERR "PM: Some devices failed to power down, "
401                         "aborting resume\n");
402                 return error;
403         }
404
405         error = platform_pre_restore(platform_mode);
406         if (error)
407                 goto Cleanup;
408
409         error = disable_nonboot_cpus();
410         if (error)
411                 goto Enable_cpus;
412
413         local_irq_disable();
414
415         error = syscore_suspend();
416         if (error)
417                 goto Enable_irqs;
418
419         /* We'll ignore saved state, but this gets preempt count (etc) right */
420         save_processor_state();
421         error = restore_highmem();
422         if (!error) {
423                 error = swsusp_arch_resume();
424                 /*
425                  * The code below is only ever reached in case of a failure.
426                  * Otherwise execution continues at place where
427                  * swsusp_arch_suspend() was called
428                  */
429                 BUG_ON(!error);
430                 /* This call to restore_highmem() undos the previous one */
431                 restore_highmem();
432         }
433         /*
434          * The only reason why swsusp_arch_resume() can fail is memory being
435          * very tight, so we have to free it as soon as we can to avoid
436          * subsequent failures
437          */
438         swsusp_free();
439         restore_processor_state();
440         touch_softlockup_watchdog();
441
442         syscore_resume();
443
444  Enable_irqs:
445         local_irq_enable();
446
447  Enable_cpus:
448         enable_nonboot_cpus();
449
450  Cleanup:
451         platform_restore_cleanup(platform_mode);
452
453         dpm_resume_noirq(PMSG_RECOVER);
454
455         return error;
456 }
457
458 /**
459  *      hibernation_restore - quiesce devices and restore the hibernation
460  *      snapshot image.  If successful, control returns in hibernation_snaphot()
461  *      @platform_mode - if set, use the platform driver, if available, to
462  *                       prepare the platform firmware for the transition.
463  *
464  *      Must be called with pm_mutex held
465  */
466
467 int hibernation_restore(int platform_mode)
468 {
469         int error;
470
471         pm_prepare_console();
472         suspend_console();
473         pm_restrict_gfp_mask();
474         error = dpm_suspend_start(PMSG_QUIESCE);
475         if (!error) {
476                 error = resume_target_kernel(platform_mode);
477                 dpm_resume_end(PMSG_RECOVER);
478         }
479         pm_restore_gfp_mask();
480         resume_console();
481         pm_restore_console();
482         return error;
483 }
484
485 /**
486  *      hibernation_platform_enter - enter the hibernation state using the
487  *      platform driver (if available)
488  */
489
490 int hibernation_platform_enter(void)
491 {
492         int error;
493
494         if (!hibernation_ops)
495                 return -ENOSYS;
496
497         /*
498          * We have cancelled the power transition by running
499          * hibernation_ops->finish() before saving the image, so we should let
500          * the firmware know that we're going to enter the sleep state after all
501          */
502         error = hibernation_ops->begin();
503         if (error)
504                 goto Close;
505
506         entering_platform_hibernation = true;
507         suspend_console();
508         error = dpm_suspend_start(PMSG_HIBERNATE);
509         if (error) {
510                 if (hibernation_ops->recover)
511                         hibernation_ops->recover();
512                 goto Resume_devices;
513         }
514
515         error = dpm_suspend_noirq(PMSG_HIBERNATE);
516         if (error)
517                 goto Resume_devices;
518
519         error = hibernation_ops->prepare();
520         if (error)
521                 goto Platform_finish;
522
523         error = disable_nonboot_cpus();
524         if (error)
525                 goto Platform_finish;
526
527         local_irq_disable();
528         syscore_suspend();
529         if (pm_wakeup_pending()) {
530                 error = -EAGAIN;
531                 goto Power_up;
532         }
533
534         hibernation_ops->enter();
535         /* We should never get here */
536         while (1);
537
538  Power_up:
539         syscore_resume();
540         local_irq_enable();
541         enable_nonboot_cpus();
542
543  Platform_finish:
544         hibernation_ops->finish();
545
546         dpm_resume_noirq(PMSG_RESTORE);
547
548  Resume_devices:
549         entering_platform_hibernation = false;
550         dpm_resume_end(PMSG_RESTORE);
551         resume_console();
552
553  Close:
554         hibernation_ops->end();
555
556         return error;
557 }
558
559 /**
560  *      power_down - Shut the machine down for hibernation.
561  *
562  *      Use the platform driver, if configured so; otherwise try
563  *      to power off or reboot.
564  */
565
566 static void power_down(void)
567 {
568         switch (hibernation_mode) {
569         case HIBERNATION_TEST:
570         case HIBERNATION_TESTPROC:
571                 break;
572         case HIBERNATION_REBOOT:
573                 kernel_restart(NULL);
574                 break;
575         case HIBERNATION_PLATFORM:
576                 hibernation_platform_enter();
577         case HIBERNATION_SHUTDOWN:
578                 kernel_power_off();
579                 break;
580         }
581         kernel_halt();
582         /*
583          * Valid image is on the disk, if we continue we risk serious data
584          * corruption after resume.
585          */
586         printk(KERN_CRIT "PM: Please power down manually\n");
587         while(1);
588 }
589
590 static int prepare_processes(void)
591 {
592         int error = 0;
593
594         if (freeze_processes()) {
595                 error = -EBUSY;
596                 thaw_processes();
597         }
598         return error;
599 }
600
601 /**
602  *      hibernate - The granpappy of the built-in hibernation management
603  */
604
605 int hibernate(void)
606 {
607         int error;
608
609         mutex_lock(&pm_mutex);
610         /* The snapshot device should not be opened while we're running */
611         if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
612                 error = -EBUSY;
613                 goto Unlock;
614         }
615
616         pm_prepare_console();
617         error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
618         if (error)
619                 goto Exit;
620
621         error = usermodehelper_disable();
622         if (error)
623                 goto Exit;
624
625         /* Allocate memory management structures */
626         error = create_basic_memory_bitmaps();
627         if (error)
628                 goto Exit;
629
630         printk(KERN_INFO "PM: Syncing filesystems ... ");
631         sys_sync();
632         printk("done.\n");
633
634         error = prepare_processes();
635         if (error)
636                 goto Finish;
637
638         if (hibernation_test(TEST_FREEZER))
639                 goto Thaw;
640
641         if (hibernation_testmode(HIBERNATION_TESTPROC))
642                 goto Thaw;
643
644         error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
645         if (error)
646                 goto Thaw;
647
648         if (in_suspend) {
649                 unsigned int flags = 0;
650
651                 if (hibernation_mode == HIBERNATION_PLATFORM)
652                         flags |= SF_PLATFORM_MODE;
653                 if (nocompress)
654                         flags |= SF_NOCOMPRESS_MODE;
655                 pr_debug("PM: writing image.\n");
656                 error = swsusp_write(flags);
657                 swsusp_free();
658                 if (!error)
659                         power_down();
660                 in_suspend = 0;
661                 pm_restore_gfp_mask();
662         } else {
663                 pr_debug("PM: Image restored successfully.\n");
664         }
665
666  Thaw:
667         thaw_processes();
668  Finish:
669         free_basic_memory_bitmaps();
670         usermodehelper_enable();
671  Exit:
672         pm_notifier_call_chain(PM_POST_HIBERNATION);
673         pm_restore_console();
674         atomic_inc(&snapshot_device_available);
675  Unlock:
676         mutex_unlock(&pm_mutex);
677         return error;
678 }
679
680
681 /**
682  *      software_resume - Resume from a saved image.
683  *
684  *      Called as a late_initcall (so all devices are discovered and
685  *      initialized), we call swsusp to see if we have a saved image or not.
686  *      If so, we quiesce devices, the restore the saved image. We will
687  *      return above (in hibernate() ) if everything goes well.
688  *      Otherwise, we fail gracefully and return to the normally
689  *      scheduled program.
690  *
691  */
692
693 static int software_resume(void)
694 {
695         int error;
696         unsigned int flags;
697
698         /*
699          * If the user said "noresume".. bail out early.
700          */
701         if (noresume)
702                 return 0;
703
704         /*
705          * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
706          * is configured into the kernel. Since the regular hibernate
707          * trigger path is via sysfs which takes a buffer mutex before
708          * calling hibernate functions (which take pm_mutex) this can
709          * cause lockdep to complain about a possible ABBA deadlock
710          * which cannot happen since we're in the boot code here and
711          * sysfs can't be invoked yet. Therefore, we use a subclass
712          * here to avoid lockdep complaining.
713          */
714         mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
715
716         if (swsusp_resume_device)
717                 goto Check_image;
718
719         if (!strlen(resume_file)) {
720                 error = -ENOENT;
721                 goto Unlock;
722         }
723
724         pr_debug("PM: Checking hibernation image partition %s\n", resume_file);
725
726         /* Check if the device is there */
727         swsusp_resume_device = name_to_dev_t(resume_file);
728         if (!swsusp_resume_device) {
729                 /*
730                  * Some device discovery might still be in progress; we need
731                  * to wait for this to finish.
732                  */
733                 wait_for_device_probe();
734                 /*
735                  * We can't depend on SCSI devices being available after loading
736                  * one of their modules until scsi_complete_async_scans() is
737                  * called and the resume device usually is a SCSI one.
738                  */
739                 scsi_complete_async_scans();
740
741                 swsusp_resume_device = name_to_dev_t(resume_file);
742                 if (!swsusp_resume_device) {
743                         error = -ENODEV;
744                         goto Unlock;
745                 }
746         }
747
748  Check_image:
749         pr_debug("PM: Hibernation image partition %d:%d present\n",
750                 MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
751
752         pr_debug("PM: Looking for hibernation image.\n");
753         error = swsusp_check();
754         if (error)
755                 goto Unlock;
756
757         /* The snapshot device should not be opened while we're running */
758         if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
759                 error = -EBUSY;
760                 swsusp_close(FMODE_READ);
761                 goto Unlock;
762         }
763
764         pm_prepare_console();
765         error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
766         if (error)
767                 goto close_finish;
768
769         error = usermodehelper_disable();
770         if (error)
771                 goto close_finish;
772
773         error = create_basic_memory_bitmaps();
774         if (error)
775                 goto close_finish;
776
777         pr_debug("PM: Preparing processes for restore.\n");
778         error = prepare_processes();
779         if (error) {
780                 swsusp_close(FMODE_READ);
781                 goto Done;
782         }
783
784         pr_debug("PM: Loading hibernation image.\n");
785
786         error = swsusp_read(&flags);
787         swsusp_close(FMODE_READ);
788         if (!error)
789                 hibernation_restore(flags & SF_PLATFORM_MODE);
790
791         printk(KERN_ERR "PM: Failed to load hibernation image, recovering.\n");
792         swsusp_free();
793         thaw_processes();
794  Done:
795         free_basic_memory_bitmaps();
796         usermodehelper_enable();
797  Finish:
798         pm_notifier_call_chain(PM_POST_RESTORE);
799         pm_restore_console();
800         atomic_inc(&snapshot_device_available);
801         /* For success case, the suspend path will release the lock */
802  Unlock:
803         mutex_unlock(&pm_mutex);
804         pr_debug("PM: Hibernation image not present or could not be loaded.\n");
805         return error;
806 close_finish:
807         swsusp_close(FMODE_READ);
808         goto Finish;
809 }
810
811 late_initcall(software_resume);
812
813
814 static const char * const hibernation_modes[] = {
815         [HIBERNATION_PLATFORM]  = "platform",
816         [HIBERNATION_SHUTDOWN]  = "shutdown",
817         [HIBERNATION_REBOOT]    = "reboot",
818         [HIBERNATION_TEST]      = "test",
819         [HIBERNATION_TESTPROC]  = "testproc",
820 };
821
822 /**
823  *      disk - Control hibernation mode
824  *
825  *      Suspend-to-disk can be handled in several ways. We have a few options
826  *      for putting the system to sleep - using the platform driver (e.g. ACPI
827  *      or other hibernation_ops), powering off the system or rebooting the
828  *      system (for testing) as well as the two test modes.
829  *
830  *      The system can support 'platform', and that is known a priori (and
831  *      encoded by the presence of hibernation_ops). However, the user may
832  *      choose 'shutdown' or 'reboot' as alternatives, as well as one fo the
833  *      test modes, 'test' or 'testproc'.
834  *
835  *      show() will display what the mode is currently set to.
836  *      store() will accept one of
837  *
838  *      'platform'
839  *      'shutdown'
840  *      'reboot'
841  *      'test'
842  *      'testproc'
843  *
844  *      It will only change to 'platform' if the system
845  *      supports it (as determined by having hibernation_ops).
846  */
847
848 static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
849                          char *buf)
850 {
851         int i;
852         char *start = buf;
853
854         for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
855                 if (!hibernation_modes[i])
856                         continue;
857                 switch (i) {
858                 case HIBERNATION_SHUTDOWN:
859                 case HIBERNATION_REBOOT:
860                 case HIBERNATION_TEST:
861                 case HIBERNATION_TESTPROC:
862                         break;
863                 case HIBERNATION_PLATFORM:
864                         if (hibernation_ops)
865                                 break;
866                         /* not a valid mode, continue with loop */
867                         continue;
868                 }
869                 if (i == hibernation_mode)
870                         buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
871                 else
872                         buf += sprintf(buf, "%s ", hibernation_modes[i]);
873         }
874         buf += sprintf(buf, "\n");
875         return buf-start;
876 }
877
878
879 static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
880                           const char *buf, size_t n)
881 {
882         int error = 0;
883         int i;
884         int len;
885         char *p;
886         int mode = HIBERNATION_INVALID;
887
888         p = memchr(buf, '\n', n);
889         len = p ? p - buf : n;
890
891         mutex_lock(&pm_mutex);
892         for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
893                 if (len == strlen(hibernation_modes[i])
894                     && !strncmp(buf, hibernation_modes[i], len)) {
895                         mode = i;
896                         break;
897                 }
898         }
899         if (mode != HIBERNATION_INVALID) {
900                 switch (mode) {
901                 case HIBERNATION_SHUTDOWN:
902                 case HIBERNATION_REBOOT:
903                 case HIBERNATION_TEST:
904                 case HIBERNATION_TESTPROC:
905                         hibernation_mode = mode;
906                         break;
907                 case HIBERNATION_PLATFORM:
908                         if (hibernation_ops)
909                                 hibernation_mode = mode;
910                         else
911                                 error = -EINVAL;
912                 }
913         } else
914                 error = -EINVAL;
915
916         if (!error)
917                 pr_debug("PM: Hibernation mode set to '%s'\n",
918                          hibernation_modes[mode]);
919         mutex_unlock(&pm_mutex);
920         return error ? error : n;
921 }
922
923 power_attr(disk);
924
925 static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
926                            char *buf)
927 {
928         return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
929                        MINOR(swsusp_resume_device));
930 }
931
932 static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
933                             const char *buf, size_t n)
934 {
935         unsigned int maj, min;
936         dev_t res;
937         int ret = -EINVAL;
938
939         if (sscanf(buf, "%u:%u", &maj, &min) != 2)
940                 goto out;
941
942         res = MKDEV(maj,min);
943         if (maj != MAJOR(res) || min != MINOR(res))
944                 goto out;
945
946         mutex_lock(&pm_mutex);
947         swsusp_resume_device = res;
948         mutex_unlock(&pm_mutex);
949         printk(KERN_INFO "PM: Starting manual resume from disk\n");
950         noresume = 0;
951         software_resume();
952         ret = n;
953  out:
954         return ret;
955 }
956
957 power_attr(resume);
958
959 static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
960                                char *buf)
961 {
962         return sprintf(buf, "%lu\n", image_size);
963 }
964
965 static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
966                                 const char *buf, size_t n)
967 {
968         unsigned long size;
969
970         if (sscanf(buf, "%lu", &size) == 1) {
971                 image_size = size;
972                 return n;
973         }
974
975         return -EINVAL;
976 }
977
978 power_attr(image_size);
979
980 static ssize_t reserved_size_show(struct kobject *kobj,
981                                   struct kobj_attribute *attr, char *buf)
982 {
983         return sprintf(buf, "%lu\n", reserved_size);
984 }
985
986 static ssize_t reserved_size_store(struct kobject *kobj,
987                                    struct kobj_attribute *attr,
988                                    const char *buf, size_t n)
989 {
990         unsigned long size;
991
992         if (sscanf(buf, "%lu", &size) == 1) {
993                 reserved_size = size;
994                 return n;
995         }
996
997         return -EINVAL;
998 }
999
1000 power_attr(reserved_size);
1001
1002 static struct attribute * g[] = {
1003         &disk_attr.attr,
1004         &resume_attr.attr,
1005         &image_size_attr.attr,
1006         &reserved_size_attr.attr,
1007         NULL,
1008 };
1009
1010
1011 static struct attribute_group attr_group = {
1012         .attrs = g,
1013 };
1014
1015
1016 static int __init pm_disk_init(void)
1017 {
1018         return sysfs_create_group(power_kobj, &attr_group);
1019 }
1020
1021 core_initcall(pm_disk_init);
1022
1023
1024 static int __init resume_setup(char *str)
1025 {
1026         if (noresume)
1027                 return 1;
1028
1029         strncpy( resume_file, str, 255 );
1030         return 1;
1031 }
1032
1033 static int __init resume_offset_setup(char *str)
1034 {
1035         unsigned long long offset;
1036
1037         if (noresume)
1038                 return 1;
1039
1040         if (sscanf(str, "%llu", &offset) == 1)
1041                 swsusp_resume_block = offset;
1042
1043         return 1;
1044 }
1045
1046 static int __init hibernate_setup(char *str)
1047 {
1048         if (!strncmp(str, "noresume", 8))
1049                 noresume = 1;
1050         else if (!strncmp(str, "nocompress", 10))
1051                 nocompress = 1;
1052         return 1;
1053 }
1054
1055 static int __init noresume_setup(char *str)
1056 {
1057         noresume = 1;
1058         return 1;
1059 }
1060
1061 __setup("noresume", noresume_setup);
1062 __setup("resume_offset=", resume_offset_setup);
1063 __setup("resume=", resume_setup);
1064 __setup("hibernate=", hibernate_setup);