[mirror_ubuntu-hirsute-kernel.git] / drivers / firmware / efi / libstub / arm64-stub.c

/*
 * Copyright (C) 2013, 2014 Linaro Ltd;  <roy.franz@linaro.org>
 *
 * This file implements the EFI boot stub for the arm64 kernel.
 * Adapted from ARM version by Mark Salter <msalter@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */
#include <linux/efi.h>
#include <asm/efi.h>
#include <asm/sections.h>
#include <asm/sysreg.h>

#include "efistub.h"

extern bool __nokaslr;

efi_status_t check_platform_features(efi_system_table_t *sys_table_arg)
{
	u64 tg;

	/* UEFI mandates support for 4 KB granularity, no need to check */
	if (IS_ENABLED(CONFIG_ARM64_4K_PAGES))
		return EFI_SUCCESS;

	tg = (read_cpuid(ID_AA64MMFR0_EL1) >> ID_AA64MMFR0_TGRAN_SHIFT) & 0xf;
	if (tg != ID_AA64MMFR0_TGRAN_SUPPORTED) {
		if (IS_ENABLED(CONFIG_ARM64_64K_PAGES))
			pr_efi_err(sys_table_arg, "This 64 KB granular kernel is not supported by your CPU\n");
		else
			pr_efi_err(sys_table_arg, "This 16 KB granular kernel is not supported by your CPU\n");
		return EFI_UNSUPPORTED;
	}
	return EFI_SUCCESS;
}

efi_status_t handle_kernel_image(efi_system_table_t *sys_table_arg,
				 unsigned long *image_addr,
				 unsigned long *image_size,
				 unsigned long *reserve_addr,
				 unsigned long *reserve_size,
				 unsigned long dram_base,
				 efi_loaded_image_t *image)
{
	efi_status_t status;
	unsigned long kernel_size, kernel_memsize = 0;
	void *old_image_addr = (void *)*image_addr;
	unsigned long preferred_offset;
	u64 phys_seed = 0;

	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
		if (!__nokaslr) {
			status = efi_get_random_bytes(sys_table_arg,
						      sizeof(phys_seed),
						      (u8 *)&phys_seed);
			if (status == EFI_NOT_FOUND) {
				pr_efi(sys_table_arg, "EFI_RNG_PROTOCOL unavailable, no randomness supplied\n");
			} else if (status != EFI_SUCCESS) {
				pr_efi_err(sys_table_arg, "efi_get_random_bytes() failed\n");
				return status;
			}
		} else {
			pr_efi(sys_table_arg, "KASLR disabled on kernel command line\n");
		}
	}

	/*
	 * The preferred offset of the kernel Image is TEXT_OFFSET bytes beyond
	 * a 2 MB aligned base, which itself may be lower than dram_base, as
	 * long as the resulting offset equals or exceeds it.
	 */
	preferred_offset = round_down(dram_base, MIN_KIMG_ALIGN) + TEXT_OFFSET;
	if (preferred_offset < dram_base)
		preferred_offset += MIN_KIMG_ALIGN;

	kernel_size = _edata - _text;
	kernel_memsize = kernel_size + (_end - _edata);

	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && phys_seed != 0) {
		/*
		 * If CONFIG_DEBUG_ALIGN_RODATA is not set, produce a
		 * displacement in the interval [0, MIN_KIMG_ALIGN) that
		 * is a multiple of the minimal segment alignment (SZ_64K)
		 */
		u32 mask = (MIN_KIMG_ALIGN - 1) & ~(SZ_64K - 1);
		u32 offset = !IS_ENABLED(CONFIG_DEBUG_ALIGN_RODATA) ?
			     (phys_seed >> 32) & mask : TEXT_OFFSET;

		/*
		 * If KASLR is enabled, and we have some randomness available,
		 * locate the kernel at a randomized offset in physical memory.
		 */
		*reserve_size = kernel_memsize + offset;
		status = efi_random_alloc(sys_table_arg, *reserve_size,
					  MIN_KIMG_ALIGN, reserve_addr,
					  (u32)phys_seed);

		*image_addr = *reserve_addr + offset;
	} else {
		/*
		 * Else, try a straight allocation at the preferred offset.
		 * This will work around the issue where, if dram_base == 0x0,
		 * efi_low_alloc() refuses to allocate at 0x0 (to prevent the
		 * address of the allocation to be mistaken for a FAIL return
		 * value or a NULL pointer). It will also ensure that, on
		 * platforms where the [dram_base, dram_base + TEXT_OFFSET)
		 * interval is partially occupied by the firmware (like on APM
		 * Mustang), we can still place the kernel at the address
		 * 'dram_base + TEXT_OFFSET'.
		 */
		if (*image_addr == preferred_offset)
			return EFI_SUCCESS;

		*image_addr = *reserve_addr = preferred_offset;
		*reserve_size = round_up(kernel_memsize, EFI_ALLOC_ALIGN);

		status = efi_call_early(allocate_pages, EFI_ALLOCATE_ADDRESS,
					EFI_LOADER_DATA,
					*reserve_size / EFI_PAGE_SIZE,
					(efi_physical_addr_t *)reserve_addr);
	}

	if (status != EFI_SUCCESS) {
		*reserve_size = kernel_memsize + TEXT_OFFSET;
		status = efi_low_alloc(sys_table_arg, *reserve_size,
				       MIN_KIMG_ALIGN, reserve_addr);

		if (status != EFI_SUCCESS) {
			pr_efi_err(sys_table_arg, "Failed to relocate kernel\n");
			*reserve_size = 0;
			return status;
		}
		*image_addr = *reserve_addr + TEXT_OFFSET;
	}
	memcpy((void *)*image_addr, old_image_addr, kernel_size);

	return EFI_SUCCESS;
}
Commit	Line	Data
3c7f2550 MS	1	/*
	2	* Copyright (C) 2013, 2014 Linaro Ltd; <roy.franz@linaro.org>
	3	*
	4	* This file implements the EFI boot stub for the arm64 kernel.
	5	* Adapted from ARM version by Mark Salter <msalter@redhat.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	*/
	12	#include <linux/efi.h>
