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
get_cpu_state(u32 * cpsr,u32 * sctlr)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
check_platform_features(void)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
efi_handle_post_ebs_state(void)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 static efi_guid_t screen_info_guid = LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID;
80
alloc_screen_info(void)81 struct screen_info *alloc_screen_info(void)
82 {
83 struct screen_info *si;
84 efi_status_t status;
85
86 /*
87 * Unlike on arm64, where we can directly fill out the screen_info
88 * structure from the stub, we need to allocate a buffer to hold
89 * its contents while we hand over to the kernel proper from the
90 * decompressor.
91 */
92 status = efi_bs_call(allocate_pool, EFI_RUNTIME_SERVICES_DATA,
93 sizeof(*si), (void **)&si);
94
95 if (status != EFI_SUCCESS)
96 return NULL;
97
98 status = efi_bs_call(install_configuration_table,
99 &screen_info_guid, si);
100 if (status == EFI_SUCCESS)
101 return si;
102
103 efi_bs_call(free_pool, si);
104 return NULL;
105 }
106
free_screen_info(struct screen_info * si)107 void free_screen_info(struct screen_info *si)
108 {
109 if (!si)
110 return;
111
112 efi_bs_call(install_configuration_table, &screen_info_guid, NULL);
113 efi_bs_call(free_pool, si);
114 }
115
handle_kernel_image(unsigned long * image_addr,unsigned long * image_size,unsigned long * reserve_addr,unsigned long * reserve_size,efi_loaded_image_t * image)116 efi_status_t handle_kernel_image(unsigned long *image_addr,
117 unsigned long *image_size,
118 unsigned long *reserve_addr,
119 unsigned long *reserve_size,
120 efi_loaded_image_t *image)
121 {
122 const int slack = TEXT_OFFSET - 5 * PAGE_SIZE;
123 int alloc_size = MAX_UNCOMP_KERNEL_SIZE + EFI_PHYS_ALIGN;
124 unsigned long alloc_base, kernel_base;
125 efi_status_t status;
126
127 /*
128 * Allocate space for the decompressed kernel as low as possible.
129 * The region should be 16 MiB aligned, but the first 'slack' bytes
130 * are not used by Linux, so we allow those to be occupied by the
131 * firmware.
132 */
133 status = efi_low_alloc_above(alloc_size, EFI_PAGE_SIZE, &alloc_base, 0x0);
134 if (status != EFI_SUCCESS) {
135 efi_err("Unable to allocate memory for uncompressed kernel.\n");
136 return status;
137 }
138
139 if ((alloc_base % EFI_PHYS_ALIGN) > slack) {
140 /*
141 * More than 'slack' bytes are already occupied at the base of
142 * the allocation, so we need to advance to the next 16 MiB block.
143 */
144 kernel_base = round_up(alloc_base, EFI_PHYS_ALIGN);
145 efi_info("Free memory starts at 0x%lx, setting kernel_base to 0x%lx\n",
146 alloc_base, kernel_base);
147 } else {
148 kernel_base = round_down(alloc_base, EFI_PHYS_ALIGN);
149 }
150
151 *reserve_addr = kernel_base + slack;
152 *reserve_size = MAX_UNCOMP_KERNEL_SIZE;
153
154 /* now free the parts that we will not use */
155 if (*reserve_addr > alloc_base) {
156 efi_bs_call(free_pages, alloc_base,
157 (*reserve_addr - alloc_base) / EFI_PAGE_SIZE);
158 alloc_size -= *reserve_addr - alloc_base;
159 }
160 efi_bs_call(free_pages, *reserve_addr + MAX_UNCOMP_KERNEL_SIZE,
161 (alloc_size - MAX_UNCOMP_KERNEL_SIZE) / EFI_PAGE_SIZE);
162
163 *image_addr = kernel_base + TEXT_OFFSET;
164 *image_size = 0;
165
166 efi_debug("image addr == 0x%lx, reserve_addr == 0x%lx\n",
167 *image_addr, *reserve_addr);
168
169 return EFI_SUCCESS;
170 }
171