Blackfin arch: Extend sram malloc to handle L2 SRAM.
[linux-2.6.git] / arch / blackfin / kernel / module.c
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 /*
41  * handle arithmetic relocations.
42  * See binutils/bfd/elf32-bfin.c for more details
43  */
44 #define RELOC_STACK_SIZE 100
45 static uint32_t reloc_stack[RELOC_STACK_SIZE];
46 static unsigned int reloc_stack_tos;
47
48 #define is_reloc_stack_empty() ((reloc_stack_tos > 0)?0:1)
49
50 static void reloc_stack_push(uint32_t value)
51 {
52         reloc_stack[reloc_stack_tos++] = value;
53 }
54
55 static uint32_t reloc_stack_pop(void)
56 {
57         return reloc_stack[--reloc_stack_tos];
58 }
59
60 static uint32_t reloc_stack_operate(unsigned int oper, struct module *mod)
61 {
62         uint32_t value;
63
64         switch (oper) {
65         case R_add:
66                 value = reloc_stack[reloc_stack_tos - 2] +
67                         reloc_stack[reloc_stack_tos - 1];
68                 reloc_stack_tos -= 2;
69                 break;
70         case R_sub:
71                 value = reloc_stack[reloc_stack_tos - 2] -
72                         reloc_stack[reloc_stack_tos - 1];
73                 reloc_stack_tos -= 2;
74                 break;
75         case R_mult:
76                 value = reloc_stack[reloc_stack_tos - 2] *
77                         reloc_stack[reloc_stack_tos - 1];
78                 reloc_stack_tos -= 2;
79                 break;
80         case R_div:
81                 value = reloc_stack[reloc_stack_tos - 2] /
82                         reloc_stack[reloc_stack_tos - 1];
83                 reloc_stack_tos -= 2;
84                 break;
85         case R_mod:
86                 value = reloc_stack[reloc_stack_tos - 2] %
87                         reloc_stack[reloc_stack_tos - 1];
88                 reloc_stack_tos -= 2;
89                 break;
90         case R_lshift:
91                 value = reloc_stack[reloc_stack_tos - 2] <<
92                         reloc_stack[reloc_stack_tos - 1];
93                 reloc_stack_tos -= 2;
94                 break;
95         case R_rshift:
96                 value = reloc_stack[reloc_stack_tos - 2] >>
97                         reloc_stack[reloc_stack_tos - 1];
98                 reloc_stack_tos -= 2;
99                 break;
100         case R_and:
101                 value = reloc_stack[reloc_stack_tos - 2] &
102                         reloc_stack[reloc_stack_tos - 1];
103                 reloc_stack_tos -= 2;
104                 break;
105         case R_or:
106                 value = reloc_stack[reloc_stack_tos - 2] |
107                         reloc_stack[reloc_stack_tos - 1];
108                 reloc_stack_tos -= 2;
109                 break;
110         case R_xor:
111                 value = reloc_stack[reloc_stack_tos - 2] ^
112                         reloc_stack[reloc_stack_tos - 1];
113                 reloc_stack_tos -= 2;
114                 break;
115         case R_land:
116                 value = reloc_stack[reloc_stack_tos - 2] &&
117                         reloc_stack[reloc_stack_tos - 1];
118                 reloc_stack_tos -= 2;
119                 break;
120         case R_lor:
121                 value = reloc_stack[reloc_stack_tos - 2] ||
122                         reloc_stack[reloc_stack_tos - 1];
123                 reloc_stack_tos -= 2;
124                 break;
125         case R_neg:
126                 value = -reloc_stack[reloc_stack_tos - 1];
127                 reloc_stack_tos--;
128                 break;
129         case R_comp:
130                 value = ~reloc_stack[reloc_stack_tos - 1];
131                 reloc_stack_tos -= 1;
132                 break;
133         default:
134                 printk(KERN_WARNING "module %s: unhandled reloction\n",
135                                 mod->name);
136                 return 0;
137         }
138
139         /* now push the new value back on stack */
140         reloc_stack_push(value);
141
142         return value;
143 }
144
145 void *module_alloc(unsigned long size)
146 {
147         if (size == 0)
148                 return NULL;
149         return vmalloc(size);
150 }
151
152 /* Free memory returned from module_alloc */
153 void module_free(struct module *mod, void *module_region)
154 {
155         vfree(module_region);
156 }
157
158 /* Transfer the section to the L1 memory */
159 int
160 module_frob_arch_sections(Elf_Ehdr * hdr, Elf_Shdr * sechdrs,
161                           char *secstrings, struct module *mod)
162 {
163         /*
164          * XXX: sechdrs are vmalloced in kernel/module.c
165          * and would be vfreed just after module is loaded,
166          * so we hack to keep the only information we needed
167          * in mod->arch to correctly free L1 I/D sram later.
168          * NOTE: this breaks the semantic of mod->arch structure.
169          */
170         Elf_Shdr *s, *sechdrs_end = sechdrs + hdr->e_shnum;
171         void *dest = NULL;
172
173         for (s = sechdrs; s < sechdrs_end; ++s) {
174                 if ((strcmp(".l1.text", secstrings + s->sh_name) == 0) ||
175                     ((strcmp(".text", secstrings + s->sh_name) == 0) &&
176                      (hdr->e_flags & EF_BFIN_CODE_IN_L1) && (s->sh_size > 0))) {
177                         dest = l1_inst_sram_alloc(s->sh_size);
178                         mod->arch.text_l1 = dest;
179                         if (dest == NULL) {
180                                 printk(KERN_ERR
181                                        "module %s: L1 instruction memory allocation failed\n",
182                                        mod->name);
183                                 return -1;
184                         }
185                         dma_memcpy(dest, (void *)s->sh_addr, s->sh_size);
186                         s->sh_flags &= ~SHF_ALLOC;
187                         s->sh_addr = (unsigned long)dest;
188                 }
189                 if ((strcmp(".l1.data", secstrings + s->sh_name) == 0) ||
190                     ((strcmp(".data", secstrings + s->sh_name) == 0) &&
191                      (hdr->e_flags & EF_BFIN_DATA_IN_L1) && (s->sh_size > 0))) {
192                         dest = l1_data_sram_alloc(s->sh_size);
193                         mod->arch.data_a_l1 = dest;
194                         if (dest == NULL) {
195                                 printk(KERN_ERR
196                                         "module %s: L1 data memory allocation failed\n",
197                                         mod->name);
198                                 return -1;
199                         }
200                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
201                         s->sh_flags &= ~SHF_ALLOC;
202                         s->sh_addr = (unsigned long)dest;
203                 }
204                 if (strcmp(".l1.bss", secstrings + s->sh_name) == 0 ||
205                     ((strcmp(".bss", secstrings + s->sh_name) == 0) &&
206                      (hdr->e_flags & EF_BFIN_DATA_IN_L1) && (s->sh_size > 0))) {
207                         dest = l1_data_sram_alloc(s->sh_size);
208                         mod->arch.bss_a_l1 = dest;
209                         if (dest == NULL) {
210                                 printk(KERN_ERR
211                                         "module %s: L1 data memory allocation failed\n",
212                                         mod->name);
213                                 return -1;
214                         }
215                         memset(dest, 0, s->sh_size);
216                         s->sh_flags &= ~SHF_ALLOC;
217                         s->sh_addr = (unsigned long)dest;
218                 }
219                 if (strcmp(".l1.data.B", secstrings + s->sh_name) == 0) {
220                         dest = l1_data_B_sram_alloc(s->sh_size);
221                         mod->arch.data_b_l1 = dest;
222                         if (dest == NULL) {
223                                 printk(KERN_ERR
224                                         "module %s: L1 data memory allocation failed\n",
225                                         mod->name);
226                                 return -1;
227                         }
228                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
229                         s->sh_flags &= ~SHF_ALLOC;
230                         s->sh_addr = (unsigned long)dest;
231                 }
232                 if (strcmp(".l1.bss.B", secstrings + s->sh_name) == 0) {
233                         dest = l1_data_B_sram_alloc(s->sh_size);
234                         mod->arch.bss_b_l1 = dest;
235                         if (dest == NULL) {
236                                 printk(KERN_ERR
237                                         "module %s: L1 data memory allocation failed\n",
238                                         mod->name);
239                                 return -1;
240                         }
241                         memset(dest, 0, s->sh_size);
242                         s->sh_flags &= ~SHF_ALLOC;
243                         s->sh_addr = (unsigned long)dest;
244                 }
245                 if ((strcmp(".l2.text", secstrings + s->sh_name) == 0) ||
246                     ((strcmp(".text", secstrings + s->sh_name) == 0) &&
247                      (hdr->e_flags & EF_BFIN_CODE_IN_L2) && (s->sh_size > 0))) {
248                         dest = l2_sram_alloc(s->sh_size);
249                         mod->arch.text_l2 = dest;
250                         if (dest == NULL) {
251                                 printk(KERN_ERR
252                                        "module %s: L2 SRAM allocation failed\n",
253                                        mod->name);
254                                 return -1;
255                         }
256                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
257                         s->sh_flags &= ~SHF_ALLOC;
258                         s->sh_addr = (unsigned long)dest;
259                 }
260                 if ((strcmp(".l2.data", secstrings + s->sh_name) == 0) ||
261                     ((strcmp(".data", secstrings + s->sh_name) == 0) &&
262                      (hdr->e_flags & EF_BFIN_DATA_IN_L2) && (s->sh_size > 0))) {
263                         dest = l2_sram_alloc(s->sh_size);
264                         mod->arch.data_l2 = dest;
265                         if (dest == NULL) {
266                                 printk(KERN_ERR
267                                         "module %s: L2 SRAM allocation failed\n",
268                                         mod->name);
269                                 return -1;
270                         }
271                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
272                         s->sh_flags &= ~SHF_ALLOC;
273                         s->sh_addr = (unsigned long)dest;
274                 }
275                 if (strcmp(".l2.bss", secstrings + s->sh_name) == 0 ||
276                     ((strcmp(".bss", secstrings + s->sh_name) == 0) &&
277                      (hdr->e_flags & EF_BFIN_DATA_IN_L2) && (s->sh_size > 0))) {
278                         dest = l2_sram_alloc(s->sh_size);
279                         mod->arch.bss_l2 = dest;
280                         if (dest == NULL) {
281                                 printk(KERN_ERR
282                                         "module %s: L2 SRAM allocation failed\n",
283                                         mod->name);
284                                 return -1;
285                         }
286                         memset(dest, 0, s->sh_size);
287                         s->sh_flags &= ~SHF_ALLOC;
288                         s->sh_addr = (unsigned long)dest;
289                 }
290         }
291         return 0;
292 }
293
294 int
295 apply_relocate(Elf_Shdr * sechdrs, const char *strtab,
296                unsigned int symindex, unsigned int relsec, struct module *me)
297 {
298         printk(KERN_ERR "module %s: .rel unsupported\n", me->name);
299         return -ENOEXEC;
300 }
301
302 /*************************************************************************/
303 /* FUNCTION : apply_relocate_add                                         */
304 /* ABSTRACT : Blackfin specific relocation handling for the loadable     */
305 /*            modules. Modules are expected to be .o files.              */
306 /*            Arithmetic relocations are handled.                        */
307 /*            We do not expect LSETUP to be split and hence is not       */
308 /*            handled.                                                   */
309 /*            R_byte and R_byte2 are also not handled as the gas         */
310 /*            does not generate it.                                      */
311 /*************************************************************************/
312 int
313 apply_relocate_add(Elf_Shdr * sechdrs, const char *strtab,
314                    unsigned int symindex, unsigned int relsec,
315                    struct module *mod)
316 {
317         unsigned int i;
318         unsigned short tmp;
319         Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr;
320         Elf32_Sym *sym;
321         uint32_t *location32;
322         uint16_t *location16;
323         uint32_t value;
324
325         pr_debug("Applying relocate section %u to %u\n", relsec,
326                sechdrs[relsec].sh_info);
327         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
328                 /* This is where to make the change */
329                 location16 =
330                     (uint16_t *) (sechdrs[sechdrs[relsec].sh_info].sh_addr +
331                                   rel[i].r_offset);
332                 location32 = (uint32_t *) location16;
333                 /* This is the symbol it is referring to. Note that all
334                    undefined symbols have been resolved. */
335                 sym = (Elf32_Sym *) sechdrs[symindex].sh_addr
336                     + ELF32_R_SYM(rel[i].r_info);
337                 if (is_reloc_stack_empty()) {
338                         value = sym->st_value;
339                 } else {
340                         value = reloc_stack_pop();
341                 }
342                 value += rel[i].r_addend;
343                 pr_debug("location is %x, value is %x type is %d \n",
344                          (unsigned int) location32, value,
345                          ELF32_R_TYPE(rel[i].r_info));
346
347                 switch (ELF32_R_TYPE(rel[i].r_info)) {
348
349                 case R_pcrel24:
350                 case R_pcrel24_jump_l:
351                         /* Add the value, subtract its postition */
352                         location16 =
353                             (uint16_t *) (sechdrs[sechdrs[relsec].sh_info].
354                                           sh_addr + rel[i].r_offset - 2);
355                         location32 = (uint32_t *) location16;
356                         value -= (uint32_t) location32;
357                         value >>= 1;
358                         pr_debug("value is %x, before %x-%x after %x-%x\n", value,
359                                *location16, *(location16 + 1),
360                                (*location16 & 0xff00) | (value >> 16 & 0x00ff),
361                                value & 0xffff);
362                         *location16 =
363                             (*location16 & 0xff00) | (value >> 16 & 0x00ff);
364                         *(location16 + 1) = value & 0xffff;
365                         break;
366                 case R_pcrel12_jump:
367                 case R_pcrel12_jump_s:
368                         value -= (uint32_t) location32;
369                         value >>= 1;
370                         *location16 = (value & 0xfff);
371                         break;
372                 case R_pcrel10:
373                         value -= (uint32_t) location32;
374                         value >>= 1;
375                         *location16 = (value & 0x3ff);
376                         break;
377                 case R_luimm16:
378                         pr_debug("before %x after %x\n", *location16,
379                                        (value & 0xffff));
380                         tmp = (value & 0xffff);
381                         if ((unsigned long)location16 >= L1_CODE_START) {
382                                 dma_memcpy(location16, &tmp, 2);
383                         } else
384                                 *location16 = tmp;
385                         break;
386                 case R_huimm16:
387                         pr_debug("before %x after %x\n", *location16,
388                                        ((value >> 16) & 0xffff));
389                         tmp = ((value >> 16) & 0xffff);
390                         if ((unsigned long)location16 >= L1_CODE_START) {
391                                 dma_memcpy(location16, &tmp, 2);
392                         } else
393                                 *location16 = tmp;
394                         break;
395                 case R_rimm16:
396                         *location16 = (value & 0xffff);
397                         break;
398                 case R_byte4_data:
399                         pr_debug("before %x after %x\n", *location32, value);
400                         *location32 = value;
401                         break;
402                 case R_push:
403                         reloc_stack_push(value);
404                         break;
405                 case R_const:
406                         reloc_stack_push(rel[i].r_addend);
407                         break;
408                 case R_add:
409                 case R_sub:
410                 case R_mult:
411                 case R_div:
412                 case R_mod:
413                 case R_lshift:
414                 case R_rshift:
415                 case R_and:
416                 case R_or:
417                 case R_xor:
418                 case R_land:
419                 case R_lor:
420                 case R_neg:
421                 case R_comp:
422                         reloc_stack_operate(ELF32_R_TYPE(rel[i].r_info), mod);
423                         break;
424                 default:
425                         printk(KERN_ERR "module %s: Unknown relocation: %u\n",
426                                mod->name, ELF32_R_TYPE(rel[i].r_info));
427                         return -ENOEXEC;
428                 }
429         }
430         return 0;
431 }
432
433 int
434 module_finalize(const Elf_Ehdr * hdr,
435                 const Elf_Shdr * sechdrs, struct module *mod)
436 {
437         unsigned int i, strindex = 0, symindex = 0;
438         char *secstrings;
439
440         secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
441
442         for (i = 1; i < hdr->e_shnum; i++) {
443                 /* Internal symbols and strings. */
444                 if (sechdrs[i].sh_type == SHT_SYMTAB) {
445                         symindex = i;
446                         strindex = sechdrs[i].sh_link;
447                 }
448         }
449
450         for (i = 1; i < hdr->e_shnum; i++) {
451                 const char *strtab = (char *)sechdrs[strindex].sh_addr;
452                 unsigned int info = sechdrs[i].sh_info;
453
454                 /* Not a valid relocation section? */
455                 if (info >= hdr->e_shnum)
456                         continue;
457
458                 if ((sechdrs[i].sh_type == SHT_RELA) &&
459                     ((strcmp(".rela.l2.text", secstrings + sechdrs[i].sh_name) == 0) ||
460                     (strcmp(".rela.l1.text", secstrings + sechdrs[i].sh_name) == 0) ||
461                     ((strcmp(".rela.text", secstrings + sechdrs[i].sh_name) == 0) &&
462                         (hdr->e_flags & (EF_BFIN_CODE_IN_L1|EF_BFIN_CODE_IN_L2))))) {
463                         apply_relocate_add((Elf_Shdr *) sechdrs, strtab,
464                                            symindex, i, mod);
465                 }
466         }
467         return 0;
468 }
469
470 void module_arch_cleanup(struct module *mod)
471 {
472         l1_inst_sram_free(mod->arch.text_l1);
473         l1_data_A_sram_free(mod->arch.data_a_l1);
474         l1_data_A_sram_free(mod->arch.bss_a_l1);
475         l1_data_B_sram_free(mod->arch.data_b_l1);
476         l1_data_B_sram_free(mod->arch.bss_b_l1);
477         l2_sram_free(mod->arch.text_l2);
478         l2_sram_free(mod->arch.data_l2);
479         l2_sram_free(mod->arch.bss_l2);
480 }