Commit | Line | Data |
---|---|---|
fce2b111 | 1 | /* |
d146df18 | 2 | * nvs.c - Routines for saving and restoring ACPI NVS memory region |
fce2b111 | 3 | * |
d146df18 | 4 | * Copyright (C) 2008-2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc. |
fce2b111 CH |
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> | |
5a0e3ad6 | 13 | #include <linux/slab.h> |
d146df18 | 14 | #include <linux/acpi.h> |
2d6d9fd3 | 15 | #include <linux/acpi_io.h> |
ca9b600b | 16 | #include <acpi/acpiosxf.h> |
fce2b111 CH |
17 | |
18 | /* | |
19 | * Platforms, like ACPI, may want us to save some memory used by them during | |
dd4c4f17 | 20 | * suspend and to restore the contents of this memory during the subsequent |
fce2b111 CH |
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; | |
bb45e394 | 29 | bool unmap; |
fce2b111 CH |
30 | struct list_head node; |
31 | }; | |
32 | ||
33 | static LIST_HEAD(nvs_list); | |
34 | ||
35 | /** | |
dd4c4f17 | 36 | * suspend_nvs_register - register platform NVS memory region to save |
fce2b111 CH |
37 | * @start - physical address of the region |
38 | * @size - size of the region | |
39 | * | |
40 | * The NVS region need not be page-aligned (both ends) and we arrange | |
41 | * things so that the data from page-aligned addresses in this region will | |
42 | * be copied into separate RAM pages. | |
43 | */ | |
dd4c4f17 | 44 | int suspend_nvs_register(unsigned long start, unsigned long size) |
fce2b111 CH |
45 | { |
46 | struct nvs_page *entry, *next; | |
47 | ||
bb45e394 RW |
48 | pr_info("PM: Registering ACPI NVS region at %lx (%ld bytes)\n", |
49 | start, size); | |
50 | ||
fce2b111 CH |
51 | while (size > 0) { |
52 | unsigned int nr_bytes; | |
53 | ||
54 | entry = kzalloc(sizeof(struct nvs_page), GFP_KERNEL); | |
55 | if (!entry) | |
56 | goto Error; | |
57 | ||
58 | list_add_tail(&entry->node, &nvs_list); | |
59 | entry->phys_start = start; | |
60 | nr_bytes = PAGE_SIZE - (start & ~PAGE_MASK); | |
61 | entry->size = (size < nr_bytes) ? size : nr_bytes; | |
62 | ||
63 | start += entry->size; | |
64 | size -= entry->size; | |
65 | } | |
66 | return 0; | |
67 | ||
68 | Error: | |
69 | list_for_each_entry_safe(entry, next, &nvs_list, node) { | |
70 | list_del(&entry->node); | |
71 | kfree(entry); | |
72 | } | |
73 | return -ENOMEM; | |
74 | } | |
75 | ||
76 | /** | |
dd4c4f17 | 77 | * suspend_nvs_free - free data pages allocated for saving NVS regions |
fce2b111 | 78 | */ |
dd4c4f17 | 79 | void suspend_nvs_free(void) |
fce2b111 CH |
80 | { |
81 | struct nvs_page *entry; | |
82 | ||
83 | list_for_each_entry(entry, &nvs_list, node) | |
84 | if (entry->data) { | |
85 | free_page((unsigned long)entry->data); | |
86 | entry->data = NULL; | |
87 | if (entry->kaddr) { | |
bb45e394 RW |
88 | if (entry->unmap) { |
89 | iounmap(entry->kaddr); | |
90 | entry->unmap = false; | |
91 | } else { | |
92 | acpi_os_unmap_memory(entry->kaddr, | |
93 | entry->size); | |
94 | } | |
fce2b111 CH |
95 | entry->kaddr = NULL; |
96 | } | |
97 | } | |
98 | } | |
99 | ||
100 | /** | |
dd4c4f17 | 101 | * suspend_nvs_alloc - allocate memory necessary for saving NVS regions |
fce2b111 | 102 | */ |
dd4c4f17 | 103 | int suspend_nvs_alloc(void) |
fce2b111 CH |
104 | { |
105 | struct nvs_page *entry; | |
106 | ||
107 | list_for_each_entry(entry, &nvs_list, node) { | |
108 | entry->data = (void *)__get_free_page(GFP_KERNEL); | |
109 | if (!entry->data) { | |
dd4c4f17 | 110 | suspend_nvs_free(); |
fce2b111 CH |
111 | return -ENOMEM; |
112 | } | |
113 | } | |
114 | return 0; | |
115 | } | |
116 | ||
117 | /** | |
dd4c4f17 | 118 | * suspend_nvs_save - save NVS memory regions |
fce2b111 | 119 | */ |
26fcaf60 | 120 | int suspend_nvs_save(void) |
fce2b111 CH |
121 | { |
122 | struct nvs_page *entry; | |
123 | ||
124 | printk(KERN_INFO "PM: Saving platform NVS memory\n"); | |
125 | ||
126 | list_for_each_entry(entry, &nvs_list, node) | |
127 | if (entry->data) { | |
bb45e394 RW |
128 | unsigned long phys = entry->phys_start; |
129 | unsigned int size = entry->size; | |
130 | ||
131 | entry->kaddr = acpi_os_get_iomem(phys, size); | |
132 | if (!entry->kaddr) { | |
133 | entry->kaddr = acpi_os_ioremap(phys, size); | |
134 | entry->unmap = !!entry->kaddr; | |
135 | } | |
26fcaf60 JS |
136 | if (!entry->kaddr) { |
137 | suspend_nvs_free(); | |
138 | return -ENOMEM; | |
139 | } | |
fce2b111 CH |
140 | memcpy(entry->data, entry->kaddr, entry->size); |
141 | } | |
26fcaf60 JS |
142 | |
143 | return 0; | |
fce2b111 CH |
144 | } |
145 | ||
146 | /** | |
dd4c4f17 | 147 | * suspend_nvs_restore - restore NVS memory regions |
fce2b111 CH |
148 | * |
149 | * This function is going to be called with interrupts disabled, so it | |
150 | * cannot iounmap the virtual addresses used to access the NVS region. | |
151 | */ | |
dd4c4f17 | 152 | void suspend_nvs_restore(void) |
fce2b111 CH |
153 | { |
154 | struct nvs_page *entry; | |
155 | ||
156 | printk(KERN_INFO "PM: Restoring platform NVS memory\n"); | |
157 | ||
158 | list_for_each_entry(entry, &nvs_list, node) | |
159 | if (entry->data) | |
160 | memcpy(entry->kaddr, entry->data, entry->size); | |
161 | } |