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