db5e98d2eb7311e330d9b6ec397d6e156a7075e0
[linux-2.6.git] / arch / i386 / power / suspend.c
1 /*
2  * Suspend support specific for i386 - temporary page tables
3  *
4  * Distribute under GPLv2
5  *
6  * Copyright (c) 2006 Rafael J. Wysocki <rjw@sisk.pl>
7  */
8
9 #include <linux/suspend.h>
10 #include <linux/bootmem.h>
11
12 #include <asm/system.h>
13 #include <asm/page.h>
14 #include <asm/pgtable.h>
15
16 /* Defined in arch/i386/power/swsusp.S */
17 extern int restore_image(void);
18
19 /* Pointer to the temporary resume page tables */
20 pgd_t *resume_pg_dir;
21
22 /* The following three functions are based on the analogous code in
23  * arch/i386/mm/init.c
24  */
25
26 /*
27  * Create a middle page table on a resume-safe page and put a pointer to it in
28  * the given global directory entry.  This only returns the gd entry
29  * in non-PAE compilation mode, since the middle layer is folded.
30  */
31 static pmd_t *resume_one_md_table_init(pgd_t *pgd)
32 {
33         pud_t *pud;
34         pmd_t *pmd_table;
35
36 #ifdef CONFIG_X86_PAE
37         pmd_table = (pmd_t *)get_safe_page(GFP_ATOMIC);
38         if (!pmd_table)
39                 return NULL;
40
41         set_pgd(pgd, __pgd(__pa(pmd_table) | _PAGE_PRESENT));
42         pud = pud_offset(pgd, 0);
43
44         BUG_ON(pmd_table != pmd_offset(pud, 0));
45 #else
46         pud = pud_offset(pgd, 0);
47         pmd_table = pmd_offset(pud, 0);
48 #endif
49
50         return pmd_table;
51 }
52
53 /*
54  * Create a page table on a resume-safe page and place a pointer to it in
55  * a middle page directory entry.
56  */
57 static pte_t *resume_one_page_table_init(pmd_t *pmd)
58 {
59         if (pmd_none(*pmd)) {
60                 pte_t *page_table = (pte_t *)get_safe_page(GFP_ATOMIC);
61                 if (!page_table)
62                         return NULL;
63
64                 set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));
65
66                 BUG_ON(page_table != pte_offset_kernel(pmd, 0));
67
68                 return page_table;
69         }
70
71         return pte_offset_kernel(pmd, 0);
72 }
73
74 /*
75  * This maps the physical memory to kernel virtual address space, a total
76  * of max_low_pfn pages, by creating page tables starting from address
77  * PAGE_OFFSET.  The page tables are allocated out of resume-safe pages.
78  */
79 static int resume_physical_mapping_init(pgd_t *pgd_base)
80 {
81         unsigned long pfn;
82         pgd_t *pgd;
83         pmd_t *pmd;
84         pte_t *pte;
85         int pgd_idx, pmd_idx;
86
87         pgd_idx = pgd_index(PAGE_OFFSET);
88         pgd = pgd_base + pgd_idx;
89         pfn = 0;
90
91         for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
92                 pmd = resume_one_md_table_init(pgd);
93                 if (!pmd)
94                         return -ENOMEM;
95
96                 if (pfn >= max_low_pfn)
97                         continue;
98
99                 for (pmd_idx = 0; pmd_idx < PTRS_PER_PMD; pmd++, pmd_idx++) {
100                         if (pfn >= max_low_pfn)
101                                 break;
102
103                         /* Map with big pages if possible, otherwise create
104                          * normal page tables.
105                          * NOTE: We can mark everything as executable here
106                          */
107                         if (cpu_has_pse) {
108                                 set_pmd(pmd, pfn_pmd(pfn, PAGE_KERNEL_LARGE_EXEC));
109                                 pfn += PTRS_PER_PTE;
110                         } else {
111                                 pte_t *max_pte;
112
113                                 pte = resume_one_page_table_init(pmd);
114                                 if (!pte)
115                                         return -ENOMEM;
116
117                                 max_pte = pte + PTRS_PER_PTE;
118                                 for (; pte < max_pte; pte++, pfn++) {
119                                         if (pfn >= max_low_pfn)
120                                                 break;
121
122                                         set_pte(pte, pfn_pte(pfn, PAGE_KERNEL_EXEC));
123                                 }
124                         }
125                 }
126         }
127         return 0;
128 }
129
130 static inline void resume_init_first_level_page_table(pgd_t *pg_dir)
131 {
132 #ifdef CONFIG_X86_PAE
133         int i;
134
135         /* Init entries of the first-level page table to the zero page */
136         for (i = 0; i < PTRS_PER_PGD; i++)
137                 set_pgd(pg_dir + i,
138                         __pgd(__pa(empty_zero_page) | _PAGE_PRESENT));
139 #endif
140 }
141
142 int swsusp_arch_resume(void)
143 {
144         int error;
145
146         resume_pg_dir = (pgd_t *)get_safe_page(GFP_ATOMIC);
147         if (!resume_pg_dir)
148                 return -ENOMEM;
149
150         resume_init_first_level_page_table(resume_pg_dir);
151         error = resume_physical_mapping_init(resume_pg_dir);
152         if (error)
153                 return error;
154
155         /* We have got enough memory and from now on we cannot recover */
156         restore_image();
157         return 0;
158 }