]>
Commit | Line | Data |
---|---|---|
1394f032 BW |
1 | /* |
2 | * File: arch/blackfin/kernel/module.c | |
3 | * Based on: | |
4 | * Author: | |
5 | * | |
6 | * Created: | |
7 | * Description: | |
8 | * | |
9 | * Modified: | |
10 | * Copyright 2004-2006 Analog Devices Inc. | |
11 | * | |
12 | * Bugs: Enter bugs at http://blackfin.uclinux.org/ | |
13 | * | |
14 | * This program is free software; you can redistribute it and/or modify | |
15 | * it under the terms of the GNU General Public License as published by | |
16 | * the Free Software Foundation; either version 2 of the License, or | |
17 | * (at your option) any later version. | |
18 | * | |
19 | * This program is distributed in the hope that it will be useful, | |
20 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
22 | * GNU General Public License for more details. | |
23 | * | |
24 | * You should have received a copy of the GNU General Public License | |
25 | * along with this program; if not, see the file COPYING, or write | |
26 | * to the Free Software Foundation, Inc., | |
27 | * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
28 | */ | |
29 | ||
dc6b1ac9 | 30 | #define pr_fmt(fmt) "module %s: " fmt |
1394f032 BW |
31 | |
32 | #include <linux/moduleloader.h> | |
33 | #include <linux/elf.h> | |
34 | #include <linux/vmalloc.h> | |
35 | #include <linux/fs.h> | |
36 | #include <linux/string.h> | |
37 | #include <linux/kernel.h> | |
38 | #include <asm/dma.h> | |
39 | #include <asm/cacheflush.h> | |
a7690940 | 40 | #include <asm/uaccess.h> |
1394f032 | 41 | |
1394f032 BW |
42 | void *module_alloc(unsigned long size) |
43 | { | |
44 | if (size == 0) | |
45 | return NULL; | |
46 | return vmalloc(size); | |
47 | } | |
48 | ||
49 | /* Free memory returned from module_alloc */ | |
50 | void module_free(struct module *mod, void *module_region) | |
51 | { | |
52 | vfree(module_region); | |
53 | } | |
54 | ||
55 | /* Transfer the section to the L1 memory */ | |
56 | int | |
459fec90 | 57 | module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs, |
1394f032 BW |
58 | char *secstrings, struct module *mod) |
59 | { | |
96a87e2f MF |
60 | /* |
61 | * XXX: sechdrs are vmalloced in kernel/module.c | |
62 | * and would be vfreed just after module is loaded, | |
63 | * so we hack to keep the only information we needed | |
64 | * in mod->arch to correctly free L1 I/D sram later. | |
65 | * NOTE: this breaks the semantic of mod->arch structure. | |
66 | */ | |
1394f032 | 67 | Elf_Shdr *s, *sechdrs_end = sechdrs + hdr->e_shnum; |
459fec90 | 68 | void *dest; |
1394f032 BW |
69 | |
70 | for (s = sechdrs; s < sechdrs_end; ++s) { | |
459fec90 MF |
71 | const char *shname = secstrings + s->sh_name; |
72 | ||
73 | if (s->sh_size == 0) | |
74 | continue; | |
75 | ||
76 | if (!strcmp(".l1.text", shname) || | |
77 | (!strcmp(".text", shname) && | |
78 | (hdr->e_flags & EF_BFIN_CODE_IN_L1))) { | |
79 | ||
1394f032 | 80 | dest = l1_inst_sram_alloc(s->sh_size); |
96a87e2f | 81 | mod->arch.text_l1 = dest; |
1394f032 | 82 | if (dest == NULL) { |
dc6b1ac9 MF |
83 | pr_err("L1 inst memory allocation failed\n", |
84 | mod->name); | |
1394f032 BW |
85 | return -1; |
86 | } | |
87 | dma_memcpy(dest, (void *)s->sh_addr, s->sh_size); | |
459fec90 MF |
88 | |
89 | } else if (!strcmp(".l1.data", shname) || | |
90 | (!strcmp(".data", shname) && | |
91 | (hdr->e_flags & EF_BFIN_DATA_IN_L1))) { | |
92 | ||
1394f032 | 93 | dest = l1_data_sram_alloc(s->sh_size); |
96a87e2f | 94 | mod->arch.data_a_l1 = dest; |
1394f032 | 95 | if (dest == NULL) { |
dc6b1ac9 | 96 | pr_err("L1 data memory allocation failed\n", |
1394f032 BW |
97 | mod->name); |
98 | return -1; | |
99 | } | |
100 | memcpy(dest, (void *)s->sh_addr, s->sh_size); | |
459fec90 MF |
101 | |
102 | } else if (!strcmp(".l1.bss", shname) || | |
103 | (!strcmp(".bss", shname) && | |
104 | (hdr->e_flags & EF_BFIN_DATA_IN_L1))) { | |
105 | ||
70deca9f | 106 | dest = l1_data_sram_zalloc(s->sh_size); |
96a87e2f | 107 | mod->arch.bss_a_l1 = dest; |
1394f032 | 108 | if (dest == NULL) { |
dc6b1ac9 | 109 | pr_err("L1 data memory allocation failed\n", |
1394f032 BW |
110 | mod->name); |
111 | return -1; | |
112 | } | |
459fec90 MF |
113 | |
114 | } else if (!strcmp(".l1.data.B", shname)) { | |
115 | ||
1394f032 | 116 | dest = l1_data_B_sram_alloc(s->sh_size); |
96a87e2f | 117 | mod->arch.data_b_l1 = dest; |
1394f032 | 118 | if (dest == NULL) { |
dc6b1ac9 | 119 | pr_err("L1 data memory allocation failed\n", |
1394f032 BW |
120 | mod->name); |
121 | return -1; | |
122 | } | |
123 | memcpy(dest, (void *)s->sh_addr, s->sh_size); | |
459fec90 MF |
124 | |
125 | } else if (!strcmp(".l1.bss.B", shname)) { | |
126 | ||
1394f032 | 127 | dest = l1_data_B_sram_alloc(s->sh_size); |
96a87e2f | 128 | mod->arch.bss_b_l1 = dest; |
1394f032 | 129 | if (dest == NULL) { |
dc6b1ac9 | 130 | pr_err("L1 data memory allocation failed\n", |
1394f032 BW |
131 | mod->name); |
132 | return -1; | |
133 | } | |
134 | memset(dest, 0, s->sh_size); | |
459fec90 MF |
135 | |
136 | } else if (!strcmp(".l2.text", shname) || | |
137 | (!strcmp(".text", shname) && | |
138 | (hdr->e_flags & EF_BFIN_CODE_IN_L2))) { | |
139 | ||
262c3825 SZ |
140 | dest = l2_sram_alloc(s->sh_size); |
141 | mod->arch.text_l2 = dest; | |
142 | if (dest == NULL) { | |
dc6b1ac9 MF |
143 | pr_err("L2 SRAM allocation failed\n", |
144 | mod->name); | |
262c3825 SZ |
145 | return -1; |
146 | } | |
147 | memcpy(dest, (void *)s->sh_addr, s->sh_size); | |
459fec90 MF |
148 | |
149 | } else if (!strcmp(".l2.data", shname) || | |
150 | (!strcmp(".data", shname) && | |
151 | (hdr->e_flags & EF_BFIN_DATA_IN_L2))) { | |
152 | ||
262c3825 SZ |
153 | dest = l2_sram_alloc(s->sh_size); |
154 | mod->arch.data_l2 = dest; | |
155 | if (dest == NULL) { | |
dc6b1ac9 | 156 | pr_err("L2 SRAM allocation failed\n", |
262c3825 SZ |
157 | mod->name); |
158 | return -1; | |
159 | } | |
160 | memcpy(dest, (void *)s->sh_addr, s->sh_size); | |
459fec90 MF |
161 | |
162 | } else if (!strcmp(".l2.bss", shname) || | |
163 | (!strcmp(".bss", shname) && | |
164 | (hdr->e_flags & EF_BFIN_DATA_IN_L2))) { | |
165 | ||
70deca9f | 166 | dest = l2_sram_zalloc(s->sh_size); |
262c3825 SZ |
167 | mod->arch.bss_l2 = dest; |
168 | if (dest == NULL) { | |
dc6b1ac9 | 169 | pr_err("L2 SRAM allocation failed\n", |
262c3825 SZ |
170 | mod->name); |
171 | return -1; | |
172 | } | |
459fec90 MF |
173 | |
174 | } else | |
175 | continue; | |
176 | ||
177 | s->sh_flags &= ~SHF_ALLOC; | |
178 | s->sh_addr = (unsigned long)dest; | |
1394f032 | 179 | } |
459fec90 | 180 | |
1394f032 BW |
181 | return 0; |
182 | } | |
183 | ||
184 | int | |
185 | apply_relocate(Elf_Shdr * sechdrs, const char *strtab, | |
186 | unsigned int symindex, unsigned int relsec, struct module *me) | |
187 | { | |
dc6b1ac9 | 188 | pr_err(".rel unsupported\n", me->name); |
1394f032 BW |
189 | return -ENOEXEC; |
190 | } | |
191 | ||
192 | /*************************************************************************/ | |
193 | /* FUNCTION : apply_relocate_add */ | |
194 | /* ABSTRACT : Blackfin specific relocation handling for the loadable */ | |
195 | /* modules. Modules are expected to be .o files. */ | |
196 | /* Arithmetic relocations are handled. */ | |
197 | /* We do not expect LSETUP to be split and hence is not */ | |
198 | /* handled. */ | |
595d681f MF |
199 | /* R_BFIN_BYTE and R_BFIN_BYTE2 are also not handled as the */ |
200 | /* gas does not generate it. */ | |
1394f032 BW |
201 | /*************************************************************************/ |
202 | int | |
a7690940 | 203 | apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab, |
1394f032 BW |
204 | unsigned int symindex, unsigned int relsec, |
205 | struct module *mod) | |
206 | { | |
207 | unsigned int i; | |
1394f032 BW |
208 | Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr; |
209 | Elf32_Sym *sym; | |
a7690940 | 210 | unsigned long location, value, size; |
1394f032 | 211 | |
dc6b1ac9 MF |
212 | pr_debug("applying relocate section %u to %u\n", mod->name, |
213 | relsec, sechdrs[relsec].sh_info); | |
a7690940 | 214 | |
1394f032 BW |
215 | for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) { |
216 | /* This is where to make the change */ | |
a7690940 MF |
217 | location = sechdrs[sechdrs[relsec].sh_info].sh_addr + |
218 | rel[i].r_offset; | |
219 | ||
1394f032 BW |
220 | /* This is the symbol it is referring to. Note that all |
221 | undefined symbols have been resolved. */ | |
222 | sym = (Elf32_Sym *) sechdrs[symindex].sh_addr | |
223 | + ELF32_R_SYM(rel[i].r_info); | |
d1a85305 | 224 | value = sym->st_value; |
1394f032 | 225 | value += rel[i].r_addend; |
dc6b1ac9 | 226 | |
8f65873e | 227 | #ifdef CONFIG_SMP |
a7690940 | 228 | if (location >= COREB_L1_DATA_A_START) { |
dc6b1ac9 MF |
229 | pr_err("cannot relocate in L1: %u (SMP kernel)", |
230 | mod->name, ELF32_R_TYPE(rel[i].r_info)); | |
8f65873e GY |
231 | return -ENOEXEC; |
232 | } | |
233 | #endif | |
dc6b1ac9 | 234 | |
a7690940 MF |
235 | pr_debug("location is %lx, value is %lx type is %d\n", |
236 | mod->name, location, value, ELF32_R_TYPE(rel[i].r_info)); | |
dc6b1ac9 | 237 | |
1394f032 BW |
238 | switch (ELF32_R_TYPE(rel[i].r_info)) { |
239 | ||
595d681f | 240 | case R_BFIN_HUIMM16: |
a7690940 MF |
241 | value >>= 16; |
242 | case R_BFIN_LUIMM16: | |
595d681f | 243 | case R_BFIN_RIMM16: |
a7690940 | 244 | size = 2; |
1394f032 | 245 | break; |
595d681f | 246 | case R_BFIN_BYTE4_DATA: |
a7690940 | 247 | size = 4; |
1394f032 | 248 | break; |
a7690940 | 249 | |
22532578 RG |
250 | case R_BFIN_PCREL24: |
251 | case R_BFIN_PCREL24_JUMP_L: | |
252 | case R_BFIN_PCREL12_JUMP: | |
253 | case R_BFIN_PCREL12_JUMP_S: | |
254 | case R_BFIN_PCREL10: | |
dc6b1ac9 | 255 | pr_err("unsupported relocation: %u (no -mlong-calls?)\n", |
22532578 RG |
256 | mod->name, ELF32_R_TYPE(rel[i].r_info)); |
257 | return -ENOEXEC; | |
a7690940 | 258 | |
1394f032 | 259 | default: |
dc6b1ac9 MF |
260 | pr_err("unknown relocation: %u\n", mod->name, |
261 | ELF32_R_TYPE(rel[i].r_info)); | |
1394f032 BW |
262 | return -ENOEXEC; |
263 | } | |
a7690940 MF |
264 | |
265 | switch (bfin_mem_access_type(location, size)) { | |
266 | case BFIN_MEM_ACCESS_CORE: | |
267 | case BFIN_MEM_ACCESS_CORE_ONLY: | |
268 | memcpy((void *)location, &value, size); | |
269 | break; | |
270 | case BFIN_MEM_ACCESS_DMA: | |
271 | dma_memcpy((void *)location, &value, size); | |
272 | break; | |
273 | case BFIN_MEM_ACCESS_ITEST: | |
274 | isram_memcpy((void *)location, &value, size); | |
275 | break; | |
276 | default: | |
277 | pr_err("invalid relocation for %#lx\n", | |
278 | mod->name, location); | |
279 | return -ENOEXEC; | |
280 | } | |
1394f032 | 281 | } |
a7690940 | 282 | |
1394f032 BW |
283 | return 0; |
284 | } | |
285 | ||
286 | int | |
287 | module_finalize(const Elf_Ehdr * hdr, | |
288 | const Elf_Shdr * sechdrs, struct module *mod) | |
289 | { | |
290 | unsigned int i, strindex = 0, symindex = 0; | |
291 | char *secstrings; | |
8f65873e | 292 | long err = 0; |
1394f032 BW |
293 | |
294 | secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset; | |
295 | ||
296 | for (i = 1; i < hdr->e_shnum; i++) { | |
297 | /* Internal symbols and strings. */ | |
298 | if (sechdrs[i].sh_type == SHT_SYMTAB) { | |
299 | symindex = i; | |
300 | strindex = sechdrs[i].sh_link; | |
301 | } | |
302 | } | |
303 | ||
304 | for (i = 1; i < hdr->e_shnum; i++) { | |
305 | const char *strtab = (char *)sechdrs[strindex].sh_addr; | |
306 | unsigned int info = sechdrs[i].sh_info; | |
459fec90 | 307 | const char *shname = secstrings + sechdrs[i].sh_name; |
1394f032 BW |
308 | |
309 | /* Not a valid relocation section? */ | |
310 | if (info >= hdr->e_shnum) | |
311 | continue; | |
312 | ||
459fec90 MF |
313 | /* Only support RELA relocation types */ |
314 | if (sechdrs[i].sh_type != SHT_RELA) | |
315 | continue; | |
316 | ||
317 | if (!strcmp(".rela.l2.text", shname) || | |
318 | !strcmp(".rela.l1.text", shname) || | |
319 | (!strcmp(".rela.text", shname) && | |
320 | (hdr->e_flags & (EF_BFIN_CODE_IN_L1 | EF_BFIN_CODE_IN_L2)))) { | |
321 | ||
8f65873e | 322 | err = apply_relocate_add((Elf_Shdr *) sechdrs, strtab, |
1394f032 | 323 | symindex, i, mod); |
8f65873e GY |
324 | if (err < 0) |
325 | return -ENOEXEC; | |
1394f032 BW |
326 | } |
327 | } | |
459fec90 | 328 | |
1394f032 BW |
329 | return 0; |
330 | } | |
331 | ||
332 | void module_arch_cleanup(struct module *mod) | |
333 | { | |
262c3825 SZ |
334 | l1_inst_sram_free(mod->arch.text_l1); |
335 | l1_data_A_sram_free(mod->arch.data_a_l1); | |
336 | l1_data_A_sram_free(mod->arch.bss_a_l1); | |
337 | l1_data_B_sram_free(mod->arch.data_b_l1); | |
338 | l1_data_B_sram_free(mod->arch.bss_b_l1); | |
339 | l2_sram_free(mod->arch.text_l2); | |
340 | l2_sram_free(mod->arch.data_l2); | |
341 | l2_sram_free(mod->arch.bss_l2); | |
1394f032 | 342 | } |