ACPI / Button: Avoid disabling wakeup unnecessarily on remove
[linux-2.6.git] / drivers / acpi / nvs.c
1 /*
2  * nvs.c - Routines for saving and restoring ACPI NVS memory region
3  *
4  * Copyright (C) 2008-2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
5  *
6  * This file is released under the GPLv2.
7  */
8
9 #include <linux/io.h>
10 #include <linux/kernel.h>
11 #include <linux/list.h>
12 #include <linux/mm.h>
13 #include <linux/slab.h>
14 #include <linux/acpi.h>
15 #include <linux/acpi_io.h>
16 #include <acpi/acpiosxf.h>
17
18 /*
19  * Platforms, like ACPI, may want us to save some memory used by them during
20  * suspend and to restore the contents of this memory during the subsequent
21  * resume.  The code below implements a mechanism allowing us to do that.
22  */
23
24 struct nvs_page {
25         unsigned long phys_start;
26         unsigned int size;
27         void *kaddr;
28         void *data;
29         struct list_head node;
30 };
31
32 static LIST_HEAD(nvs_list);
33
34 /**
35  *      suspend_nvs_register - register platform NVS memory region to save
36  *      @start - physical address of the region
37  *      @size - size of the region
38  *
39  *      The NVS region need not be page-aligned (both ends) and we arrange
40  *      things so that the data from page-aligned addresses in this region will
41  *      be copied into separate RAM pages.
42  */
43 int suspend_nvs_register(unsigned long start, unsigned long size)
44 {
45         struct nvs_page *entry, *next;
46
47         while (size > 0) {
48                 unsigned int nr_bytes;
49
50                 entry = kzalloc(sizeof(struct nvs_page), GFP_KERNEL);
51                 if (!entry)
52                         goto Error;
53
54                 list_add_tail(&entry->node, &nvs_list);
55                 entry->phys_start = start;
56                 nr_bytes = PAGE_SIZE - (start & ~PAGE_MASK);
57                 entry->size = (size < nr_bytes) ? size : nr_bytes;
58
59                 start += entry->size;
60                 size -= entry->size;
61         }
62         return 0;
63
64  Error:
65         list_for_each_entry_safe(entry, next, &nvs_list, node) {
66                 list_del(&entry->node);
67                 kfree(entry);
68         }
69         return -ENOMEM;
70 }
71
72 /**
73  *      suspend_nvs_free - free data pages allocated for saving NVS regions
74  */
75 void suspend_nvs_free(void)
76 {
77         struct nvs_page *entry;
78
79         list_for_each_entry(entry, &nvs_list, node)
80                 if (entry->data) {
81                         free_page((unsigned long)entry->data);
82                         entry->data = NULL;
83                         if (entry->kaddr) {
84                                 iounmap(entry->kaddr);
85                                 entry->kaddr = NULL;
86                         }
87                 }
88 }
89
90 /**
91  *      suspend_nvs_alloc - allocate memory necessary for saving NVS regions
92  */
93 int suspend_nvs_alloc(void)
94 {
95         struct nvs_page *entry;
96
97         list_for_each_entry(entry, &nvs_list, node) {
98                 entry->data = (void *)__get_free_page(GFP_KERNEL);
99                 if (!entry->data) {
100                         suspend_nvs_free();
101                         return -ENOMEM;
102                 }
103         }
104         return 0;
105 }
106
107 /**
108  *      suspend_nvs_save - save NVS memory regions
109  */
110 int suspend_nvs_save(void)
111 {
112         struct nvs_page *entry;
113
114         printk(KERN_INFO "PM: Saving platform NVS memory\n");
115
116         list_for_each_entry(entry, &nvs_list, node)
117                 if (entry->data) {
118                         entry->kaddr = acpi_os_ioremap(entry->phys_start,
119                                                     entry->size);
120                         if (!entry->kaddr) {
121                                 suspend_nvs_free();
122                                 return -ENOMEM;
123                         }
124                         memcpy(entry->data, entry->kaddr, entry->size);
125                 }
126
127         return 0;
128 }
129
130 /**
131  *      suspend_nvs_restore - restore NVS memory regions
132  *
133  *      This function is going to be called with interrupts disabled, so it
134  *      cannot iounmap the virtual addresses used to access the NVS region.
135  */
136 void suspend_nvs_restore(void)
137 {
138         struct nvs_page *entry;
139
140         printk(KERN_INFO "PM: Restoring platform NVS memory\n");
141
142         list_for_each_entry(entry, &nvs_list, node)
143                 if (entry->data)
144                         memcpy(entry->kaddr, entry->data, entry->size);
145 }