1/*
2 * Extensible Firmware Interface
3 *
4 * Based on Extensible Firmware Interface Specification version 2.4
5 *
6 * Copyright (C) 2013, 2014 Linaro Ltd.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 */
13
14#include <linux/atomic.h>
15#include <linux/dmi.h>
16#include <linux/efi.h>
17#include <linux/export.h>
18#include <linux/memblock.h>
19#include <linux/mm_types.h>
20#include <linux/bootmem.h>
21#include <linux/of.h>
22#include <linux/of_fdt.h>
23#include <linux/preempt.h>
24#include <linux/rbtree.h>
25#include <linux/rwsem.h>
26#include <linux/sched.h>
27#include <linux/slab.h>
28#include <linux/spinlock.h>
29
30#include <asm/cacheflush.h>
31#include <asm/efi.h>
32#include <asm/tlbflush.h>
33#include <asm/mmu_context.h>
34#include <asm/mmu.h>
35#include <asm/pgtable.h>
36
37struct efi_memory_map memmap;
38
39static u64 efi_system_table;
40
41static pgd_t efi_pgd[PTRS_PER_PGD] __page_aligned_bss;
42
43static struct mm_struct efi_mm = {
44	.mm_rb			= RB_ROOT,
45	.pgd			= efi_pgd,
46	.mm_users		= ATOMIC_INIT(2),
47	.mm_count		= ATOMIC_INIT(1),
48	.mmap_sem		= __RWSEM_INITIALIZER(efi_mm.mmap_sem),
49	.page_table_lock	= __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
50	.mmlist			= LIST_HEAD_INIT(efi_mm.mmlist),
51	INIT_MM_CONTEXT(efi_mm)
52};
53
54static int uefi_debug __initdata;
55static int __init uefi_debug_setup(char *str)
56{
57	uefi_debug = 1;
58
59	return 0;
60}
61early_param("uefi_debug", uefi_debug_setup);
62
63static int __init is_normal_ram(efi_memory_desc_t *md)
64{
65	if (md->attribute & EFI_MEMORY_WB)
66		return 1;
67	return 0;
68}
69
70/*
71 * Translate a EFI virtual address into a physical address: this is necessary,
72 * as some data members of the EFI system table are virtually remapped after
73 * SetVirtualAddressMap() has been called.
74 */
75static phys_addr_t efi_to_phys(unsigned long addr)
76{
77	efi_memory_desc_t *md;
78
79	for_each_efi_memory_desc(&memmap, md) {
80		if (!(md->attribute & EFI_MEMORY_RUNTIME))
81			continue;
82		if (md->virt_addr == 0)
83			/* no virtual mapping has been installed by the stub */
84			break;
85		if (md->virt_addr <= addr &&
86		    (addr - md->virt_addr) < (md->num_pages << EFI_PAGE_SHIFT))
87			return md->phys_addr + addr - md->virt_addr;
88	}
89	return addr;
90}
91
92static int __init uefi_init(void)
93{
94	efi_char16_t *c16;
95	void *config_tables;
96	u64 table_size;
97	char vendor[100] = "unknown";
98	int i, retval;
99
100	efi.systab = early_memremap(efi_system_table,
101				    sizeof(efi_system_table_t));
102	if (efi.systab == NULL) {
103		pr_warn("Unable to map EFI system table.\n");
104		return -ENOMEM;
105	}
106
107	set_bit(EFI_BOOT, &efi.flags);
108	set_bit(EFI_64BIT, &efi.flags);
109
110	/*
111	 * Verify the EFI Table
112	 */
113	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
114		pr_err("System table signature incorrect\n");
115		retval = -EINVAL;
116		goto out;
117	}
118	if ((efi.systab->hdr.revision >> 16) < 2)
119		pr_warn("Warning: EFI system table version %d.%02d, expected 2.00 or greater\n",
120			efi.systab->hdr.revision >> 16,
121			efi.systab->hdr.revision & 0xffff);
122
123	/* Show what we know for posterity */
124	c16 = early_memremap(efi_to_phys(efi.systab->fw_vendor),
125			     sizeof(vendor) * sizeof(efi_char16_t));
126	if (c16) {
127		for (i = 0; i < (int) sizeof(vendor) - 1 && *c16; ++i)
128			vendor[i] = c16[i];
129		vendor[i] = '\0';
130		early_memunmap(c16, sizeof(vendor) * sizeof(efi_char16_t));
131	}
132
133	pr_info("EFI v%u.%.02u by %s\n",
134		efi.systab->hdr.revision >> 16,
135		efi.systab->hdr.revision & 0xffff, vendor);
136
137	table_size = sizeof(efi_config_table_64_t) * efi.systab->nr_tables;
138	config_tables = early_memremap(efi_to_phys(efi.systab->tables),
139				       table_size);
140
141	retval = efi_config_parse_tables(config_tables, efi.systab->nr_tables,
142					 sizeof(efi_config_table_64_t), NULL);
143
144	early_memunmap(config_tables, table_size);
145out:
146	early_memunmap(efi.systab,  sizeof(efi_system_table_t));
147	return retval;
148}
149
150/*
151 * Return true for RAM regions we want to permanently reserve.
152 */
153static __init int is_reserve_region(efi_memory_desc_t *md)
154{
155	switch (md->type) {
156	case EFI_LOADER_CODE:
157	case EFI_LOADER_DATA:
158	case EFI_BOOT_SERVICES_CODE:
159	case EFI_BOOT_SERVICES_DATA:
160	case EFI_CONVENTIONAL_MEMORY:
161		return 0;
162	default:
163		break;
164	}
165	return is_normal_ram(md);
166}
167
168static __init void reserve_regions(void)
169{
170	efi_memory_desc_t *md;
171	u64 paddr, npages, size;
172
173	if (uefi_debug)
174		pr_info("Processing EFI memory map:\n");
175
176	for_each_efi_memory_desc(&memmap, md) {
177		paddr = md->phys_addr;
178		npages = md->num_pages;
179
180		if (uefi_debug) {
181			char buf[64];
182
183			pr_info("  0x%012llx-0x%012llx %s",
184				paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1,
185				efi_md_typeattr_format(buf, sizeof(buf), md));
186		}
187
188		memrange_efi_to_native(&paddr, &npages);
189		size = npages << PAGE_SHIFT;
190
191		if (is_normal_ram(md))
192			early_init_dt_add_memory_arch(paddr, size);
193
194		if (is_reserve_region(md)) {
195			memblock_reserve(paddr, size);
196			if (uefi_debug)
197				pr_cont("*");
198		}
199
200		if (uefi_debug)
201			pr_cont("\n");
202	}
203
204	set_bit(EFI_MEMMAP, &efi.flags);
205}
206
207void __init efi_init(void)
208{
209	struct efi_fdt_params params;
210
211	/* Grab UEFI information placed in FDT by stub */
212	if (!efi_get_fdt_params(&params, uefi_debug))
213		return;
214
215	efi_system_table = params.system_table;
216
217	memblock_reserve(params.mmap & PAGE_MASK,
218			 PAGE_ALIGN(params.mmap_size + (params.mmap & ~PAGE_MASK)));
219	memmap.phys_map = (void *)params.mmap;
220	memmap.map = early_memremap(params.mmap, params.mmap_size);
221	memmap.map_end = memmap.map + params.mmap_size;
222	memmap.desc_size = params.desc_size;
223	memmap.desc_version = params.desc_ver;
224
225	if (uefi_init() < 0)
226		return;
227
228	reserve_regions();
229	early_memunmap(memmap.map, params.mmap_size);
230}
231
232static bool __init efi_virtmap_init(void)
233{
234	efi_memory_desc_t *md;
235
236	for_each_efi_memory_desc(&memmap, md) {
237		u64 paddr, npages, size;
238		pgprot_t prot;
239
240		if (!(md->attribute & EFI_MEMORY_RUNTIME))
241			continue;
242		if (md->virt_addr == 0)
243			return false;
244
245		paddr = md->phys_addr;
246		npages = md->num_pages;
247		memrange_efi_to_native(&paddr, &npages);
248		size = npages << PAGE_SHIFT;
249
250		pr_info("  EFI remap 0x%016llx => %p\n",
251			md->phys_addr, (void *)md->virt_addr);
252
253		/*
254		 * Only regions of type EFI_RUNTIME_SERVICES_CODE need to be
255		 * executable, everything else can be mapped with the XN bits
256		 * set.
257		 */
258		if (!is_normal_ram(md))
259			prot = __pgprot(PROT_DEVICE_nGnRE);
260		else if (md->type == EFI_RUNTIME_SERVICES_CODE ||
261			 !PAGE_ALIGNED(md->phys_addr))
262			prot = PAGE_KERNEL_EXEC;
263		else
264			prot = PAGE_KERNEL;
265
266		create_pgd_mapping(&efi_mm, paddr, md->virt_addr, size, prot);
267	}
268	return true;
269}
270
271/*
272 * Enable the UEFI Runtime Services if all prerequisites are in place, i.e.,
273 * non-early mapping of the UEFI system table and virtual mappings for all
274 * EFI_MEMORY_RUNTIME regions.
275 */
276static int __init arm64_enable_runtime_services(void)
277{
278	u64 mapsize;
279
280	if (!efi_enabled(EFI_BOOT)) {
281		pr_info("EFI services will not be available.\n");
282		return -1;
283	}
284
285	if (efi_runtime_disabled()) {
286		pr_info("EFI runtime services will be disabled.\n");
287		return -1;
288	}
289
290	pr_info("Remapping and enabling EFI services.\n");
291
292	mapsize = memmap.map_end - memmap.map;
293	memmap.map = (__force void *)ioremap_cache((phys_addr_t)memmap.phys_map,
294						   mapsize);
295	if (!memmap.map) {
296		pr_err("Failed to remap EFI memory map\n");
297		return -1;
298	}
299	memmap.map_end = memmap.map + mapsize;
300	efi.memmap = &memmap;
301
302	efi.systab = (__force void *)ioremap_cache(efi_system_table,
303						   sizeof(efi_system_table_t));
304	if (!efi.systab) {
305		pr_err("Failed to remap EFI System Table\n");
306		return -1;
307	}
308	set_bit(EFI_SYSTEM_TABLES, &efi.flags);
309
310	if (!efi_virtmap_init()) {
311		pr_err("No UEFI virtual mapping was installed -- runtime services will not be available\n");
312		return -1;
313	}
314
315	/* Set up runtime services function pointers */
316	efi_native_runtime_setup();
317	set_bit(EFI_RUNTIME_SERVICES, &efi.flags);
318
319	efi.runtime_version = efi.systab->hdr.revision;
320
321	return 0;
322}
323early_initcall(arm64_enable_runtime_services);
324
325static int __init arm64_dmi_init(void)
326{
327	/*
328	 * On arm64, DMI depends on UEFI, and dmi_scan_machine() needs to
329	 * be called early because dmi_id_init(), which is an arch_initcall
330	 * itself, depends on dmi_scan_machine() having been called already.
331	 */
332	dmi_scan_machine();
333	if (dmi_available)
334		dmi_set_dump_stack_arch_desc();
335	return 0;
336}
337core_initcall(arm64_dmi_init);
338
339static void efi_set_pgd(struct mm_struct *mm)
340{
341	if (mm == &init_mm)
342		cpu_set_reserved_ttbr0();
343	else
344		cpu_switch_mm(mm->pgd, mm);
345
346	flush_tlb_all();
347	if (icache_is_aivivt())
348		__flush_icache_all();
349}
350
351void efi_virtmap_load(void)
352{
353	preempt_disable();
354	efi_set_pgd(&efi_mm);
355}
356
357void efi_virtmap_unload(void)
358{
359	efi_set_pgd(current->active_mm);
360	preempt_enable();
361}
362
363/*
364 * UpdateCapsule() depends on the system being shutdown via
365 * ResetSystem().
366 */
367bool efi_poweroff_required(void)
368{
369	return efi_enabled(EFI_RUNTIME_SERVICES);
370}
371