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 }