drivers/firmware/efi/libstub/arm32-stub.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2013 Linaro Ltd;  <roy.franz@linaro.org>
   4  */
   5 #include <linux/efi.h>
   6 #include <asm/efi.h>
   7
   8 #include "efistub.h"
   9
  10 static efi_guid_t cpu_state_guid = LINUX_EFI_ARM_CPU_STATE_TABLE_GUID;
  11
  12 struct efi_arm_entry_state *efi_entry_state;
  13
  14 static void get_cpu_state(u32 *cpsr, u32 *sctlr)
  15 {
  16         asm("mrs %0, cpsr" : "=r"(*cpsr));
  17         if ((*cpsr & MODE_MASK) == HYP_MODE)
  18                 asm("mrc p15, 4, %0, c1, c0, 0" : "=r"(*sctlr));
  19         else
  20                 asm("mrc p15, 0, %0, c1, c0, 0" : "=r"(*sctlr));
  21 }
  22
  23 efi_status_t check_platform_features(void)
  24 {
  25         efi_status_t status;
  26         u32 cpsr, sctlr;
  27         int block;
  28
  29         get_cpu_state(&cpsr, &sctlr);
  30
  31         efi_info("Entering in %s mode with MMU %sabled\n",
  32                  ((cpsr & MODE_MASK) == HYP_MODE) ? "HYP" : "SVC",
  33                  (sctlr & 1) ? "en" : "dis");
  34
  35         status = efi_bs_call(allocate_pool, EFI_LOADER_DATA,
  36                              sizeof(*efi_entry_state),
  37                              (void **)&efi_entry_state);
  38         if (status != EFI_SUCCESS) {
  39                 efi_err("allocate_pool() failed\n");
  40                 return status;
  41         }
  42
  43         efi_entry_state->cpsr_before_ebs = cpsr;
  44         efi_entry_state->sctlr_before_ebs = sctlr;
  45
  46         status = efi_bs_call(install_configuration_table, &cpu_state_guid,
  47                              efi_entry_state);
  48         if (status != EFI_SUCCESS) {
  49                 efi_err("install_configuration_table() failed\n");
  50                 goto free_state;
  51         }
  52
  53         /* non-LPAE kernels can run anywhere */
  54         if (!IS_ENABLED(CONFIG_ARM_LPAE))
  55                 return EFI_SUCCESS;
  56
  57         /* LPAE kernels need compatible hardware */
  58         block = cpuid_feature_extract(CPUID_EXT_MMFR0, 0);
  59         if (block < 5) {
  60                 efi_err("This LPAE kernel is not supported by your CPU\n");
  61                 status = EFI_UNSUPPORTED;
  62                 goto drop_table;
  63         }
  64         return EFI_SUCCESS;
  65
  66 drop_table:
  67         efi_bs_call(install_configuration_table, &cpu_state_guid, NULL);
  68 free_state:
  69         efi_bs_call(free_pool, efi_entry_state);
  70         return status;
  71 }
  72
  73 void efi_handle_post_ebs_state(void)
  74 {
  75         get_cpu_state(&efi_entry_state->cpsr_after_ebs,
  76                       &efi_entry_state->sctlr_after_ebs);
  77 }
  78
  79 efi_status_t handle_kernel_image(unsigned long *image_addr,
  80                                  unsigned long *image_size,
  81                                  unsigned long *reserve_addr,
  82                                  unsigned long *reserve_size,
  83                                  efi_loaded_image_t *image,
  84                                  efi_handle_t image_handle)
  85 {
  86         const int slack = TEXT_OFFSET - 5 * PAGE_SIZE;
  87         int alloc_size = MAX_UNCOMP_KERNEL_SIZE + EFI_PHYS_ALIGN;
  88         unsigned long alloc_base, kernel_base;
  89         efi_status_t status;
  90
  91         /*
  92          * Allocate space for the decompressed kernel as low as possible.
  93          * The region should be 16 MiB aligned, but the first 'slack' bytes
  94          * are not used by Linux, so we allow those to be occupied by the
  95          * firmware.
  96          */
  97         status = efi_low_alloc_above(alloc_size, EFI_PAGE_SIZE, &alloc_base, 0x0);
  98         if (status != EFI_SUCCESS) {
  99                 efi_err("Unable to allocate memory for uncompressed kernel.\n");
 100                 return status;
 101         }
 102
 103         if ((alloc_base % EFI_PHYS_ALIGN) > slack) {
 104                 /*
 105                  * More than 'slack' bytes are already occupied at the base of
 106                  * the allocation, so we need to advance to the next 16 MiB block.
 107                  */
 108                 kernel_base = round_up(alloc_base, EFI_PHYS_ALIGN);
 109                 efi_info("Free memory starts at 0x%lx, setting kernel_base to 0x%lx\n",
 110                          alloc_base, kernel_base);
 111         } else {
 112                 kernel_base = round_down(alloc_base, EFI_PHYS_ALIGN);
 113         }
 114
 115         *reserve_addr = kernel_base + slack;
 116         *reserve_size = MAX_UNCOMP_KERNEL_SIZE;
 117
 118         /* now free the parts that we will not use */
 119         if (*reserve_addr > alloc_base) {
 120                 efi_bs_call(free_pages, alloc_base,
 121                             (*reserve_addr - alloc_base) / EFI_PAGE_SIZE);
 122                 alloc_size -= *reserve_addr - alloc_base;
 123         }
 124         efi_bs_call(free_pages, *reserve_addr + MAX_UNCOMP_KERNEL_SIZE,
 125                     (alloc_size - MAX_UNCOMP_KERNEL_SIZE) / EFI_PAGE_SIZE);
 126
 127         *image_addr = kernel_base + TEXT_OFFSET;
 128         *image_size = 0;
 129
 130         efi_debug("image addr == 0x%lx, reserve_addr == 0x%lx\n",
 131                   *image_addr, *reserve_addr);
 132
 133         return EFI_SUCCESS;
 134 }