Commit | Line | Data |
---|---|---|
549c7e33 BD |
1 | /* linux/arch/arm/plat-s3c/pm-check.c |
2 | * originally in linux/arch/arm/plat-s3c24xx/pm.c | |
3 | * | |
4 | * Copyright (c) 2004,2006,2008 Simtec Electronics | |
5 | * http://armlinux.simtec.co.uk | |
6 | * Ben Dooks <ben@simtec.co.uk> | |
7 | * | |
8 | * S3C Power Mangament - suspend/resume memory corruptiuon check. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | */ | |
14 | ||
15 | #include <linux/kernel.h> | |
16 | #include <linux/suspend.h> | |
17 | #include <linux/init.h> | |
18 | #include <linux/crc32.h> | |
19 | #include <linux/ioport.h> | |
20 | ||
21 | #include <plat/pm.h> | |
22 | ||
23 | #if CONFIG_S3C2410_PM_CHECK_CHUNKSIZE < 1 | |
24 | #error CONFIG_S3C2410_PM_CHECK_CHUNKSIZE must be a positive non-zero value | |
25 | #endif | |
26 | ||
27 | /* suspend checking code... | |
28 | * | |
29 | * this next area does a set of crc checks over all the installed | |
30 | * memory, so the system can verify if the resume was ok. | |
31 | * | |
32 | * CONFIG_S3C2410_PM_CHECK_CHUNKSIZE defines the block-size for the CRC, | |
33 | * increasing it will mean that the area corrupted will be less easy to spot, | |
34 | * and reducing the size will cause the CRC save area to grow | |
35 | */ | |
36 | ||
37 | #define CHECK_CHUNKSIZE (CONFIG_S3C2410_PM_CHECK_CHUNKSIZE * 1024) | |
38 | ||
39 | static u32 crc_size; /* size needed for the crc block */ | |
40 | static u32 *crcs; /* allocated over suspend/resume */ | |
41 | ||
42 | typedef u32 *(run_fn_t)(struct resource *ptr, u32 *arg); | |
43 | ||
44 | /* s3c_pm_run_res | |
45 | * | |
46 | * go through the given resource list, and look for system ram | |
47 | */ | |
48 | ||
49 | static void s3c_pm_run_res(struct resource *ptr, run_fn_t fn, u32 *arg) | |
50 | { | |
51 | while (ptr != NULL) { | |
52 | if (ptr->child != NULL) | |
53 | s3c_pm_run_res(ptr->child, fn, arg); | |
54 | ||
55 | if ((ptr->flags & IORESOURCE_MEM) && | |
56 | strcmp(ptr->name, "System RAM") == 0) { | |
57 | S3C_PMDBG("Found system RAM at %08lx..%08lx\n", | |
840eeeb8 BD |
58 | (unsigned long)ptr->start, |
59 | (unsigned long)ptr->end); | |
549c7e33 BD |
60 | arg = (fn)(ptr, arg); |
61 | } | |
62 | ||
63 | ptr = ptr->sibling; | |
64 | } | |
65 | } | |
66 | ||
67 | static void s3c_pm_run_sysram(run_fn_t fn, u32 *arg) | |
68 | { | |
69 | s3c_pm_run_res(&iomem_resource, fn, arg); | |
70 | } | |
71 | ||
72 | static u32 *s3c_pm_countram(struct resource *res, u32 *val) | |
73 | { | |
74 | u32 size = (u32)(res->end - res->start)+1; | |
75 | ||
76 | size += CHECK_CHUNKSIZE-1; | |
77 | size /= CHECK_CHUNKSIZE; | |
78 | ||
840eeeb8 BD |
79 | S3C_PMDBG("Area %08lx..%08lx, %d blocks\n", |
80 | (unsigned long)res->start, (unsigned long)res->end, size); | |
549c7e33 BD |
81 | |
82 | *val += size * sizeof(u32); | |
83 | return val; | |
84 | } | |
85 | ||
86 | /* s3c_pm_prepare_check | |
87 | * | |
88 | * prepare the necessary information for creating the CRCs. This | |
89 | * must be done before the final save, as it will require memory | |
90 | * allocating, and thus touching bits of the kernel we do not | |
91 | * know about. | |
92 | */ | |
93 | ||
94 | void s3c_pm_check_prepare(void) | |
95 | { | |
96 | crc_size = 0; | |
97 | ||
98 | s3c_pm_run_sysram(s3c_pm_countram, &crc_size); | |
99 | ||
100 | S3C_PMDBG("s3c_pm_prepare_check: %u checks needed\n", crc_size); | |
101 | ||
102 | crcs = kmalloc(crc_size+4, GFP_KERNEL); | |
103 | if (crcs == NULL) | |
104 | printk(KERN_ERR "Cannot allocated CRC save area\n"); | |
105 | } | |
106 | ||
107 | static u32 *s3c_pm_makecheck(struct resource *res, u32 *val) | |
108 | { | |
109 | unsigned long addr, left; | |
110 | ||
111 | for (addr = res->start; addr < res->end; | |
112 | addr += CHECK_CHUNKSIZE) { | |
113 | left = res->end - addr; | |
114 | ||
115 | if (left > CHECK_CHUNKSIZE) | |
116 | left = CHECK_CHUNKSIZE; | |
117 | ||
118 | *val = crc32_le(~0, phys_to_virt(addr), left); | |
119 | val++; | |
120 | } | |
121 | ||
122 | return val; | |
123 | } | |
124 | ||
125 | /* s3c_pm_check_store | |
126 | * | |
127 | * compute the CRC values for the memory blocks before the final | |
128 | * sleep. | |
129 | */ | |
130 | ||
131 | void s3c_pm_check_store(void) | |
132 | { | |
133 | if (crcs != NULL) | |
134 | s3c_pm_run_sysram(s3c_pm_makecheck, crcs); | |
135 | } | |
136 | ||
137 | /* in_region | |
138 | * | |
139 | * return TRUE if the area defined by ptr..ptr+size contains the | |
140 | * what..what+whatsz | |
141 | */ | |
142 | ||
143 | static inline int in_region(void *ptr, int size, void *what, size_t whatsz) | |
144 | { | |
145 | if ((what+whatsz) < ptr) | |
146 | return 0; | |
147 | ||
148 | if (what > (ptr+size)) | |
149 | return 0; | |
150 | ||
151 | return 1; | |
152 | } | |
153 | ||
154 | /** | |
663a8304 | 155 | * s3c_pm_runcheck() - helper to check a resource on restore. |
549c7e33 BD |
156 | * @res: The resource to check |
157 | * @vak: Pointer to list of CRC32 values to check. | |
158 | * | |
159 | * Called from the s3c_pm_check_restore() via s3c_pm_run_sysram(), this | |
160 | * function runs the given memory resource checking it against the stored | |
161 | * CRC to ensure that memory is restored. The function tries to skip as | |
162 | * many of the areas used during the suspend process. | |
163 | */ | |
164 | static u32 *s3c_pm_runcheck(struct resource *res, u32 *val) | |
165 | { | |
166 | void *save_at = phys_to_virt(s3c_sleep_save_phys); | |
167 | unsigned long addr; | |
168 | unsigned long left; | |
663a8304 | 169 | void *stkpage; |
549c7e33 BD |
170 | void *ptr; |
171 | u32 calc; | |
172 | ||
663a8304 BD |
173 | stkpage = (void *)((u32)&calc & ~PAGE_MASK); |
174 | ||
549c7e33 BD |
175 | for (addr = res->start; addr < res->end; |
176 | addr += CHECK_CHUNKSIZE) { | |
177 | left = res->end - addr; | |
178 | ||
179 | if (left > CHECK_CHUNKSIZE) | |
180 | left = CHECK_CHUNKSIZE; | |
181 | ||
182 | ptr = phys_to_virt(addr); | |
183 | ||
663a8304 BD |
184 | if (in_region(ptr, left, stkpage, 4096)) { |
185 | S3C_PMDBG("skipping %08lx, has stack in\n", addr); | |
186 | goto skip_check; | |
187 | } | |
188 | ||
549c7e33 BD |
189 | if (in_region(ptr, left, crcs, crc_size)) { |
190 | S3C_PMDBG("skipping %08lx, has crc block in\n", addr); | |
191 | goto skip_check; | |
192 | } | |
193 | ||
194 | if (in_region(ptr, left, save_at, 32*4 )) { | |
195 | S3C_PMDBG("skipping %08lx, has save block in\n", addr); | |
196 | goto skip_check; | |
197 | } | |
198 | ||
199 | /* calculate and check the checksum */ | |
200 | ||
201 | calc = crc32_le(~0, ptr, left); | |
202 | if (calc != *val) { | |
203 | printk(KERN_ERR "Restore CRC error at " | |
204 | "%08lx (%08x vs %08x)\n", addr, calc, *val); | |
205 | ||
206 | S3C_PMDBG("Restore CRC error at %08lx (%08x vs %08x)\n", | |
207 | addr, calc, *val); | |
208 | } | |
209 | ||
210 | skip_check: | |
211 | val++; | |
212 | } | |
213 | ||
214 | return val; | |
215 | } | |
216 | ||
217 | /** | |
218 | * s3c_pm_check_restore() - memory check called on resume | |
219 | * | |
220 | * check the CRCs after the restore event and free the memory used | |
221 | * to hold them | |
222 | */ | |
223 | void s3c_pm_check_restore(void) | |
224 | { | |
aa8aba69 | 225 | if (crcs != NULL) |
549c7e33 | 226 | s3c_pm_run_sysram(s3c_pm_runcheck, crcs); |
549c7e33 | 227 | } |
aa8aba69 BD |
228 | |
229 | /** | |
230 | * s3c_pm_check_cleanup() - free memory resources | |
231 | * | |
232 | * Free the resources that where allocated by the suspend | |
233 | * memory check code. We do this separately from the | |
234 | * s3c_pm_check_restore() function as we cannot call any | |
235 | * functions that might sleep during that resume. | |
236 | */ | |
237 | void s3c_pm_check_cleanup(void) | |
238 | { | |
239 | kfree(crcs); | |
240 | crcs = NULL; | |
241 | } | |
242 |