LXR uboot/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#include <linux/bitops.h>
  35
  36/**
  37 * read_uint() - Read an unsigned integer from the buffer
  38 * @buf: pointer to a pointer to the reloc buffer
  39 *
  40 * Read one whole unsigned integer from the relocation data pointed to by @buf,
  41 * advancing @buf past the bytes encoding the integer.
  42 *
  43 * Returns: the integer read from @buf
  44 */
  45static unsigned long read_uint(uint8_t **buf)
  46{
  47        unsigned long val = 0;
  48        unsigned int shift = 0;
  49        uint8_t new;
  50
  51        do {
  52                new = *(*buf)++;
  53                val |= (new & 0x7f) << shift;
  54                shift += 7;
  55        } while (new & 0x80);
  56
  57        return val;
  58}
  59
  60/**
  61 * apply_reloc() - Apply a single relocation
  62 * @type: the type of reloc (R_MIPS_*)
  63 * @addr: the address that the reloc should be applied to
  64 * @off: the relocation offset, ie. number of bytes we're moving U-Boot by
  65 *
  66 * Apply a single relocation of type @type at @addr. This function is
  67 * intentionally simple, and does the bare minimum needed to fixup the
  68 * relocated U-Boot - in particular, it does not check for overflows.
  69 */
  70static void apply_reloc(unsigned int type, void *addr, long off, uint8_t *buf)
  71{
  72        uint32_t u32;
  73
  74        switch (type) {
  75        case R_MIPS_26:
  76                u32 = *(uint32_t *)addr;
  77                u32 = (u32 & GENMASK(31, 26)) |
  78                      ((u32 + (off >> 2)) & GENMASK(25, 0));
  79                *(uint32_t *)addr = u32;
  80                break;
  81
  82        case R_MIPS_32:
  83                *(uint32_t *)addr += off;
  84                break;
  85
  86        case R_MIPS_64:
  87                *(uint64_t *)addr += off;
  88                break;
  89
  90        case R_MIPS_HI16:
  91                *(uint32_t *)addr += off >> 16;
  92                break;
  93
  94        default:
  95                panic("Unhandled reloc type %u (@ %p), bss used before relocation?\n",
  96                      type, buf);
  97        }
  98}
  99
 100/**
 101 * relocate_code() - Relocate U-Boot, generally from flash to DDR
 102 * @start_addr_sp: new stack pointer
 103 * @new_gd: pointer to relocated global data
 104 * @relocaddr: the address to relocate to
 105 *
 106 * Relocate U-Boot from its current location (generally in flash) to a new one
 107 * (generally in DDR). This function will copy the U-Boot binary & apply
 108 * relocations as necessary, then jump to board_init_r in the new build of
 109 * U-Boot. As such, this function does not return.
 110 */
 111void relocate_code(ulong start_addr_sp, gd_t *new_gd, ulong relocaddr)
 112{
 113        unsigned long addr, length, bss_len;
 114        uint8_t *buf, *bss_start;
 115        unsigned int type;
 116        long off;
 117
 118        /*
 119         * Ensure that we're relocating by an offset which is a multiple of
 120         * 64KiB, ie. doesn't change the least significant 16 bits of any
 121         * addresses. This allows us to discard R_MIPS_LO16 relocs, saving
 122         * space in the U-Boot binary & complexity in handling them.
 123         */
 124        off = relocaddr - (unsigned long)__text_start;
 125        if (off & 0xffff)
 126                panic("Mis-aligned relocation\n");
 127
 128        /* Copy U-Boot to RAM */
 129        length = __image_copy_end - __text_start;
 130        memcpy((void *)relocaddr, __text_start, length);
 131
 132        /* Now apply relocations to the copy in RAM */
 133        buf = __rel_start;
 134        addr = relocaddr;
 135        while (true) {
 136                type = read_uint(&buf);
 137                if (type == R_MIPS_NONE)
 138                        break;
 139
 140                addr += read_uint(&buf) << 2;
 141                apply_reloc(type, (void *)addr, off, buf);
 142        }
 143
 144        /* Ensure the icache is coherent */
 145        flush_cache(relocaddr, length);
 146
 147        /* Clear the .bss section */
 148        bss_start = (uint8_t *)((unsigned long)__bss_start + off);
 149        bss_len = (unsigned long)&__bss_end - (unsigned long)__bss_start;
 150        memset(bss_start, 0, bss_len);
 151
 152        /* Jump to the relocated U-Boot */
 153        asm volatile(
 154                       "move    $29, %0\n"
 155                "       move    $4, %1\n"
 156                "       move    $5, %2\n"
 157                "       move    $31, $0\n"
 158                "       jr      %3"
 159                : /* no outputs */
 160                : "r"(start_addr_sp),
 161                  "r"(new_gd),
 162                  "r"(relocaddr),
 163                  "r"((unsigned long)board_init_r + off));
 164
 165        /* Since we jumped to the new U-Boot above, we won't get here */
 166        unreachable();
 167}
 168