xref: /openbmc/linux/mm/early_ioremap.c (revision b4bd2aaf) 
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 		if (WARN_ON(prev_map[i]))
77 			break;
78 
79 	for (i = 0; i < FIX_BTMAPS_SLOTS; i++)
80 		slot_virt[i] = __fix_to_virt(FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*i);
81 }
82 
83 static int __init check_early_ioremap_leak(void)
84 {
85 	int count = 0;
86 	int i;
87 
88 	for (i = 0; i < FIX_BTMAPS_SLOTS; i++)
89 		if (prev_map[i])
90 			count++;
91 
92 	if (WARN(count, KERN_WARNING
93 		 "Debug warning: early ioremap leak of %d areas detected.\n"
94 		 "please boot with early_ioremap_debug and report the dmesg.\n",
95 		 count))
96 		return 1;
97 	return 0;
98 }
99 late_initcall(check_early_ioremap_leak);
100 
101 static void __init __iomem *
102 __early_ioremap(resource_size_t phys_addr, unsigned long size, pgprot_t prot)
103 {
104 	unsigned long offset;
105 	resource_size_t last_addr;
106 	unsigned int nrpages;
107 	enum fixed_addresses idx;
108 	int i, slot;
109 
110 	WARN_ON(system_state >= SYSTEM_RUNNING);
111 
112 	slot = -1;
113 	for (i = 0; i < FIX_BTMAPS_SLOTS; i++) {
114 		if (!prev_map[i]) {
115 			slot = i;
116 			break;
117 		}
118 	}
119 
120 	if (WARN(slot < 0, "%s(%pa, %08lx) not found slot\n",
121 		 __func__, &phys_addr, size))
122 		return NULL;
123 
124 	/* Don't allow wraparound or zero size */
125 	last_addr = phys_addr + size - 1;
126 	if (WARN_ON(!size || last_addr < phys_addr))
127 		return NULL;
128 
129 	prev_size[slot] = size;
130 	/*
131 	 * Mappings have to be page-aligned
132 	 */
133 	offset = offset_in_page(phys_addr);
134 	phys_addr &= PAGE_MASK;
135 	size = PAGE_ALIGN(last_addr + 1) - phys_addr;
136 
137 	/*
138 	 * Mappings have to fit in the FIX_BTMAP area.
139 	 */
140 	nrpages = size >> PAGE_SHIFT;
141 	if (WARN_ON(nrpages > NR_FIX_BTMAPS))
142 		return NULL;
143 
144 	/*
145 	 * Ok, go for it..
146 	 */
147 	idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*slot;
148 	while (nrpages > 0) {
149 		if (after_paging_init)
150 			__late_set_fixmap(idx, phys_addr, prot);
151 		else
152 			__early_set_fixmap(idx, phys_addr, prot);
153 		phys_addr += PAGE_SIZE;
154 		--idx;
155 		--nrpages;
156 	}
157 	WARN(early_ioremap_debug, "%s(%pa, %08lx) [%d] => %08lx + %08lx\n",
158 	     __func__, &phys_addr, size, slot, offset, slot_virt[slot]);
159 
160 	prev_map[slot] = (void __iomem *)(offset + slot_virt[slot]);
161 	return prev_map[slot];
162 }
163 
164 void __init early_iounmap(void __iomem *addr, unsigned long size)
165 {
166 	unsigned long virt_addr;
167 	unsigned long offset;
168 	unsigned int nrpages;
169 	enum fixed_addresses idx;
170 	int i, slot;
171 
172 	slot = -1;
173 	for (i = 0; i < FIX_BTMAPS_SLOTS; i++) {
174 		if (prev_map[i] == addr) {
175 			slot = i;
176 			break;
177 		}
178 	}
179 
180 	if (WARN(slot < 0, "%s(%p, %08lx) not found slot\n",
181 		  __func__, addr, size))
182 		return;
183 
184 	if (WARN(prev_size[slot] != size,
185 		 "%s(%p, %08lx) [%d] size not consistent %08lx\n",
186 		  __func__, addr, size, slot, prev_size[slot]))
187 		return;
188 
189 	WARN(early_ioremap_debug, "%s(%p, %08lx) [%d]\n",
190 	      __func__, addr, size, slot);
191 
192 	virt_addr = (unsigned long)addr;
193 	if (WARN_ON(virt_addr < fix_to_virt(FIX_BTMAP_BEGIN)))
194 		return;
195 
196 	offset = offset_in_page(virt_addr);
197 	nrpages = PAGE_ALIGN(offset + size) >> PAGE_SHIFT;
198 
199 	idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*slot;
200 	while (nrpages > 0) {
201 		if (after_paging_init)
202 			__late_clear_fixmap(idx);
203 		else
204 			__early_set_fixmap(idx, 0, FIXMAP_PAGE_CLEAR);
205 		--idx;
206 		--nrpages;
207 	}
208 	prev_map[slot] = NULL;
209 }
210 
211 /* Remap an IO device */
212 void __init __iomem *
213 early_ioremap(resource_size_t phys_addr, unsigned long size)
214 {
215 	return __early_ioremap(phys_addr, size, FIXMAP_PAGE_IO);
216 }
217 
218 /* Remap memory */
219 void __init *
220 early_memremap(resource_size_t phys_addr, unsigned long size)
221 {
222 	pgprot_t prot = early_memremap_pgprot_adjust(phys_addr, size,
223 						     FIXMAP_PAGE_NORMAL);
224 
225 	return (__force void *)__early_ioremap(phys_addr, size, prot);
226 }
227 #ifdef FIXMAP_PAGE_RO
228 void __init *
229 early_memremap_ro(resource_size_t phys_addr, unsigned long size)
230 {
231 	pgprot_t prot = early_memremap_pgprot_adjust(phys_addr, size,
232 						     FIXMAP_PAGE_RO);
233 
234 	return (__force void *)__early_ioremap(phys_addr, size, prot);
235 }
236 #endif
237 
238 #ifdef CONFIG_ARCH_USE_MEMREMAP_PROT
239 void __init *
240 early_memremap_prot(resource_size_t phys_addr, unsigned long size,
241 		    unsigned long prot_val)
242 {
243 	return (__force void *)__early_ioremap(phys_addr, size,
244 					       __pgprot(prot_val));
245 }
246 #endif
247 
248 #define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
249 
250 void __init copy_from_early_mem(void *dest, phys_addr_t src, unsigned long size)
251 {
252 	unsigned long slop, clen;
253 	char *p;
254 
255 	while (size) {
256 		slop = offset_in_page(src);
257 		clen = size;
258 		if (clen > MAX_MAP_CHUNK - slop)
259 			clen = MAX_MAP_CHUNK - slop;
260 		p = early_memremap(src & PAGE_MASK, clen + slop);
261 		memcpy(dest, p + slop, clen);
262 		early_memunmap(p, clen + slop);
263 		dest += clen;
264 		src += clen;
265 		size -= clen;
266 	}
267 }
268 
269 #else /* CONFIG_MMU */
270 
271 void __init __iomem *
272 early_ioremap(resource_size_t phys_addr, unsigned long size)
273 {
274 	return (__force void __iomem *)phys_addr;
275 }
276 
277 /* Remap memory */
278 void __init *
279 early_memremap(resource_size_t phys_addr, unsigned long size)
280 {
281 	return (void *)phys_addr;
282 }
283 void __init *
284 early_memremap_ro(resource_size_t phys_addr, unsigned long size)
285 {
286 	return (void *)phys_addr;
287 }
288 
289 void __init early_iounmap(void __iomem *addr, unsigned long size)
290 {
291 }
292 
293 #endif /* CONFIG_MMU */
294 
295 
296 void __init early_memunmap(void *addr, unsigned long size)
297 {
298 	early_iounmap((__force void __iomem *)addr, size);
299 }
300