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 } 135