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 #define pr_fmt(fmt) "module %s: " fmt
  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>
  40 #include <asm/uaccess.h>
  41
  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
  57 module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
  58                           char *secstrings, struct module *mod)
  59 {
  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          */
  67         Elf_Shdr *s, *sechdrs_end = sechdrs + hdr->e_shnum;
  68         void *dest;
  69
  70         for (s = sechdrs; s < sechdrs_end; ++s) {
  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
  80                         dest = l1_inst_sram_alloc(s->sh_size);
  81                         mod->arch.text_l1 = dest;
  82                         if (dest == NULL) {
  83                                 pr_err("L1 inst memory allocation failed\n",
  84                                         mod->name);
  85                                 return -1;
  86                         }
  87                         dma_memcpy(dest, (void *)s->sh_addr, s->sh_size);
  88
  89                 } else if (!strcmp(".l1.data", shname) ||
  90                            (!strcmp(".data", shname) &&
  91                             (hdr->e_flags & EF_BFIN_DATA_IN_L1))) {
  92
  93                         dest = l1_data_sram_alloc(s->sh_size);
  94                         mod->arch.data_a_l1 = dest;
  95                         if (dest == NULL) {
  96                                 pr_err("L1 data memory allocation failed\n",
  97                                         mod->name);
  98                                 return -1;
  99                         }
 100                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
 101
 102                 } else if (!strcmp(".l1.bss", shname) ||
 103                            (!strcmp(".bss", shname) &&
 104                             (hdr->e_flags & EF_BFIN_DATA_IN_L1))) {
 105
 106                         dest = l1_data_sram_zalloc(s->sh_size);
 107                         mod->arch.bss_a_l1 = dest;
 108                         if (dest == NULL) {
 109                                 pr_err("L1 data memory allocation failed\n",
 110                                         mod->name);
 111                                 return -1;
 112                         }
 113
 114                 } else if (!strcmp(".l1.data.B", shname)) {
 115
 116                         dest = l1_data_B_sram_alloc(s->sh_size);
 117                         mod->arch.data_b_l1 = dest;
 118                         if (dest == NULL) {
 119                                 pr_err("L1 data memory allocation failed\n",
 120                                         mod->name);
 121                                 return -1;
 122                         }
 123                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
 124
 125                 } else if (!strcmp(".l1.bss.B", shname)) {
 126
 127                         dest = l1_data_B_sram_alloc(s->sh_size);
 128                         mod->arch.bss_b_l1 = dest;
 129                         if (dest == NULL) {
 130                                 pr_err("L1 data memory allocation failed\n",
 131                                         mod->name);
 132                                 return -1;
 133                         }
 134                         memset(dest, 0, s->sh_size);
 135
 136                 } else if (!strcmp(".l2.text", shname) ||
 137                            (!strcmp(".text", shname) &&
 138                             (hdr->e_flags & EF_BFIN_CODE_IN_L2))) {
 139
 140                         dest = l2_sram_alloc(s->sh_size);
 141                         mod->arch.text_l2 = dest;
 142                         if (dest == NULL) {
 143                                 pr_err("L2 SRAM allocation failed\n",
 144                                         mod->name);
 145                                 return -1;
 146                         }
 147                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
 148
 149                 } else if (!strcmp(".l2.data", shname) ||
 150                            (!strcmp(".data", shname) &&
 151                             (hdr->e_flags & EF_BFIN_DATA_IN_L2))) {
 152
 153                         dest = l2_sram_alloc(s->sh_size);
 154                         mod->arch.data_l2 = dest;
 155                         if (dest == NULL) {
 156                                 pr_err("L2 SRAM allocation failed\n",
 157                                         mod->name);
 158                                 return -1;
 159                         }
 160                         memcpy(dest, (void *)s->sh_addr, s->sh_size);
 161
 162                 } else if (!strcmp(".l2.bss", shname) ||
 163                            (!strcmp(".bss", shname) &&
 164                             (hdr->e_flags & EF_BFIN_DATA_IN_L2))) {
 165
 166                         dest = l2_sram_zalloc(s->sh_size);
 167                         mod->arch.bss_l2 = dest;
 168                         if (dest == NULL) {
 169                                 pr_err("L2 SRAM allocation failed\n",
 170                                         mod->name);
 171                                 return -1;
 172                         }
 173
 174                 } else
 175                         continue;
 176
 177                 s->sh_flags &= ~SHF_ALLOC;
 178                 s->sh_addr = (unsigned long)dest;
 179         }
 180
 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 {
 188         pr_err(".rel unsupported\n", me->name);
 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.                                                   */
 199 /*            R_BFIN_BYTE and R_BFIN_BYTE2 are also not handled as the   */
 200 /*            gas does not generate it.                                  */
 201 /*************************************************************************/
 202 int
 203 apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
 204                    unsigned int symindex, unsigned int relsec,
 205                    struct module *mod)
 206 {
 207         unsigned int i;
 208         Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr;
 209         Elf32_Sym *sym;
 210         unsigned long location, value, size;
 211
 212         pr_debug("applying relocate section %u to %u\n", mod->name,
 213                 relsec, sechdrs[relsec].sh_info);
 214
 215         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
 216                 /* This is where to make the change */
 217                 location = sechdrs[sechdrs[relsec].sh_info].sh_addr +
 218                            rel[i].r_offset;
 219
 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);
 224                 value = sym->st_value;
 225                 value += rel[i].r_addend;
 226
 227 #ifdef CONFIG_SMP
 228                 if (location >= COREB_L1_DATA_A_START) {
 229                         pr_err("cannot relocate in L1: %u (SMP kernel)",
 230                                 mod->name, ELF32_R_TYPE(rel[i].r_info));
 231                         return -ENOEXEC;
 232                 }
 233 #endif
 234
 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));
 237
 238                 switch (ELF32_R_TYPE(rel[i].r_info)) {
 239
 240                 case R_BFIN_HUIMM16:
 241                         value >>= 16;
 242                 case R_BFIN_LUIMM16:
 243                 case R_BFIN_RIMM16:
 244                         size = 2;
 245                         break;
 246                 case R_BFIN_BYTE4_DATA:
 247                         size = 4;
 248                         break;
 249
 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:
 255                         pr_err("unsupported relocation: %u (no -mlong-calls?)\n",
 256                                 mod->name, ELF32_R_TYPE(rel[i].r_info));
 257                         return -ENOEXEC;
 258
 259                 default:
 260                         pr_err("unknown relocation: %u\n", mod->name,
 261                                 ELF32_R_TYPE(rel[i].r_info));
 262                         return -ENOEXEC;
 263                 }
 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                 }
 281         }
 282
 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;
 292         long err = 0;
 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;
 307                 const char *shname = secstrings + sechdrs[i].sh_name;
 308
 309                 /* Not a valid relocation section? */
 310                 if (info >= hdr->e_shnum)
 311                         continue;
 312
 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
 322                         err = apply_relocate_add((Elf_Shdr *) sechdrs, strtab,
 323                                            symindex, i, mod);
 324                         if (err < 0)
 325                                 return -ENOEXEC;
 326                 }
 327         }
 328
 329         return 0;
 330 }
 331
 332 void module_arch_cleanup(struct module *mod)
 333 {
 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);
 342 }