a13b0077	13	#include <asm/efi.h>
3c7f2550	14	#include <asm/sections.h>
42b55734	15	#include <asm/sysreg.h>
3c7f2550	16
2b5fe07a AB	17	#include "efistub.h"
	18
	19	extern bool __nokaslr;
	20
42b55734 AB	21	efi_status_t check_platform_features(efi_system_table_t *sys_table_arg)
	22	{
	23	u64 tg;
	24
	25	/* UEFI mandates support for 4 KB granularity, no need to check */
	26	if (IS_ENABLED(CONFIG_ARM64_4K_PAGES))
	27	return EFI_SUCCESS;
	28
	29	tg = (read_cpuid(ID_AA64MMFR0_EL1) >> ID_AA64MMFR0_TGRAN_SHIFT) & 0xf;
	30	if (tg != ID_AA64MMFR0_TGRAN_SUPPORTED) {
	31	if (IS_ENABLED(CONFIG_ARM64_64K_PAGES))
	32	pr_efi_err(sys_table_arg, "This 64 KB granular kernel is not supported by your CPU\n");
	33	else
	34	pr_efi_err(sys_table_arg, "This 16 KB granular kernel is not supported by your CPU\n");
	35	return EFI_UNSUPPORTED;
	36	}
	37	return EFI_SUCCESS;
	38	}
3c7f2550	39
dae31fd2 AB	40	efi_status_t handle_kernel_image(efi_system_table_t *sys_table_arg,
	41	unsigned long *image_addr,
	42	unsigned long *image_size,
	43	unsigned long *reserve_addr,
	44	unsigned long *reserve_size,
	45	unsigned long dram_base,
	46	efi_loaded_image_t *image)
3c7f2550 MS	47	{
	48	efi_status_t status;
	49	unsigned long kernel_size, kernel_memsize = 0;
e38457c3	50	void old_image_addr = (void )*image_addr;
73effccb	51	unsigned long preferred_offset;
2b5fe07a AB	52	u64 phys_seed = 0;
	53
	54	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
	55	if (!__nokaslr) {
	56	status = efi_get_random_bytes(sys_table_arg,
	57	sizeof(phys_seed),
	58	(u8 *)&phys_seed);
	59	if (status == EFI_NOT_FOUND) {
	60	pr_efi(sys_table_arg, "EFI_RNG_PROTOCOL unavailable, no randomness supplied\n");
	61	} else if (status != EFI_SUCCESS) {
	62	pr_efi_err(sys_table_arg, "efi_get_random_bytes() failed\n");
	63	return status;
	64	}
	65	} else {
	66	pr_efi(sys_table_arg, "KASLR disabled on kernel command line\n");
	67	}
	68	}
