1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Provide common bits of early_ioremap() support for architectures needing |
4 | * temporary mappings during boot before ioremap() is available. |
5 | * |
6 | * This is mostly a direct copy of the x86 early_ioremap implementation. |
7 | * |
8 | * (C) Copyright 1995 1996, 2014 Linus Torvalds |
9 | * |
10 | */ |
11 | #include <linux/kernel.h> |
12 | #include <linux/init.h> |
13 | #include <linux/io.h> |
14 | #include <linux/module.h> |
15 | #include <linux/slab.h> |
16 | #include <linux/mm.h> |
17 | #include <linux/vmalloc.h> |
18 | #include <asm/fixmap.h> |
19 | #include <asm/early_ioremap.h> |
20 | #include "internal.h" |
21 | |
22 | #ifdef CONFIG_MMU |
23 | static int early_ioremap_debug __initdata; |
24 | |
25 | static int __init early_ioremap_debug_setup(char *str) |
26 | { |
27 | early_ioremap_debug = 1; |
28 | |
29 | return 0; |
30 | } |
31 | early_param("early_ioremap_debug" , early_ioremap_debug_setup); |
32 | |
33 | static int after_paging_init __initdata; |
34 | |
35 | pgprot_t __init __weak early_memremap_pgprot_adjust(resource_size_t phys_addr, |
36 | unsigned long size, |
37 | pgprot_t prot) |
38 | { |
39 | return prot; |
40 | } |
41 | |
42 | void __init early_ioremap_reset(void) |
43 | { |
44 | after_paging_init = 1; |
45 | } |
46 | |
47 | /* |
48 | * Generally, ioremap() is available after paging_init() has been called. |
49 | * Architectures wanting to allow early_ioremap after paging_init() can |
50 | * define __late_set_fixmap and __late_clear_fixmap to do the right thing. |
51 | */ |
52 | #ifndef __late_set_fixmap |
53 | static inline void __init __late_set_fixmap(enum fixed_addresses idx, |
54 | phys_addr_t phys, pgprot_t prot) |
55 | { |
56 | BUG(); |
57 | } |
58 | #endif |
59 | |
60 | #ifndef __late_clear_fixmap |
61 | static inline void __init __late_clear_fixmap(enum fixed_addresses idx) |
62 | { |
63 | BUG(); |
64 | } |
65 | #endif |
66 | |
67 | static void __iomem *prev_map[FIX_BTMAPS_SLOTS] __initdata; |
68 | static unsigned long prev_size[FIX_BTMAPS_SLOTS] __initdata; |
69 | static unsigned long slot_virt[FIX_BTMAPS_SLOTS] __initdata; |
70 | |
71 | void __init early_ioremap_setup(void) |
72 | { |
73 | int i; |
74 | |
75 | for (i = 0; i < FIX_BTMAPS_SLOTS; i++) { |
76 | WARN_ON_ONCE(prev_map[i]); |
77 | slot_virt[i] = __fix_to_virt(FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*i); |
78 | } |
79 | } |
80 | |
81 | static int __init check_early_ioremap_leak(void) |
82 | { |
83 | int count = 0; |
84 | int i; |
85 | |
86 | for (i = 0; i < FIX_BTMAPS_SLOTS; i++) |
87 | if (prev_map[i]) |
88 | count++; |
89 | |
90 | if (WARN(count, KERN_WARNING |
91 | "Debug warning: early ioremap leak of %d areas detected.\n" |
92 | "please boot with early_ioremap_debug and report the dmesg.\n" , |
93 | count)) |
94 | return 1; |
95 | return 0; |
96 | } |
97 | late_initcall(check_early_ioremap_leak); |
98 | |
99 | static void __init __iomem * |
100 | __early_ioremap(resource_size_t phys_addr, unsigned long size, pgprot_t prot) |
101 | { |
102 | unsigned long offset; |
103 | resource_size_t last_addr; |
104 | unsigned int nrpages; |
105 | enum fixed_addresses idx; |
106 | int i, slot; |
107 | |
108 | WARN_ON(system_state >= SYSTEM_RUNNING); |
109 | |
110 | slot = -1; |
111 | for (i = 0; i < FIX_BTMAPS_SLOTS; i++) { |
112 | if (!prev_map[i]) { |
113 | slot = i; |
114 | break; |
115 | } |
116 | } |
117 | |
118 | if (WARN(slot < 0, "%s(%pa, %08lx) not found slot\n" , |
119 | __func__, &phys_addr, size)) |
120 | return NULL; |
121 | |
122 | /* Don't allow wraparound or zero size */ |
123 | last_addr = phys_addr + size - 1; |
124 | if (WARN_ON(!size || last_addr < phys_addr)) |
125 | return NULL; |
126 | |
127 | prev_size[slot] = size; |
128 | /* |
129 | * Mappings have to be page-aligned |
130 | */ |
131 | offset = offset_in_page(phys_addr); |
132 | phys_addr &= PAGE_MASK; |
133 | size = PAGE_ALIGN(last_addr + 1) - phys_addr; |
134 | |
135 | /* |
136 | * Mappings have to fit in the FIX_BTMAP area. |
137 | */ |
138 | nrpages = size >> PAGE_SHIFT; |
139 | if (WARN_ON(nrpages > NR_FIX_BTMAPS)) |
140 | return NULL; |
141 | |
142 | /* |
143 | * Ok, go for it.. |
144 | */ |
145 | idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*slot; |
146 | while (nrpages > 0) { |
147 | if (after_paging_init) |
148 | __late_set_fixmap(idx, phys_addr, prot); |
149 | else |
150 | __early_set_fixmap(idx, phys: phys_addr, flags: prot); |
151 | phys_addr += PAGE_SIZE; |
152 | --idx; |
153 | --nrpages; |
154 | } |
155 | WARN(early_ioremap_debug, "%s(%pa, %08lx) [%d] => %08lx + %08lx\n" , |
156 | __func__, &phys_addr, size, slot, offset, slot_virt[slot]); |
157 | |
158 | prev_map[slot] = (void __iomem *)(offset + slot_virt[slot]); |
159 | return prev_map[slot]; |
160 | } |
161 | |
162 | void __init early_iounmap(void __iomem *addr, unsigned long size) |
163 | { |
164 | unsigned long virt_addr; |
165 | unsigned long offset; |
166 | unsigned int nrpages; |
167 | enum fixed_addresses idx; |
168 | int i, slot; |
169 | |
170 | slot = -1; |
171 | for (i = 0; i < FIX_BTMAPS_SLOTS; i++) { |
172 | if (prev_map[i] == addr) { |
173 | slot = i; |
174 | break; |
175 | } |
176 | } |
177 | |
178 | if (WARN(slot < 0, "%s(%p, %08lx) not found slot\n" , |
179 | __func__, addr, size)) |
180 | return; |
181 | |
182 | if (WARN(prev_size[slot] != size, |
183 | "%s(%p, %08lx) [%d] size not consistent %08lx\n" , |
184 | __func__, addr, size, slot, prev_size[slot])) |
185 | return; |
186 | |
187 | WARN(early_ioremap_debug, "%s(%p, %08lx) [%d]\n" , |
188 | __func__, addr, size, slot); |
189 | |
190 | virt_addr = (unsigned long)addr; |
191 | if (WARN_ON(virt_addr < fix_to_virt(FIX_BTMAP_BEGIN))) |
192 | return; |
193 | |
194 | offset = offset_in_page(virt_addr); |
195 | nrpages = PAGE_ALIGN(offset + size) >> PAGE_SHIFT; |
196 | |
197 | idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*slot; |
198 | while (nrpages > 0) { |
199 | if (after_paging_init) |
200 | __late_clear_fixmap(idx); |
201 | else |
202 | __early_set_fixmap(idx, phys: 0, FIXMAP_PAGE_CLEAR); |
203 | --idx; |
204 | --nrpages; |
205 | } |
206 | prev_map[slot] = NULL; |
207 | } |
208 | |
209 | /* Remap an IO device */ |
210 | void __init __iomem * |
211 | early_ioremap(resource_size_t phys_addr, unsigned long size) |
212 | { |
213 | return __early_ioremap(phys_addr, size, FIXMAP_PAGE_IO); |
214 | } |
215 | |
216 | /* Remap memory */ |
217 | void __init * |
218 | early_memremap(resource_size_t phys_addr, unsigned long size) |
219 | { |
220 | pgprot_t prot = early_memremap_pgprot_adjust(phys_addr, size, |
221 | FIXMAP_PAGE_NORMAL); |
222 | |
223 | return (__force void *)__early_ioremap(phys_addr, size, prot); |
224 | } |
225 | #ifdef FIXMAP_PAGE_RO |
226 | void __init * |
227 | early_memremap_ro(resource_size_t phys_addr, unsigned long size) |
228 | { |
229 | pgprot_t prot = early_memremap_pgprot_adjust(phys_addr, size, |
230 | FIXMAP_PAGE_RO); |
231 | |
232 | return (__force void *)__early_ioremap(phys_addr, size, prot); |
233 | } |
234 | #endif |
235 | |
236 | #ifdef CONFIG_ARCH_USE_MEMREMAP_PROT |
237 | void __init * |
238 | early_memremap_prot(resource_size_t phys_addr, unsigned long size, |
239 | unsigned long prot_val) |
240 | { |
241 | return (__force void *)__early_ioremap(phys_addr, size, |
242 | __pgprot(prot_val)); |
243 | } |
244 | #endif |
245 | |
246 | #define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT) |
247 | |
248 | void __init copy_from_early_mem(void *dest, phys_addr_t src, unsigned long size) |
249 | { |
250 | unsigned long slop, clen; |
251 | char *p; |
252 | |
253 | while (size) { |
254 | slop = offset_in_page(src); |
255 | clen = size; |
256 | if (clen > MAX_MAP_CHUNK - slop) |
257 | clen = MAX_MAP_CHUNK - slop; |
258 | p = early_memremap(phys_addr: src & PAGE_MASK, size: clen + slop); |
259 | memcpy(dest, p + slop, clen); |
260 | early_memunmap(addr: p, size: clen + slop); |
261 | dest += clen; |
262 | src += clen; |
263 | size -= clen; |
264 | } |
265 | } |
266 | |
267 | #else /* CONFIG_MMU */ |
268 | |
269 | void __init __iomem * |
270 | early_ioremap(resource_size_t phys_addr, unsigned long size) |
271 | { |
272 | return (__force void __iomem *)phys_addr; |
273 | } |
274 | |
275 | /* Remap memory */ |
276 | void __init * |
277 | early_memremap(resource_size_t phys_addr, unsigned long size) |
278 | { |
279 | return (void *)phys_addr; |
280 | } |
281 | void __init * |
282 | early_memremap_ro(resource_size_t phys_addr, unsigned long size) |
283 | { |
284 | return (void *)phys_addr; |
285 | } |
286 | |
287 | void __init early_iounmap(void __iomem *addr, unsigned long size) |
288 | { |
289 | } |
290 | |
291 | #endif /* CONFIG_MMU */ |
292 | |
293 | |
294 | void __init early_memunmap(void *addr, unsigned long size) |
295 | { |
296 | early_iounmap(addr: (__force void __iomem *)addr, size); |
297 | } |
298 | |