?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
warning removal
[cor_2_6_31.git] / arch / blackfin / kernel / module.c
blobd5aee362668838f11d2f924ed47b05e34e4bb835
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
30
31 #include <linux/moduleloader.h>
32 #include <linux/elf.h>
33 #include <linux/vmalloc.h>
34 #include <linux/fs.h>
35 #include <linux/string.h>
36 #include <linux/kernel.h>
37 #include <asm/dma.h>
38 #include <asm/cacheflush.h>
39
40 void *module_alloc(unsigned long size)
41 {
42 if (size == 0)
43 return NULL;
44 return vmalloc(size);
45 }
46
47 /* Free memory returned from module_alloc */
48 void module_free(struct module *mod, void *module_region)
49 {
50 vfree(module_region);
51 }
52
53 /* Transfer the section to the L1 memory */
54 int
55 module_frob_arch_sections(Elf_Ehdr * hdr, Elf_Shdr * sechdrs,
56 char *secstrings, struct module *mod)
57 {
58 /*
59 * XXX: sechdrs are vmalloced in kernel/module.c
60 * and would be vfreed just after module is loaded,
61 * so we hack to keep the only information we needed
62 * in mod->arch to correctly free L1 I/D sram later.
63 * NOTE: this breaks the semantic of mod->arch structure.
64 */
65 Elf_Shdr *s, *sechdrs_end = sechdrs + hdr->e_shnum;
66 void *dest = NULL;
67
68 for (s = sechdrs; s < sechdrs_end; ++s) {
69 if ((strcmp(".l1.text", secstrings + s->sh_name) == 0) ||
70 ((strcmp(".text", secstrings + s->sh_name) == 0) &&
71 (hdr->e_flags & EF_BFIN_CODE_IN_L1) && (s->sh_size > 0))) {
72 dest = l1_inst_sram_alloc(s->sh_size);
73 mod->arch.text_l1 = dest;
74 if (dest == NULL) {
75 printk(KERN_ERR
76 "module %s: L1 instruction memory allocation failed\n",
77 mod->name);
78 return -1;
79 }
80 dma_memcpy(dest, (void *)s->sh_addr, s->sh_size);
81 s->sh_flags &= ~SHF_ALLOC;
82 s->sh_addr = (unsigned long)dest;
83 }
84 if ((strcmp(".l1.data", secstrings + s->sh_name) == 0) ||
85 ((strcmp(".data", secstrings + s->sh_name) == 0) &&
86 (hdr->e_flags & EF_BFIN_DATA_IN_L1) && (s->sh_size > 0))) {
87 dest = l1_data_sram_alloc(s->sh_size);
88 mod->arch.data_a_l1 = dest;
89 if (dest == NULL) {
90 printk(KERN_ERR
91 "module %s: L1 data memory allocation failed\n",
92 mod->name);
93 return -1;
94 }
95 memcpy(dest, (void *)s->sh_addr, s->sh_size);
96 s->sh_flags &= ~SHF_ALLOC;
97 s->sh_addr = (unsigned long)dest;
98 }
99 if (strcmp(".l1.bss", secstrings + s->sh_name) == 0 ||
100 ((strcmp(".bss", secstrings + s->sh_name) == 0) &&
101 (hdr->e_flags & EF_BFIN_DATA_IN_L1) && (s->sh_size > 0))) {
102 dest = l1_data_sram_alloc(s->sh_size);
103 mod->arch.bss_a_l1 = dest;
104 if (dest == NULL) {
105 printk(KERN_ERR
106 "module %s: L1 data memory allocation failed\n",
107 mod->name);
108 return -1;
109 }
110 memset(dest, 0, s->sh_size);
111 s->sh_flags &= ~SHF_ALLOC;
112 s->sh_addr = (unsigned long)dest;
113 }
114 if (strcmp(".l1.data.B", secstrings + s->sh_name) == 0) {
115 dest = l1_data_B_sram_alloc(s->sh_size);
116 mod->arch.data_b_l1 = dest;
117 if (dest == NULL) {
118 printk(KERN_ERR
119 "module %s: L1 data memory allocation failed\n",
120 mod->name);
121 return -1;
122 }
123 memcpy(dest, (void *)s->sh_addr, s->sh_size);
124 s->sh_flags &= ~SHF_ALLOC;
125 s->sh_addr = (unsigned long)dest;
126 }
127 if (strcmp(".l1.bss.B", secstrings + s->sh_name) == 0) {
128 dest = l1_data_B_sram_alloc(s->sh_size);
129 mod->arch.bss_b_l1 = dest;
130 if (dest == NULL) {
131 printk(KERN_ERR
132 "module %s: L1 data memory allocation failed\n",
133 mod->name);
134 return -1;
135 }
136 memset(dest, 0, s->sh_size);
137 s->sh_flags &= ~SHF_ALLOC;
138 s->sh_addr = (unsigned long)dest;
139 }
140 if ((strcmp(".l2.text", secstrings + s->sh_name) == 0) ||
141 ((strcmp(".text", secstrings + s->sh_name) == 0) &&
142 (hdr->e_flags & EF_BFIN_CODE_IN_L2) && (s->sh_size > 0))) {
143 dest = l2_sram_alloc(s->sh_size);
144 mod->arch.text_l2 = dest;
145 if (dest == NULL) {
146 printk(KERN_ERR
147 "module %s: L2 SRAM allocation failed\n",
148 mod->name);
149 return -1;
150 }
151 memcpy(dest, (void *)s->sh_addr, s->sh_size);
152 s->sh_flags &= ~SHF_ALLOC;
153 s->sh_addr = (unsigned long)dest;
154 }
155 if ((strcmp(".l2.data", secstrings + s->sh_name) == 0) ||
156 ((strcmp(".data", secstrings + s->sh_name) == 0) &&
157 (hdr->e_flags & EF_BFIN_DATA_IN_L2) && (s->sh_size > 0))) {
158 dest = l2_sram_alloc(s->sh_size);
159 mod->arch.data_l2 = dest;
160 if (dest == NULL) {
161 printk(KERN_ERR
162 "module %s: L2 SRAM allocation failed\n",
163 mod->name);
164 return -1;
165 }
166 memcpy(dest, (void *)s->sh_addr, s->sh_size);
167 s->sh_flags &= ~SHF_ALLOC;
168 s->sh_addr = (unsigned long)dest;
169 }
170 if (strcmp(".l2.bss", secstrings + s->sh_name) == 0 ||
171 ((strcmp(".bss", secstrings + s->sh_name) == 0) &&
172 (hdr->e_flags & EF_BFIN_DATA_IN_L2) && (s->sh_size > 0))) {
173 dest = l2_sram_alloc(s->sh_size);
174 mod->arch.bss_l2 = dest;
175 if (dest == NULL) {
176 printk(KERN_ERR
177 "module %s: L2 SRAM allocation failed\n",
178 mod->name);
179 return -1;
180 }
181 memset(dest, 0, s->sh_size);
182 s->sh_flags &= ~SHF_ALLOC;
183 s->sh_addr = (unsigned long)dest;
184 }
185 }
186 return 0;
187 }
188
189 int
190 apply_relocate(Elf_Shdr * sechdrs, const char *strtab,
191 unsigned int symindex, unsigned int relsec, struct module *me)
192 {
193 printk(KERN_ERR "module %s: .rel unsupported\n", me->name);
194 return -ENOEXEC;
195 }
196
197 /*************************************************************************/
198 /* FUNCTION : apply_relocate_add */
199 /* ABSTRACT : Blackfin specific relocation handling for the loadable */
200 /* modules. Modules are expected to be .o files. */
201 /* Arithmetic relocations are handled. */
202 /* We do not expect LSETUP to be split and hence is not */
203 /* handled. */
204 /* R_BFIN_BYTE and R_BFIN_BYTE2 are also not handled as the */
205 /* gas does not generate it. */
206 /*************************************************************************/
207 int
208 apply_relocate_add(Elf_Shdr * sechdrs, const char *strtab,
209 unsigned int symindex, unsigned int relsec,
210 struct module *mod)
211 {
212 unsigned int i;
213 unsigned short tmp;
214 Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr;
215 Elf32_Sym *sym;
216 uint32_t *location32;
217 uint16_t *location16;
218 uint32_t value;
219
220 pr_debug("Applying relocate section %u to %u\n", relsec,
221 sechdrs[relsec].sh_info);
222 for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
223 /* This is where to make the change */
224 location16 =
225 (uint16_t *) (sechdrs[sechdrs[relsec].sh_info].sh_addr +
226 rel[i].r_offset);
227 location32 = (uint32_t *) location16;
228 /* This is the symbol it is referring to. Note that all
229 undefined symbols have been resolved. */
230 sym = (Elf32_Sym *) sechdrs[symindex].sh_addr
231 + ELF32_R_SYM(rel[i].r_info);
232 value = sym->st_value;
233 value += rel[i].r_addend;
234 pr_debug("location is %x, value is %x type is %d \n",
235 (unsigned int) location32, value,
236 ELF32_R_TYPE(rel[i].r_info));
237 #ifdef CONFIG_SMP
238 if ((unsigned long)location16 >= COREB_L1_DATA_A_START) {
239 printk(KERN_ERR "module %s: cannot relocate in L1: %u (SMP kernel)",
240 mod->name, ELF32_R_TYPE(rel[i].r_info));
241 return -ENOEXEC;
242 }
243 #endif
244 switch (ELF32_R_TYPE(rel[i].r_info)) {
245
246 case R_BFIN_PCREL24:
247 case R_BFIN_PCREL24_JUMP_L:
248 /* Add the value, subtract its postition */
249 location16 =
250 (uint16_t *) (sechdrs[sechdrs[relsec].sh_info].
251 sh_addr + rel[i].r_offset - 2);
252 location32 = (uint32_t *) location16;
253 value -= (uint32_t) location32;
254 value >>= 1;
255 if ((value & 0xFF000000) != 0 &&
256 (value & 0xFF000000) != 0xFF000000) {
257 printk(KERN_ERR "module %s: relocation overflow\n",
258 mod->name);
259 return -ENOEXEC;
260 }
261 pr_debug("value is %x, before %x-%x after %x-%x\n", value,
262 *location16, *(location16 + 1),
263 (*location16 & 0xff00) | (value >> 16 & 0x00ff),
264 value & 0xffff);
265 *location16 =
266 (*location16 & 0xff00) | (value >> 16 & 0x00ff);
267 *(location16 + 1) = value & 0xffff;
268 break;
269 case R_BFIN_PCREL12_JUMP:
270 case R_BFIN_PCREL12_JUMP_S:
271 value -= (uint32_t) location32;
272 value >>= 1;
273 *location16 = (value & 0xfff);
274 break;
275 case R_BFIN_PCREL10:
276 value -= (uint32_t) location32;
277 value >>= 1;
278 *location16 = (value & 0x3ff);
279 break;
280 case R_BFIN_LUIMM16:
281 pr_debug("before %x after %x\n", *location16,
282 (value & 0xffff));
283 tmp = (value & 0xffff);
284 if ((unsigned long)location16 >= L1_CODE_START) {
285 dma_memcpy(location16, &tmp, 2);
286 } else
287 *location16 = tmp;
288 break;
289 case R_BFIN_HUIMM16:
290 pr_debug("before %x after %x\n", *location16,
291 ((value >> 16) & 0xffff));
292 tmp = ((value >> 16) & 0xffff);
293 if ((unsigned long)location16 >= L1_CODE_START) {
294 dma_memcpy(location16, &tmp, 2);
295 } else
296 *location16 = tmp;
297 break;
298 case R_BFIN_RIMM16:
299 *location16 = (value & 0xffff);
300 break;
301 case R_BFIN_BYTE4_DATA:
302 pr_debug("before %x after %x\n", *location32, value);
303 *location32 = value;
304 break;
305 default:
306 printk(KERN_ERR "module %s: Unknown relocation: %u\n",
307 mod->name, ELF32_R_TYPE(rel[i].r_info));
308 return -ENOEXEC;
309 }
310 }
311 return 0;
312 }
313
314 int
315 module_finalize(const Elf_Ehdr * hdr,
316 const Elf_Shdr * sechdrs, struct module *mod)
317 {
318 unsigned int i, strindex = 0, symindex = 0;
319 char *secstrings;
320 long err = 0;
321
322 secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
323
324 for (i = 1; i < hdr->e_shnum; i++) {
325 /* Internal symbols and strings. */
326 if (sechdrs[i].sh_type == SHT_SYMTAB) {
327 symindex = i;
328 strindex = sechdrs[i].sh_link;
329 }
330 }
331
332 for (i = 1; i < hdr->e_shnum; i++) {
333 const char *strtab = (char *)sechdrs[strindex].sh_addr;
334 unsigned int info = sechdrs[i].sh_info;
335
336 /* Not a valid relocation section? */
337 if (info >= hdr->e_shnum)
338 continue;
339
340 if ((sechdrs[i].sh_type == SHT_RELA) &&
341 ((strcmp(".rela.l2.text", secstrings + sechdrs[i].sh_name) == 0) ||
342 (strcmp(".rela.l1.text", secstrings + sechdrs[i].sh_name) == 0) ||
343 ((strcmp(".rela.text", secstrings + sechdrs[i].sh_name) == 0) &&
344 (hdr->e_flags & (EF_BFIN_CODE_IN_L1|EF_BFIN_CODE_IN_L2))))) {
345 err = apply_relocate_add((Elf_Shdr *) sechdrs, strtab,
346 symindex, i, mod);
347 if (err < 0)
348 return -ENOEXEC;
349 }
350 }
351 return 0;
352 }
353
354 void module_arch_cleanup(struct module *mod)
355 {
356 l1_inst_sram_free(mod->arch.text_l1);
357 l1_data_A_sram_free(mod->arch.data_a_l1);
358 l1_data_A_sram_free(mod->arch.bss_a_l1);
359 l1_data_B_sram_free(mod->arch.data_b_l1);
360 l1_data_B_sram_free(mod->arch.bss_b_l1);
361 l2_sram_free(mod->arch.text_l2);
362 l2_sram_free(mod->arch.data_l2);
363 l2_sram_free(mod->arch.bss_l2);
364 }
connection oriented routing - ARCHIVE NO UPDATES HERE