Linux Audio

Check our new training course

Loading...
v5.9
  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
 10static efi_guid_t cpu_state_guid = LINUX_EFI_ARM_CPU_STATE_TABLE_GUID;
 11
 12struct efi_arm_entry_state *efi_entry_state;
 13
 14static 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
 23efi_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
 66drop_table:
 67	efi_bs_call(install_configuration_table, &cpu_state_guid, NULL);
 68free_state:
 69	efi_bs_call(free_pool, efi_entry_state);
 70	return status;
 71}
 72
 73void 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
 79static efi_guid_t screen_info_guid = LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID;
 80
 81struct 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
107void 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
116static efi_status_t reserve_kernel_base(unsigned long dram_base,
 
117					unsigned long *reserve_addr,
118					unsigned long *reserve_size)
119{
120	efi_physical_addr_t alloc_addr;
121	efi_memory_desc_t *memory_map;
122	unsigned long nr_pages, map_size, desc_size, buff_size;
123	efi_status_t status;
124	unsigned long l;
125
126	struct efi_boot_memmap map = {
127		.map		= &memory_map,
128		.map_size	= &map_size,
129		.desc_size	= &desc_size,
130		.desc_ver	= NULL,
131		.key_ptr	= NULL,
132		.buff_size	= &buff_size,
133	};
134
135	/*
136	 * Reserve memory for the uncompressed kernel image. This is
137	 * all that prevents any future allocations from conflicting
138	 * with the kernel. Since we can't tell from the compressed
139	 * image how much DRAM the kernel actually uses (due to BSS
140	 * size uncertainty) we allocate the maximum possible size.
141	 * Do this very early, as prints can cause memory allocations
142	 * that may conflict with this.
143	 */
144	alloc_addr = dram_base + MAX_UNCOMP_KERNEL_SIZE;
145	nr_pages = MAX_UNCOMP_KERNEL_SIZE / EFI_PAGE_SIZE;
146	status = efi_bs_call(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS,
147			     EFI_BOOT_SERVICES_DATA, nr_pages, &alloc_addr);
148	if (status == EFI_SUCCESS) {
149		if (alloc_addr == dram_base) {
150			*reserve_addr = alloc_addr;
151			*reserve_size = MAX_UNCOMP_KERNEL_SIZE;
152			return EFI_SUCCESS;
153		}
154		/*
155		 * If we end up here, the allocation succeeded but starts below
156		 * dram_base. This can only occur if the real base of DRAM is
157		 * not a multiple of 128 MB, in which case dram_base will have
158		 * been rounded up. Since this implies that a part of the region
159		 * was already occupied, we need to fall through to the code
160		 * below to ensure that the existing allocations don't conflict.
161		 * For this reason, we use EFI_BOOT_SERVICES_DATA above and not
162		 * EFI_LOADER_DATA, which we wouldn't able to distinguish from
163		 * allocations that we want to disallow.
164		 */
165	}
166
167	/*
168	 * If the allocation above failed, we may still be able to proceed:
169	 * if the only allocations in the region are of types that will be
170	 * released to the OS after ExitBootServices(), the decompressor can
171	 * safely overwrite them.
172	 */
173	status = efi_get_memory_map(&map);
174	if (status != EFI_SUCCESS) {
175		efi_err("reserve_kernel_base(): Unable to retrieve memory map.\n");
 
176		return status;
177	}
178
179	for (l = 0; l < map_size; l += desc_size) {
180		efi_memory_desc_t *desc;
181		u64 start, end;
182
183		desc = (void *)memory_map + l;
184		start = desc->phys_addr;
185		end = start + desc->num_pages * EFI_PAGE_SIZE;
186
187		/* Skip if entry does not intersect with region */
188		if (start >= dram_base + MAX_UNCOMP_KERNEL_SIZE ||
189		    end <= dram_base)
190			continue;
191
192		switch (desc->type) {
193		case EFI_BOOT_SERVICES_CODE:
194		case EFI_BOOT_SERVICES_DATA:
195			/* Ignore types that are released to the OS anyway */
196			continue;
197
198		case EFI_CONVENTIONAL_MEMORY:
199			/* Skip soft reserved conventional memory */
200			if (efi_soft_reserve_enabled() &&
201			    (desc->attribute & EFI_MEMORY_SP))
202				continue;
203
204			/*
205			 * Reserve the intersection between this entry and the
206			 * region.
207			 */
208			start = max(start, (u64)dram_base);
209			end = min(end, (u64)dram_base + MAX_UNCOMP_KERNEL_SIZE);
210
211			status = efi_bs_call(allocate_pages,
212					     EFI_ALLOCATE_ADDRESS,
213					     EFI_LOADER_DATA,
214					     (end - start) / EFI_PAGE_SIZE,
215					     &start);
216			if (status != EFI_SUCCESS) {
217				efi_err("reserve_kernel_base(): alloc failed.\n");
 
218				goto out;
219			}
220			break;
221
222		case EFI_LOADER_CODE:
223		case EFI_LOADER_DATA:
224			/*
225			 * These regions may be released and reallocated for
226			 * another purpose (including EFI_RUNTIME_SERVICE_DATA)
227			 * at any time during the execution of the OS loader,
228			 * so we cannot consider them as safe.
229			 */
230		default:
231			/*
232			 * Treat any other allocation in the region as unsafe */
233			status = EFI_OUT_OF_RESOURCES;
234			goto out;
235		}
236	}
237
238	status = EFI_SUCCESS;
239out:
240	efi_bs_call(free_pool, memory_map);
241	return status;
242}
243
244efi_status_t handle_kernel_image(unsigned long *image_addr,
 
245				 unsigned long *image_size,
246				 unsigned long *reserve_addr,
247				 unsigned long *reserve_size,
248				 unsigned long dram_base,
249				 efi_loaded_image_t *image)
250{
251	unsigned long kernel_base;
252	efi_status_t status;
253
254	/* use a 16 MiB aligned base for the decompressed kernel */
255	kernel_base = round_up(dram_base, SZ_16M) + TEXT_OFFSET;
256
257	/*
258	 * Note that some platforms (notably, the Raspberry Pi 2) put
259	 * spin-tables and other pieces of firmware at the base of RAM,
260	 * abusing the fact that the window of TEXT_OFFSET bytes at the
261	 * base of the kernel image is only partially used at the moment.
262	 * (Up to 5 pages are used for the swapper page tables)
263	 */
264	status = reserve_kernel_base(kernel_base - 5 * PAGE_SIZE, reserve_addr,
 
 
265				     reserve_size);
266	if (status != EFI_SUCCESS) {
267		efi_err("Unable to allocate memory for uncompressed kernel.\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
268		return status;
269	}
270
271	*image_addr = kernel_base;
272	*image_size = 0;
 
 
 
 
 
 
 
 
 
 
 
273	return EFI_SUCCESS;
274}
v4.17
 
  1/*
  2 * Copyright (C) 2013 Linaro Ltd;  <roy.franz@linaro.org>
  3 *
  4 * This program is free software; you can redistribute it and/or modify
  5 * it under the terms of the GNU General Public License version 2 as
  6 * published by the Free Software Foundation.
  7 *
  8 */
  9#include <linux/efi.h>
 10#include <asm/efi.h>
 11
 12#include "efistub.h"
 13
 14efi_status_t check_platform_features(efi_system_table_t *sys_table_arg)
 
 
 
 
 
 
 
 
 
 
 
 
 
 15{
 
 
 16	int block;
 17
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 18	/* non-LPAE kernels can run anywhere */
 19	if (!IS_ENABLED(CONFIG_ARM_LPAE))
 20		return EFI_SUCCESS;
 21
 22	/* LPAE kernels need compatible hardware */
 23	block = cpuid_feature_extract(CPUID_EXT_MMFR0, 0);
 24	if (block < 5) {
 25		pr_efi_err(sys_table_arg, "This LPAE kernel is not supported by your CPU\n");
 26		return EFI_UNSUPPORTED;
 
 27	}
 28	return EFI_SUCCESS;
 
 
 
 
 
 
 
 
 
 
 
 
 29}
 30
 31static efi_guid_t screen_info_guid = LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID;
 32
 33struct screen_info *alloc_screen_info(efi_system_table_t *sys_table_arg)
 34{
 35	struct screen_info *si;
 36	efi_status_t status;
 37
 38	/*
 39	 * Unlike on arm64, where we can directly fill out the screen_info
 40	 * structure from the stub, we need to allocate a buffer to hold
 41	 * its contents while we hand over to the kernel proper from the
 42	 * decompressor.
 43	 */
 44	status = efi_call_early(allocate_pool, EFI_RUNTIME_SERVICES_DATA,
 45				sizeof(*si), (void **)&si);
 46
 47	if (status != EFI_SUCCESS)
 48		return NULL;
 49
 50	status = efi_call_early(install_configuration_table,
 51				&screen_info_guid, si);
 52	if (status == EFI_SUCCESS)
 53		return si;
 54
 55	efi_call_early(free_pool, si);
 56	return NULL;
 57}
 58
 59void free_screen_info(efi_system_table_t *sys_table_arg, struct screen_info *si)
 60{
 61	if (!si)
 62		return;
 63
 64	efi_call_early(install_configuration_table, &screen_info_guid, NULL);
 65	efi_call_early(free_pool, si);
 66}
 67
 68static efi_status_t reserve_kernel_base(efi_system_table_t *sys_table_arg,
 69					unsigned long dram_base,
 70					unsigned long *reserve_addr,
 71					unsigned long *reserve_size)
 72{
 73	efi_physical_addr_t alloc_addr;
 74	efi_memory_desc_t *memory_map;
 75	unsigned long nr_pages, map_size, desc_size, buff_size;
 76	efi_status_t status;
 77	unsigned long l;
 78
 79	struct efi_boot_memmap map = {
 80		.map		= &memory_map,
 81		.map_size	= &map_size,
 82		.desc_size	= &desc_size,
 83		.desc_ver	= NULL,
 84		.key_ptr	= NULL,
 85		.buff_size	= &buff_size,
 86	};
 87
 88	/*
 89	 * Reserve memory for the uncompressed kernel image. This is
 90	 * all that prevents any future allocations from conflicting
 91	 * with the kernel. Since we can't tell from the compressed
 92	 * image how much DRAM the kernel actually uses (due to BSS
 93	 * size uncertainty) we allocate the maximum possible size.
 94	 * Do this very early, as prints can cause memory allocations
 95	 * that may conflict with this.
 96	 */
 97	alloc_addr = dram_base + MAX_UNCOMP_KERNEL_SIZE;
 98	nr_pages = MAX_UNCOMP_KERNEL_SIZE / EFI_PAGE_SIZE;
 99	status = efi_call_early(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS,
100				EFI_BOOT_SERVICES_DATA, nr_pages, &alloc_addr);
101	if (status == EFI_SUCCESS) {
102		if (alloc_addr == dram_base) {
103			*reserve_addr = alloc_addr;
104			*reserve_size = MAX_UNCOMP_KERNEL_SIZE;
105			return EFI_SUCCESS;
106		}
107		/*
108		 * If we end up here, the allocation succeeded but starts below
109		 * dram_base. This can only occur if the real base of DRAM is
110		 * not a multiple of 128 MB, in which case dram_base will have
111		 * been rounded up. Since this implies that a part of the region
112		 * was already occupied, we need to fall through to the code
113		 * below to ensure that the existing allocations don't conflict.
114		 * For this reason, we use EFI_BOOT_SERVICES_DATA above and not
115		 * EFI_LOADER_DATA, which we wouldn't able to distinguish from
116		 * allocations that we want to disallow.
117		 */
118	}
119
120	/*
121	 * If the allocation above failed, we may still be able to proceed:
122	 * if the only allocations in the region are of types that will be
123	 * released to the OS after ExitBootServices(), the decompressor can
124	 * safely overwrite them.
125	 */
126	status = efi_get_memory_map(sys_table_arg, &map);
127	if (status != EFI_SUCCESS) {
128		pr_efi_err(sys_table_arg,
129			   "reserve_kernel_base(): Unable to retrieve memory map.\n");
130		return status;
131	}
132
133	for (l = 0; l < map_size; l += desc_size) {
134		efi_memory_desc_t *desc;
135		u64 start, end;
136
137		desc = (void *)memory_map + l;
138		start = desc->phys_addr;
139		end = start + desc->num_pages * EFI_PAGE_SIZE;
140
141		/* Skip if entry does not intersect with region */
142		if (start >= dram_base + MAX_UNCOMP_KERNEL_SIZE ||
143		    end <= dram_base)
144			continue;
145
146		switch (desc->type) {
147		case EFI_BOOT_SERVICES_CODE:
148		case EFI_BOOT_SERVICES_DATA:
149			/* Ignore types that are released to the OS anyway */
150			continue;
151
152		case EFI_CONVENTIONAL_MEMORY:
 
 
 
 
 
153			/*
154			 * Reserve the intersection between this entry and the
155			 * region.
156			 */
157			start = max(start, (u64)dram_base);
158			end = min(end, (u64)dram_base + MAX_UNCOMP_KERNEL_SIZE);
159
160			status = efi_call_early(allocate_pages,
161						EFI_ALLOCATE_ADDRESS,
162						EFI_LOADER_DATA,
163						(end - start) / EFI_PAGE_SIZE,
164						&start);
165			if (status != EFI_SUCCESS) {
166				pr_efi_err(sys_table_arg,
167					"reserve_kernel_base(): alloc failed.\n");
168				goto out;
169			}
170			break;
171
172		case EFI_LOADER_CODE:
173		case EFI_LOADER_DATA:
174			/*
175			 * These regions may be released and reallocated for
176			 * another purpose (including EFI_RUNTIME_SERVICE_DATA)
177			 * at any time during the execution of the OS loader,
178			 * so we cannot consider them as safe.
179			 */
180		default:
181			/*
182			 * Treat any other allocation in the region as unsafe */
183			status = EFI_OUT_OF_RESOURCES;
184			goto out;
185		}
186	}
187
188	status = EFI_SUCCESS;
189out:
190	efi_call_early(free_pool, memory_map);
191	return status;
192}
193
194efi_status_t handle_kernel_image(efi_system_table_t *sys_table,
195				 unsigned long *image_addr,
196				 unsigned long *image_size,
197				 unsigned long *reserve_addr,
198				 unsigned long *reserve_size,
199				 unsigned long dram_base,
200				 efi_loaded_image_t *image)
201{
 
202	efi_status_t status;
203
 
 
 
204	/*
205	 * Verify that the DRAM base address is compatible with the ARM
206	 * boot protocol, which determines the base of DRAM by masking
207	 * off the low 27 bits of the address at which the zImage is
208	 * loaded. These assumptions are made by the decompressor,
209	 * before any memory map is available.
210	 */
211	dram_base = round_up(dram_base, SZ_128M);
212
213	status = reserve_kernel_base(sys_table, dram_base, reserve_addr,
214				     reserve_size);
215	if (status != EFI_SUCCESS) {
216		pr_efi_err(sys_table, "Unable to allocate memory for uncompressed kernel.\n");
217		return status;
218	}
219
220	/*
221	 * Relocate the zImage, so that it appears in the lowest 128 MB
222	 * memory window.
223	 */
224	*image_size = image->image_size;
225	status = efi_relocate_kernel(sys_table, image_addr, *image_size,
226				     *image_size,
227				     dram_base + MAX_UNCOMP_KERNEL_SIZE, 0);
228	if (status != EFI_SUCCESS) {
229		pr_efi_err(sys_table, "Failed to relocate kernel.\n");
230		efi_free(sys_table, *reserve_size, *reserve_addr);
231		*reserve_size = 0;
232		return status;
233	}
234
235	/*
236	 * Check to see if we were able to allocate memory low enough
237	 * in memory. The kernel determines the base of DRAM from the
238	 * address at which the zImage is loaded.
239	 */
240	if (*image_addr + *image_size > dram_base + ZIMAGE_OFFSET_LIMIT) {
241		pr_efi_err(sys_table, "Failed to relocate kernel, no low memory available.\n");
242		efi_free(sys_table, *reserve_size, *reserve_addr);
243		*reserve_size = 0;
244		efi_free(sys_table, *image_size, *image_addr);
245		*image_size = 0;
246		return EFI_LOAD_ERROR;
247	}
248	return EFI_SUCCESS;
249}