73effccb AB	69
	70	/*
	71	* The preferred offset of the kernel Image is TEXT_OFFSET bytes beyond
	72	* a 2 MB aligned base, which itself may be lower than dram_base, as
	73	* long as the resulting offset equals or exceeds it.
	74	*/
2b5fe07a	75	preferred_offset = round_down(dram_base, MIN_KIMG_ALIGN) + TEXT_OFFSET;
73effccb	76	if (preferred_offset < dram_base)
2b5fe07a	77	preferred_offset += MIN_KIMG_ALIGN;
3c7f2550	78
3c7f2550	79	kernel_size = _edata - _text;
2b5fe07a AB	80	kernel_memsize = kernel_size + (_end - _edata);
	81
	82	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && phys_seed != 0) {
6f26b367 AB	83	/*
	84	* If CONFIG_DEBUG_ALIGN_RODATA is not set, produce a
	85	* displacement in the interval [0, MIN_KIMG_ALIGN) that
	86	* is a multiple of the minimal segment alignment (SZ_64K)
	87	*/
	88	u32 mask = (MIN_KIMG_ALIGN - 1) & ~(SZ_64K - 1);
	89	u32 offset = !IS_ENABLED(CONFIG_DEBUG_ALIGN_RODATA) ?
	90	(phys_seed >> 32) & mask : TEXT_OFFSET;
	91
2b5fe07a AB	92	/*
	93	* If KASLR is enabled, and we have some randomness available,
	94	* locate the kernel at a randomized offset in physical memory.
	95	*/
6f26b367	96	*reserve_size = kernel_memsize + offset;
2b5fe07a AB	97	status = efi_random_alloc(sys_table_arg, *reserve_size,
2b5fe07a AB	98	MIN_KIMG_ALIGN, reserve_addr,
6f26b367	99	(u32)phys_seed);
e38457c3	100
6f26b367	101	image_addr = reserve_addr + offset;
2b5fe07a	102	} else {
e38457c3	103	/*
2b5fe07a	104	* Else, try a straight allocation at the preferred offset.
e38457c3 AB	105	* This will work around the issue where, if dram_base == 0x0,
	106	* efi_low_alloc() refuses to allocate at 0x0 (to prevent the
	107	* address of the allocation to be mistaken for a FAIL return
	108	* value or a NULL pointer). It will also ensure that, on
	109	* platforms where the [dram_base, dram_base + TEXT_OFFSET)
	110	* interval is partially occupied by the firmware (like on APM
	111	* Mustang), we can still place the kernel at the address
	112	* 'dram_base + TEXT_OFFSET'.
	113	*/
2b5fe07a AB	114	if (*image_addr == preferred_offset)
	115	return EFI_SUCCESS;
	116
73effccb	117	image_addr = reserve_addr = preferred_offset;
2b5fe07a AB	118	*reserve_size = round_up(kernel_memsize, EFI_ALLOC_ALIGN);
2b5fe07a AB	119
e38457c3	120	status = efi_call_early(allocate_pages, EFI_ALLOCATE_ADDRESS,
2b5fe07a AB	121	EFI_LOADER_DATA,
2b5fe07a AB	122	*reserve_size / EFI_PAGE_SIZE,
e38457c3	123	(efi_physical_addr_t *)reserve_addr);
2b5fe07a	124	}
e38457c3	125
2b5fe07a AB	126	if (status != EFI_SUCCESS) {
	127	*reserve_size = kernel_memsize + TEXT_OFFSET;
	128	status = efi_low_alloc(sys_table_arg, *reserve_size,
	129	MIN_KIMG_ALIGN, reserve_addr);
	130
	131	if (status != EFI_SUCCESS) {
	132	pr_efi_err(sys_table_arg, "Failed to relocate kernel\n");
	133	*reserve_size = 0;
	134	return status;
3c7f2550	135	}
2b5fe07a	136	image_addr = reserve_addr + TEXT_OFFSET;
3c7f2550	137	}
2b5fe07a	138	memcpy((void )image_addr, old_image_addr, kernel_size);
3c7f2550 MS	139
	140	return EFI_SUCCESS;
	141	}