arch/mips/lib/reloc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * MIPS Relocation
   4  *
   5  * Copyright (c) 2017 Imagination Technologies Ltd.
   6  *
   7  * Relocation data, found in the .rel section, is generated by the mips-relocs
   8  * tool & contains a record of all locations in the U-Boot binary that need to
   9  * be fixed up during relocation.
  10  *
  11  * The data is a sequence of unsigned integers, which are of somewhat arbitrary
  12  * size. This is achieved by encoding integers as a sequence of bytes, each of
  13  * which contains 7 bits of data with the most significant bit indicating
  14  * whether any further bytes need to be read. The least significant bits of the
  15  * integer are found in the first byte - ie. it somewhat resembles little
  16  * endian.
  17  *
  18  * Each pair of two integers represents a relocation that must be applied. The
  19  * first integer represents the type of relocation as a standard ELF relocation
  20  * type (ie. R_MIPS_*). The second integer represents the offset at which to
  21  * apply the relocation, relative to the previous relocation or for the first
  22  * relocation the start of the relocated .text section.
  23  *
  24  * The end of the relocation data is indicated when type R_MIPS_NONE (0) is
  25  * read, at which point no further integers should be read. That is, the
  26  * terminating R_MIPS_NONE reloc includes no offset.
  27  */
  28
  29 #include <common.h>
  30 #include <cpu_func.h>
  31 #include <init.h>
  32 #include <asm/relocs.h>
  33 #include <asm/sections.h>
  34
  35 /**
  36  * read_uint() - Read an unsigned integer from the buffer
  37  * @buf: pointer to a pointer to the reloc buffer
  38  *
  39  * Read one whole unsigned integer from the relocation data pointed to by @buf,
  40  * advancing @buf past the bytes encoding the integer.
  41  *
  42  * Returns: the integer read from @buf
  43  */
  44 static unsigned long read_uint(uint8_t **buf)
  45 {
  46         unsigned long val = 0;
  47         unsigned int shift = 0;
  48         uint8_t new;
  49
  50         do {
  51                 new = *(*buf)++;
  52                 val |= (new & 0x7f) << shift;
  53                 shift += 7;
  54         } while (new & 0x80);
  55
  56         return val;
  57 }
  58
  59 /**
  60  * apply_reloc() - Apply a single relocation
  61  * @type: the type of reloc (R_MIPS_*)
  62  * @addr: the address that the reloc should be applied to
  63  * @off: the relocation offset, ie. number of bytes we're moving U-Boot by
  64  *
  65  * Apply a single relocation of type @type at @addr. This function is
  66  * intentionally simple, and does the bare minimum needed to fixup the
  67  * relocated U-Boot - in particular, it does not check for overflows.
  68  */
  69 static void apply_reloc(unsigned int type, void *addr, long off)
  70 {
  71         uint32_t u32;
  72
  73         switch (type) {
  74         case R_MIPS_26:
  75                 u32 = *(uint32_t *)addr;
  76                 u32 = (u32 & GENMASK(31, 26)) |
  77                       ((u32 + (off >> 2)) & GENMASK(25, 0));
  78                 *(uint32_t *)addr = u32;
  79                 break;
  80
  81         case R_MIPS_32:
  82                 *(uint32_t *)addr += off;
  83                 break;
  84
  85         case R_MIPS_64:
  86                 *(uint64_t *)addr += off;
  87                 break;
  88
  89         case R_MIPS_HI16:
  90                 *(uint32_t *)addr += off >> 16;
  91                 break;
  92
  93         default:
  94                 panic("Unhandled reloc type %u\n", type);
  95         }
  96 }
  97
  98 /**
  99  * relocate_code() - Relocate U-Boot, generally from flash to DDR
 100  * @start_addr_sp: new stack pointer
 101  * @new_gd: pointer to relocated global data
 102  * @relocaddr: the address to relocate to
 103  *
 104  * Relocate U-Boot from its current location (generally in flash) to a new one
 105  * (generally in DDR). This function will copy the U-Boot binary & apply
 106  * relocations as necessary, then jump to board_init_r in the new build of
 107  * U-Boot. As such, this function does not return.
 108  */
 109 void relocate_code(ulong start_addr_sp, gd_t *new_gd, ulong relocaddr)
 110 {
 111         unsigned long addr, length, bss_len;
 112         uint8_t *buf, *bss_start;
 113         unsigned int type;
 114         long off;
 115
 116         /*
 117          * Ensure that we're relocating by an offset which is a multiple of
 118          * 64KiB, ie. doesn't change the least significant 16 bits of any
 119          * addresses. This allows us to discard R_MIPS_LO16 relocs, saving
 120          * space in the U-Boot binary & complexity in handling them.
 121          */
 122         off = relocaddr - (unsigned long)__text_start;
 123         if (off & 0xffff)
 124                 panic("Mis-aligned relocation\n");
 125
 126         /* Copy U-Boot to RAM */
 127         length = __image_copy_end - __text_start;
 128         memcpy((void *)relocaddr, __text_start, length);
 129
 130         /* Now apply relocations to the copy in RAM */
 131         buf = __rel_start;
 132         addr = relocaddr;
 133         while (true) {
 134                 type = read_uint(&buf);
 135                 if (type == R_MIPS_NONE)
 136                         break;
 137
 138                 addr += read_uint(&buf) << 2;
 139                 apply_reloc(type, (void *)addr, off);
 140         }
 141
 142         /* Ensure the icache is coherent */
 143         flush_cache(relocaddr, length);
 144
 145         /* Clear the .bss section */
 146         bss_start = (uint8_t *)((unsigned long)__bss_start + off);
 147         bss_len = (unsigned long)&__bss_end - (unsigned long)__bss_start;
 148         memset(bss_start, 0, bss_len);
 149
 150         /* Jump to the relocated U-Boot */
 151         asm volatile(
 152                        "move    $29, %0\n"
 153                 "       move    $4, %1\n"
 154                 "       move    $5, %2\n"
 155                 "       move    $31, $0\n"
 156                 "       jr      %3"
 157                 : /* no outputs */
 158                 : "r"(start_addr_sp),
 159                   "r"(new_gd),
 160                   "r"(relocaddr),
 161                   "r"((unsigned long)board_init_r + off));
 162
 163         /* Since we jumped to the new U-Boot above, we won't get here */
 164         unreachable();
 165 }