blob: 1fbb408e2e721837e7d28a9cdfdf59ffd96973d3 [file] [log] [blame]
Huang, Ying5b836832008-01-30 13:31:19 +01001/*
2 * Common EFI (Extensible Firmware Interface) support functions
3 * Based on Extensible Firmware Interface Specification version 1.0
4 *
5 * Copyright (C) 1999 VA Linux Systems
6 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
7 * Copyright (C) 1999-2002 Hewlett-Packard Co.
8 * David Mosberger-Tang <davidm@hpl.hp.com>
9 * Stephane Eranian <eranian@hpl.hp.com>
10 * Copyright (C) 2005-2008 Intel Co.
11 * Fenghua Yu <fenghua.yu@intel.com>
12 * Bibo Mao <bibo.mao@intel.com>
13 * Chandramouli Narayanan <mouli@linux.intel.com>
14 * Huang Ying <ying.huang@intel.com>
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +010015 * Copyright (C) 2013 SuSE Labs
16 * Borislav Petkov <bp@suse.de> - runtime services VA mapping
Huang, Ying5b836832008-01-30 13:31:19 +010017 *
18 * Copied from efi_32.c to eliminate the duplicated code between EFI
19 * 32/64 support code. --ying 2007-10-26
20 *
21 * All EFI Runtime Services are not implemented yet as EFI only
22 * supports physical mode addressing on SoftSDV. This is to be fixed
23 * in a future version. --drummond 1999-07-20
24 *
25 * Implemented EFI runtime services and virtual mode calls. --davidm
26 *
27 * Goutham Rao: <goutham.rao@intel.com>
28 * Skip non-WB memory and ignore empty memory ranges.
29 */
30
Olof Johanssone3cb3f52012-02-12 13:24:26 -080031#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32
Huang, Ying5b836832008-01-30 13:31:19 +010033#include <linux/kernel.h>
34#include <linux/init.h>
35#include <linux/efi.h>
Josh Triplett2223af32012-09-28 17:57:05 -070036#include <linux/efi-bgrt.h>
Paul Gortmaker69c60c82011-05-26 12:22:53 -040037#include <linux/export.h>
Huang, Ying5b836832008-01-30 13:31:19 +010038#include <linux/bootmem.h>
David Howells0d01ff22013-04-11 23:51:01 +010039#include <linux/slab.h>
Yinghai Lua9ce6bc2010-08-25 13:39:17 -070040#include <linux/memblock.h>
Huang, Ying5b836832008-01-30 13:31:19 +010041#include <linux/spinlock.h>
42#include <linux/uaccess.h>
43#include <linux/time.h>
44#include <linux/io.h>
45#include <linux/reboot.h>
46#include <linux/bcd.h>
47
48#include <asm/setup.h>
49#include <asm/efi.h>
50#include <asm/time.h>
Huang, Yinga2172e22008-01-30 13:33:55 +010051#include <asm/cacheflush.h>
52#include <asm/tlbflush.h>
Feng Tang7bd867d2009-09-10 10:48:56 +080053#include <asm/x86_init.h>
Borislav Petkova5d90c92014-03-04 17:02:17 +010054#include <asm/uv/uv.h>
Huang, Ying5b836832008-01-30 13:31:19 +010055
Harvey Harrisonecaea422008-02-13 13:26:13 -080056static struct efi efi_phys __initdata;
Huang, Ying5b836832008-01-30 13:31:19 +010057static efi_system_table_t efi_systab __initdata;
58
Joe Perches9b7d2042014-01-03 16:08:48 -080059static efi_config_table_type_t arch_tables[] __initdata = {
Leif Lindholm272686b2013-09-05 11:34:54 +010060#ifdef CONFIG_X86_UV
61 {UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab},
62#endif
Leif Lindholm722da9d2013-10-03 15:42:37 +010063 {NULL_GUID, NULL, NULL},
Leif Lindholm272686b2013-09-05 11:34:54 +010064};
65
Dave Young1fec0532013-12-20 18:02:19 +080066u64 efi_setup; /* efi setup_data physical address */
Dave Young926172d2013-12-20 18:02:18 +080067
Mathias Krause60920682014-09-07 19:42:15 +020068static int add_efi_memmap __initdata;
Paul Jackson200001e2008-06-25 05:44:46 -070069static int __init setup_add_efi_memmap(char *arg)
70{
71 add_efi_memmap = 1;
72 return 0;
73}
74early_param("add_efi_memmap", setup_add_efi_memmap);
75
Huang, Ying5b836832008-01-30 13:31:19 +010076static efi_status_t __init phys_efi_set_virtual_address_map(
77 unsigned long memory_map_size,
78 unsigned long descriptor_size,
79 u32 descriptor_version,
80 efi_memory_desc_t *virtual_map)
81{
82 efi_status_t status;
Ingo Molnar23a0d4e2015-03-03 07:34:33 +010083 unsigned long flags;
Ingo Molnar744937b2015-03-03 07:48:50 +010084 pgd_t *save_pgd;
Huang, Ying5b836832008-01-30 13:31:19 +010085
Ingo Molnar744937b2015-03-03 07:48:50 +010086 save_pgd = efi_call_phys_prolog();
Ingo Molnar23a0d4e2015-03-03 07:34:33 +010087
88 /* Disable interrupts around EFI calls: */
89 local_irq_save(flags);
Matt Fleming62fa6e62014-03-27 15:10:39 -070090 status = efi_call_phys(efi_phys.set_virtual_address_map,
91 memory_map_size, descriptor_size,
92 descriptor_version, virtual_map);
Ingo Molnar23a0d4e2015-03-03 07:34:33 +010093 local_irq_restore(flags);
94
Ingo Molnar744937b2015-03-03 07:48:50 +010095 efi_call_phys_epilog(save_pgd);
Ingo Molnar23a0d4e2015-03-03 07:34:33 +010096
Huang, Ying5b836832008-01-30 13:31:19 +010097 return status;
98}
99
Tony Luckb05b9f52015-06-24 16:58:15 -0700100void __init efi_find_mirror(void)
101{
Matt Fleming78ce2482016-04-25 21:06:38 +0100102 efi_memory_desc_t *md;
Tony Luckb05b9f52015-06-24 16:58:15 -0700103 u64 mirror_size = 0, total_size = 0;
104
Matt Fleming78ce2482016-04-25 21:06:38 +0100105 for_each_efi_memory_desc(md) {
Tony Luckb05b9f52015-06-24 16:58:15 -0700106 unsigned long long start = md->phys_addr;
107 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
108
109 total_size += size;
110 if (md->attribute & EFI_MEMORY_MORE_RELIABLE) {
111 memblock_mark_mirror(start, size);
112 mirror_size += size;
113 }
114 }
115 if (mirror_size)
116 pr_info("Memory: %lldM/%lldM mirrored memory\n",
117 mirror_size>>20, total_size>>20);
118}
119
Paul Jackson69c91892008-05-14 08:15:58 -0700120/*
121 * Tell the kernel about the EFI memory map. This might include
122 * more than the max 128 entries that can fit in the e820 legacy
123 * (zeropage) memory map.
124 */
125
Paul Jackson200001e2008-06-25 05:44:46 -0700126static void __init do_add_efi_memmap(void)
Paul Jackson69c91892008-05-14 08:15:58 -0700127{
Matt Fleming78ce2482016-04-25 21:06:38 +0100128 efi_memory_desc_t *md;
Paul Jackson69c91892008-05-14 08:15:58 -0700129
Matt Fleming78ce2482016-04-25 21:06:38 +0100130 for_each_efi_memory_desc(md) {
Paul Jackson69c91892008-05-14 08:15:58 -0700131 unsigned long long start = md->phys_addr;
132 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
133 int e820_type;
134
Cliff Wickmane2a71472009-06-16 16:43:40 -0500135 switch (md->type) {
136 case EFI_LOADER_CODE:
137 case EFI_LOADER_DATA:
138 case EFI_BOOT_SERVICES_CODE:
139 case EFI_BOOT_SERVICES_DATA:
140 case EFI_CONVENTIONAL_MEMORY:
141 if (md->attribute & EFI_MEMORY_WB)
142 e820_type = E820_RAM;
143 else
144 e820_type = E820_RESERVED;
145 break;
146 case EFI_ACPI_RECLAIM_MEMORY:
147 e820_type = E820_ACPI;
148 break;
149 case EFI_ACPI_MEMORY_NVS:
150 e820_type = E820_NVS;
151 break;
152 case EFI_UNUSABLE_MEMORY:
153 e820_type = E820_UNUSABLE;
154 break;
Dan Williamsad5fb872015-04-03 12:05:28 -0400155 case EFI_PERSISTENT_MEMORY:
156 e820_type = E820_PMEM;
157 break;
Cliff Wickmane2a71472009-06-16 16:43:40 -0500158 default:
159 /*
160 * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE
161 * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
162 * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
163 */
Paul Jackson69c91892008-05-14 08:15:58 -0700164 e820_type = E820_RESERVED;
Cliff Wickmane2a71472009-06-16 16:43:40 -0500165 break;
166 }
Yinghai Lud0be6bd2008-06-15 18:58:51 -0700167 e820_add_region(start, size, e820_type);
Paul Jackson69c91892008-05-14 08:15:58 -0700168 }
169 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
170}
171
Olof Johansson1adbfa32012-02-12 13:24:29 -0800172int __init efi_memblock_x86_reserve_range(void)
Huang, Yingecacf092008-06-02 14:26:21 +0800173{
Borislav Petkov15b9c352013-03-01 17:07:44 +0100174 struct efi_info *e = &boot_params.efi_info;
Ard Biesheuvel44511fb2015-10-23 11:48:16 +0200175 phys_addr_t pmap;
Huang, Yingecacf092008-06-02 14:26:21 +0800176
Daniel Kiper9f27bc52014-06-30 19:52:58 +0200177 if (efi_enabled(EFI_PARAVIRT))
178 return 0;
179
Paul Jackson05486fa2008-06-22 07:22:02 -0700180#ifdef CONFIG_X86_32
Olof Johansson1adbfa32012-02-12 13:24:29 -0800181 /* Can't handle data above 4GB at this time */
Borislav Petkov15b9c352013-03-01 17:07:44 +0100182 if (e->efi_memmap_hi) {
Olof Johansson1adbfa32012-02-12 13:24:29 -0800183 pr_err("Memory map is above 4GB, disabling EFI.\n");
184 return -EINVAL;
185 }
Borislav Petkov15b9c352013-03-01 17:07:44 +0100186 pmap = e->efi_memmap;
Paul Jackson05486fa2008-06-22 07:22:02 -0700187#else
Borislav Petkov15b9c352013-03-01 17:07:44 +0100188 pmap = (e->efi_memmap | ((__u64)e->efi_memmap_hi << 32));
Huang, Yingecacf092008-06-02 14:26:21 +0800189#endif
Matt Fleming884f4f62016-04-25 21:06:39 +0100190 efi.memmap.phys_map = pmap;
191 efi.memmap.nr_map = e->efi_memmap_size /
Borislav Petkov15b9c352013-03-01 17:07:44 +0100192 e->efi_memdesc_size;
Matt Fleming884f4f62016-04-25 21:06:39 +0100193 efi.memmap.desc_size = e->efi_memdesc_size;
194 efi.memmap.desc_version = e->efi_memdesc_version;
Borislav Petkov15b9c352013-03-01 17:07:44 +0100195
Ard Biesheuvel0d054ad2016-04-25 21:06:40 +0100196 WARN(efi.memmap.desc_version != 1,
197 "Unexpected EFI_MEMORY_DESCRIPTOR version %ld",
198 efi.memmap.desc_version);
199
Matt Fleming884f4f62016-04-25 21:06:39 +0100200 memblock_reserve(pmap, efi.memmap.nr_map * efi.memmap.desc_size);
Leif Lindholm258f6fd2013-09-05 11:34:55 +0100201
Olof Johansson1adbfa32012-02-12 13:24:29 -0800202 return 0;
Huang, Yingecacf092008-06-02 14:26:21 +0800203}
204
Taku Izumi0bbea1c2015-09-30 19:20:00 +0900205void __init efi_print_memmap(void)
Huang, Ying5b836832008-01-30 13:31:19 +0100206{
207 efi_memory_desc_t *md;
Matt Fleming78ce2482016-04-25 21:06:38 +0100208 int i = 0;
Huang, Ying5b836832008-01-30 13:31:19 +0100209
Matt Fleming78ce2482016-04-25 21:06:38 +0100210 for_each_efi_memory_desc(md) {
Laszlo Ersekace1d122014-09-03 13:32:21 +0200211 char buf[64];
212
Robert Elliott1e82b942016-02-01 22:07:05 +0000213 pr_info("mem%02u: %s range=[0x%016llx-0x%016llx] (%lluMB)\n",
Matt Fleming78ce2482016-04-25 21:06:38 +0100214 i++, efi_md_typeattr_format(buf, sizeof(buf), md),
Laszlo Ersekace1d122014-09-03 13:32:21 +0200215 md->phys_addr,
Robert Elliott1e82b942016-02-01 22:07:05 +0000216 md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1,
Huang, Ying5b836832008-01-30 13:31:19 +0100217 (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
218 }
Borislav Petkovf4fccac2013-10-31 17:24:59 +0100219}
Huang, Ying5b836832008-01-30 13:31:19 +0100220
Olof Johansson5189c2a2012-10-24 10:00:44 -0700221void __init efi_unmap_memmap(void)
Josh Triplett78510792012-09-28 17:55:44 -0700222{
Matt Fleming884f4f62016-04-25 21:06:39 +0100223 unsigned long size;
224
Matt Fleming3e909592014-01-15 13:21:22 +0000225 clear_bit(EFI_MEMMAP, &efi.flags);
Matt Fleming884f4f62016-04-25 21:06:39 +0100226
227 size = efi.memmap.nr_map * efi.memmap.desc_size;
228 if (efi.memmap.map) {
229 early_memunmap(efi.memmap.map, size);
230 efi.memmap.map = NULL;
Josh Triplett78510792012-09-28 17:55:44 -0700231 }
232}
233
Olof Johansson140bf272012-02-12 13:24:28 -0800234static int __init efi_systab_init(void *phys)
Huang, Ying5b836832008-01-30 13:31:19 +0100235{
Matt Fleming83e68182012-11-14 09:42:35 +0000236 if (efi_enabled(EFI_64BIT)) {
Olof Johansson1adbfa32012-02-12 13:24:29 -0800237 efi_system_table_64_t *systab64;
Dave Young1fec0532013-12-20 18:02:19 +0800238 struct efi_setup_data *data = NULL;
Olof Johansson1adbfa32012-02-12 13:24:29 -0800239 u64 tmp = 0;
240
Dave Young1fec0532013-12-20 18:02:19 +0800241 if (efi_setup) {
242 data = early_memremap(efi_setup, sizeof(*data));
243 if (!data)
244 return -ENOMEM;
245 }
Daniel Kiperabc93f82014-06-30 19:52:56 +0200246 systab64 = early_memremap((unsigned long)phys,
Olof Johansson1adbfa32012-02-12 13:24:29 -0800247 sizeof(*systab64));
248 if (systab64 == NULL) {
249 pr_err("Couldn't map the system table!\n");
Dave Young1fec0532013-12-20 18:02:19 +0800250 if (data)
Daniel Kiperabc93f82014-06-30 19:52:56 +0200251 early_memunmap(data, sizeof(*data));
Olof Johansson1adbfa32012-02-12 13:24:29 -0800252 return -ENOMEM;
253 }
254
255 efi_systab.hdr = systab64->hdr;
Dave Young1fec0532013-12-20 18:02:19 +0800256 efi_systab.fw_vendor = data ? (unsigned long)data->fw_vendor :
257 systab64->fw_vendor;
258 tmp |= data ? data->fw_vendor : systab64->fw_vendor;
Olof Johansson1adbfa32012-02-12 13:24:29 -0800259 efi_systab.fw_revision = systab64->fw_revision;
260 efi_systab.con_in_handle = systab64->con_in_handle;
261 tmp |= systab64->con_in_handle;
262 efi_systab.con_in = systab64->con_in;
263 tmp |= systab64->con_in;
264 efi_systab.con_out_handle = systab64->con_out_handle;
265 tmp |= systab64->con_out_handle;
266 efi_systab.con_out = systab64->con_out;
267 tmp |= systab64->con_out;
268 efi_systab.stderr_handle = systab64->stderr_handle;
269 tmp |= systab64->stderr_handle;
270 efi_systab.stderr = systab64->stderr;
271 tmp |= systab64->stderr;
Dave Young1fec0532013-12-20 18:02:19 +0800272 efi_systab.runtime = data ?
273 (void *)(unsigned long)data->runtime :
274 (void *)(unsigned long)systab64->runtime;
275 tmp |= data ? data->runtime : systab64->runtime;
Olof Johansson1adbfa32012-02-12 13:24:29 -0800276 efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
277 tmp |= systab64->boottime;
278 efi_systab.nr_tables = systab64->nr_tables;
Dave Young1fec0532013-12-20 18:02:19 +0800279 efi_systab.tables = data ? (unsigned long)data->tables :
280 systab64->tables;
281 tmp |= data ? data->tables : systab64->tables;
Olof Johansson1adbfa32012-02-12 13:24:29 -0800282
Daniel Kiperabc93f82014-06-30 19:52:56 +0200283 early_memunmap(systab64, sizeof(*systab64));
Dave Young1fec0532013-12-20 18:02:19 +0800284 if (data)
Daniel Kiperabc93f82014-06-30 19:52:56 +0200285 early_memunmap(data, sizeof(*data));
Olof Johansson1adbfa32012-02-12 13:24:29 -0800286#ifdef CONFIG_X86_32
287 if (tmp >> 32) {
288 pr_err("EFI data located above 4GB, disabling EFI.\n");
289 return -EINVAL;
290 }
291#endif
292 } else {
293 efi_system_table_32_t *systab32;
294
Daniel Kiperabc93f82014-06-30 19:52:56 +0200295 systab32 = early_memremap((unsigned long)phys,
Olof Johansson1adbfa32012-02-12 13:24:29 -0800296 sizeof(*systab32));
297 if (systab32 == NULL) {
298 pr_err("Couldn't map the system table!\n");
299 return -ENOMEM;
300 }
301
302 efi_systab.hdr = systab32->hdr;
303 efi_systab.fw_vendor = systab32->fw_vendor;
304 efi_systab.fw_revision = systab32->fw_revision;
305 efi_systab.con_in_handle = systab32->con_in_handle;
306 efi_systab.con_in = systab32->con_in;
307 efi_systab.con_out_handle = systab32->con_out_handle;
308 efi_systab.con_out = systab32->con_out;
309 efi_systab.stderr_handle = systab32->stderr_handle;
310 efi_systab.stderr = systab32->stderr;
311 efi_systab.runtime = (void *)(unsigned long)systab32->runtime;
312 efi_systab.boottime = (void *)(unsigned long)systab32->boottime;
313 efi_systab.nr_tables = systab32->nr_tables;
314 efi_systab.tables = systab32->tables;
315
Daniel Kiperabc93f82014-06-30 19:52:56 +0200316 early_memunmap(systab32, sizeof(*systab32));
Olof Johansson140bf272012-02-12 13:24:28 -0800317 }
Olof Johansson1adbfa32012-02-12 13:24:29 -0800318
Huang, Ying5b836832008-01-30 13:31:19 +0100319 efi.systab = &efi_systab;
320
321 /*
322 * Verify the EFI Table
323 */
Olof Johansson140bf272012-02-12 13:24:28 -0800324 if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
Olof Johanssone3cb3f52012-02-12 13:24:26 -0800325 pr_err("System table signature incorrect!\n");
Olof Johansson140bf272012-02-12 13:24:28 -0800326 return -EINVAL;
327 }
Huang, Ying5b836832008-01-30 13:31:19 +0100328 if ((efi.systab->hdr.revision >> 16) == 0)
Joe Perches9b7d2042014-01-03 16:08:48 -0800329 pr_err("Warning: System table version %d.%02d, expected 1.00 or greater!\n",
Huang, Ying5b836832008-01-30 13:31:19 +0100330 efi.systab->hdr.revision >> 16,
331 efi.systab->hdr.revision & 0xffff);
Olof Johansson140bf272012-02-12 13:24:28 -0800332
333 return 0;
Olof Johansson83e7ee62012-02-12 13:24:25 -0800334}
Huang, Ying5b836832008-01-30 13:31:19 +0100335
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000336static int __init efi_runtime_init32(void)
337{
338 efi_runtime_services_32_t *runtime;
339
Daniel Kiperabc93f82014-06-30 19:52:56 +0200340 runtime = early_memremap((unsigned long)efi.systab->runtime,
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000341 sizeof(efi_runtime_services_32_t));
342 if (!runtime) {
343 pr_err("Could not map the runtime service table!\n");
344 return -ENOMEM;
345 }
346
347 /*
Mathias Krause0ce46052014-09-07 19:42:16 +0200348 * We will only need *early* access to the SetVirtualAddressMap
349 * EFI runtime service. All other runtime services will be called
350 * via the virtual mapping.
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000351 */
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000352 efi_phys.set_virtual_address_map =
353 (efi_set_virtual_address_map_t *)
354 (unsigned long)runtime->set_virtual_address_map;
Daniel Kiperabc93f82014-06-30 19:52:56 +0200355 early_memunmap(runtime, sizeof(efi_runtime_services_32_t));
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000356
357 return 0;
358}
359
360static int __init efi_runtime_init64(void)
361{
362 efi_runtime_services_64_t *runtime;
363
Daniel Kiperabc93f82014-06-30 19:52:56 +0200364 runtime = early_memremap((unsigned long)efi.systab->runtime,
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000365 sizeof(efi_runtime_services_64_t));
366 if (!runtime) {
367 pr_err("Could not map the runtime service table!\n");
368 return -ENOMEM;
369 }
370
371 /*
Mathias Krause0ce46052014-09-07 19:42:16 +0200372 * We will only need *early* access to the SetVirtualAddressMap
373 * EFI runtime service. All other runtime services will be called
374 * via the virtual mapping.
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000375 */
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000376 efi_phys.set_virtual_address_map =
377 (efi_set_virtual_address_map_t *)
378 (unsigned long)runtime->set_virtual_address_map;
Daniel Kiperabc93f82014-06-30 19:52:56 +0200379 early_memunmap(runtime, sizeof(efi_runtime_services_64_t));
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000380
381 return 0;
382}
383
Olof Johansson140bf272012-02-12 13:24:28 -0800384static int __init efi_runtime_init(void)
Olof Johansson83e7ee62012-02-12 13:24:25 -0800385{
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000386 int rv;
Huang, Ying5b836832008-01-30 13:31:19 +0100387
388 /*
389 * Check out the runtime services table. We need to map
390 * the runtime services table so that we can grab the physical
391 * address of several of the EFI runtime functions, needed to
392 * set the firmware into virtual mode.
Daniel Kiper9f27bc52014-06-30 19:52:58 +0200393 *
394 * When EFI_PARAVIRT is in force then we could not map runtime
395 * service memory region because we do not have direct access to it.
396 * However, runtime services are available through proxy functions
397 * (e.g. in case of Xen dom0 EFI implementation they call special
398 * hypercall which executes relevant EFI functions) and that is why
399 * they are always enabled.
Huang, Ying5b836832008-01-30 13:31:19 +0100400 */
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000401
Daniel Kiper9f27bc52014-06-30 19:52:58 +0200402 if (!efi_enabled(EFI_PARAVIRT)) {
403 if (efi_enabled(EFI_64BIT))
404 rv = efi_runtime_init64();
405 else
406 rv = efi_runtime_init32();
407
408 if (rv)
409 return rv;
410 }
Olof Johansson140bf272012-02-12 13:24:28 -0800411
Matt Fleming0f8093a2014-01-15 13:36:33 +0000412 set_bit(EFI_RUNTIME_SERVICES, &efi.flags);
413
Olof Johansson140bf272012-02-12 13:24:28 -0800414 return 0;
Olof Johansson83e7ee62012-02-12 13:24:25 -0800415}
Huang, Ying5b836832008-01-30 13:31:19 +0100416
Olof Johansson140bf272012-02-12 13:24:28 -0800417static int __init efi_memmap_init(void)
Olof Johansson83e7ee62012-02-12 13:24:25 -0800418{
Matt Fleming884f4f62016-04-25 21:06:39 +0100419 unsigned long addr, size;
420
Daniel Kiper9f27bc52014-06-30 19:52:58 +0200421 if (efi_enabled(EFI_PARAVIRT))
422 return 0;
423
Huang, Ying5b836832008-01-30 13:31:19 +0100424 /* Map the EFI memory map */
Matt Fleming884f4f62016-04-25 21:06:39 +0100425 size = efi.memmap.nr_map * efi.memmap.desc_size;
426 addr = (unsigned long)efi.memmap.phys_map;
427
428 efi.memmap.map = early_memremap(addr, size);
429 if (efi.memmap.map == NULL) {
Olof Johanssone3cb3f52012-02-12 13:24:26 -0800430 pr_err("Could not map the memory map!\n");
Olof Johansson140bf272012-02-12 13:24:28 -0800431 return -ENOMEM;
432 }
Matt Fleming884f4f62016-04-25 21:06:39 +0100433
434 efi.memmap.map_end = efi.memmap.map + size;
Russ Anderson175e4382008-10-02 17:32:06 -0500435
Paul Jackson200001e2008-06-25 05:44:46 -0700436 if (add_efi_memmap)
437 do_add_efi_memmap();
Olof Johansson140bf272012-02-12 13:24:28 -0800438
Matt Fleming0f8093a2014-01-15 13:36:33 +0000439 set_bit(EFI_MEMMAP, &efi.flags);
440
Olof Johansson140bf272012-02-12 13:24:28 -0800441 return 0;
Olof Johansson83e7ee62012-02-12 13:24:25 -0800442}
443
444void __init efi_init(void)
445{
446 efi_char16_t *c16;
447 char vendor[100] = "unknown";
448 int i = 0;
449 void *tmp;
450
451#ifdef CONFIG_X86_32
Olof Johansson1adbfa32012-02-12 13:24:29 -0800452 if (boot_params.efi_info.efi_systab_hi ||
453 boot_params.efi_info.efi_memmap_hi) {
454 pr_info("Table located above 4GB, disabling EFI.\n");
Olof Johansson1adbfa32012-02-12 13:24:29 -0800455 return;
456 }
Olof Johansson83e7ee62012-02-12 13:24:25 -0800457 efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
458#else
459 efi_phys.systab = (efi_system_table_t *)
Olof Johansson1adbfa32012-02-12 13:24:29 -0800460 (boot_params.efi_info.efi_systab |
461 ((__u64)boot_params.efi_info.efi_systab_hi<<32));
Olof Johansson83e7ee62012-02-12 13:24:25 -0800462#endif
463
Matt Fleming83e68182012-11-14 09:42:35 +0000464 if (efi_systab_init(efi_phys.systab))
Olof Johansson140bf272012-02-12 13:24:28 -0800465 return;
Matt Fleming83e68182012-11-14 09:42:35 +0000466
Dave Younga0998eb2013-12-20 18:02:17 +0800467 efi.config_table = (unsigned long)efi.systab->tables;
468 efi.fw_vendor = (unsigned long)efi.systab->fw_vendor;
469 efi.runtime = (unsigned long)efi.systab->runtime;
470
Olof Johansson83e7ee62012-02-12 13:24:25 -0800471 /*
472 * Show what we know for posterity
473 */
Daniel Kiperabc93f82014-06-30 19:52:56 +0200474 c16 = tmp = early_memremap(efi.systab->fw_vendor, 2);
Olof Johansson83e7ee62012-02-12 13:24:25 -0800475 if (c16) {
476 for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
477 vendor[i] = *c16++;
478 vendor[i] = '\0';
479 } else
Olof Johanssone3cb3f52012-02-12 13:24:26 -0800480 pr_err("Could not map the firmware vendor!\n");
Daniel Kiperabc93f82014-06-30 19:52:56 +0200481 early_memunmap(tmp, 2);
Olof Johansson83e7ee62012-02-12 13:24:25 -0800482
Olof Johanssone3cb3f52012-02-12 13:24:26 -0800483 pr_info("EFI v%u.%.02u by %s\n",
484 efi.systab->hdr.revision >> 16,
485 efi.systab->hdr.revision & 0xffff, vendor);
Olof Johansson83e7ee62012-02-12 13:24:25 -0800486
Dave Young1fec0532013-12-20 18:02:19 +0800487 if (efi_reuse_config(efi.systab->tables, efi.systab->nr_tables))
488 return;
489
Leif Lindholm272686b2013-09-05 11:34:54 +0100490 if (efi_config_init(arch_tables))
Olof Johansson140bf272012-02-12 13:24:28 -0800491 return;
Matt Fleming83e68182012-11-14 09:42:35 +0000492
Olof Johansson1adbfa32012-02-12 13:24:29 -0800493 /*
494 * Note: We currently don't support runtime services on an EFI
495 * that doesn't match the kernel 32/64-bit mode.
496 */
497
Matt Fleming7d453ee2014-01-10 18:52:06 +0000498 if (!efi_runtime_supported())
Olof Johansson1adbfa32012-02-12 13:24:29 -0800499 pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
Matt Fleming83e68182012-11-14 09:42:35 +0000500 else {
Dave Youngb2e0a542014-08-14 17:15:26 +0800501 if (efi_runtime_disabled() || efi_runtime_init())
Matt Fleming83e68182012-11-14 09:42:35 +0000502 return;
Olof Johansson140bf272012-02-12 13:24:28 -0800503 }
Matt Fleming83e68182012-11-14 09:42:35 +0000504 if (efi_memmap_init())
Olof Johansson140bf272012-02-12 13:24:28 -0800505 return;
Matt Fleming83e68182012-11-14 09:42:35 +0000506
Borislav Petkovfed6cef2015-02-05 11:44:41 +0100507 if (efi_enabled(EFI_DBG))
Taku Izumi0bbea1c2015-09-30 19:20:00 +0900508 efi_print_memmap();
Peter Jones0bb54902015-04-28 18:44:31 -0400509
510 efi_esrt_init();
Huang, Ying5b836832008-01-30 13:31:19 +0100511}
512
Josh Triplett2223af32012-09-28 17:57:05 -0700513void __init efi_late_init(void)
514{
515 efi_bgrt_init();
516}
517
Matthew Garrett9cd2b072011-05-05 15:19:43 -0400518void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
519{
520 u64 addr, npages;
521
522 addr = md->virt_addr;
523 npages = md->num_pages;
524
525 memrange_efi_to_native(&addr, &npages);
526
527 if (executable)
528 set_memory_x(addr, npages);
529 else
530 set_memory_nx(addr, npages);
531}
532
Borislav Petkovc55d0162014-02-14 08:24:24 +0100533void __init runtime_code_page_mkexec(void)
Huang, Yinga2172e22008-01-30 13:33:55 +0100534{
535 efi_memory_desc_t *md;
Huang, Yinga2172e22008-01-30 13:33:55 +0100536
Huang, Yinga2172e22008-01-30 13:33:55 +0100537 /* Make EFI runtime service code area executable */
Matt Fleming78ce2482016-04-25 21:06:38 +0100538 for_each_efi_memory_desc(md) {
Huang, Ying1c083eb2008-02-04 16:48:06 +0100539 if (md->type != EFI_RUNTIME_SERVICES_CODE)
540 continue;
541
Matthew Garrett9cd2b072011-05-05 15:19:43 -0400542 efi_set_executable(md, true);
Huang, Yinga2172e22008-01-30 13:33:55 +0100543 }
Huang, Yinga2172e22008-01-30 13:33:55 +0100544}
Huang, Yinga2172e22008-01-30 13:33:55 +0100545
Mathias Krause4e78eb052014-09-07 19:42:17 +0200546void __init efi_memory_uc(u64 addr, unsigned long size)
Matt Fleming3e8fa262012-10-19 13:25:46 +0100547{
548 unsigned long page_shift = 1UL << EFI_PAGE_SHIFT;
549 u64 npages;
550
551 npages = round_up(size, page_shift) / page_shift;
552 memrange_efi_to_native(&addr, &npages);
553 set_memory_uc(addr, npages);
554}
555
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +0100556void __init old_map_region(efi_memory_desc_t *md)
557{
558 u64 start_pfn, end_pfn, end;
559 unsigned long size;
560 void *va;
561
562 start_pfn = PFN_DOWN(md->phys_addr);
563 size = md->num_pages << PAGE_SHIFT;
564 end = md->phys_addr + size;
565 end_pfn = PFN_UP(end);
566
567 if (pfn_range_is_mapped(start_pfn, end_pfn)) {
568 va = __va(md->phys_addr);
569
570 if (!(md->attribute & EFI_MEMORY_WB))
571 efi_memory_uc((u64)(unsigned long)va, size);
572 } else
573 va = efi_ioremap(md->phys_addr, size,
574 md->type, md->attribute);
575
576 md->virt_addr = (u64) (unsigned long) va;
577 if (!va)
578 pr_err("ioremap of 0x%llX failed!\n",
579 (unsigned long long)md->phys_addr);
580}
581
Dave Young481f75c2013-12-20 18:02:16 +0800582/* Merge contiguous regions of the same type and attribute */
583static void __init efi_merge_regions(void)
Huang, Ying5b836832008-01-30 13:31:19 +0100584{
Matthew Garrett202f9d02011-05-05 15:19:44 -0400585 efi_memory_desc_t *md, *prev_md = NULL;
Huang, Ying5b836832008-01-30 13:31:19 +0100586
Matt Fleming78ce2482016-04-25 21:06:38 +0100587 for_each_efi_memory_desc(md) {
Matthew Garrett202f9d02011-05-05 15:19:44 -0400588 u64 prev_size;
Matthew Garrett202f9d02011-05-05 15:19:44 -0400589
590 if (!prev_md) {
591 prev_md = md;
592 continue;
593 }
594
595 if (prev_md->type != md->type ||
596 prev_md->attribute != md->attribute) {
597 prev_md = md;
598 continue;
599 }
600
601 prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;
602
603 if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
604 prev_md->num_pages += md->num_pages;
605 md->type = EFI_RESERVED_TYPE;
606 md->attribute = 0;
607 continue;
608 }
609 prev_md = md;
610 }
Dave Young481f75c2013-12-20 18:02:16 +0800611}
612
613static void __init get_systab_virt_addr(efi_memory_desc_t *md)
614{
615 unsigned long size;
616 u64 end, systab;
617
618 size = md->num_pages << EFI_PAGE_SHIFT;
619 end = md->phys_addr + size;
620 systab = (u64)(unsigned long)efi_phys.systab;
621 if (md->phys_addr <= systab && systab < end) {
622 systab += md->virt_addr - md->phys_addr;
623 efi.systab = (efi_system_table_t *)(unsigned long)systab;
624 }
625}
626
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100627static void __init save_runtime_map(void)
Dave Young926172d2013-12-20 18:02:18 +0800628{
Dave Young2965faa2015-09-09 15:38:55 -0700629#ifdef CONFIG_KEXEC_CORE
Matt Fleming884f4f62016-04-25 21:06:39 +0100630 unsigned long desc_size;
Dave Young926172d2013-12-20 18:02:18 +0800631 efi_memory_desc_t *md;
Matt Fleming78ce2482016-04-25 21:06:38 +0100632 void *tmp, *q = NULL;
Dave Young926172d2013-12-20 18:02:18 +0800633 int count = 0;
634
Dave Younga3530e82014-05-30 11:20:10 +0800635 if (efi_enabled(EFI_OLD_MEMMAP))
636 return;
637
Matt Fleming884f4f62016-04-25 21:06:39 +0100638 desc_size = efi.memmap.desc_size;
639
Matt Fleming78ce2482016-04-25 21:06:38 +0100640 for_each_efi_memory_desc(md) {
Dave Young926172d2013-12-20 18:02:18 +0800641 if (!(md->attribute & EFI_MEMORY_RUNTIME) ||
642 (md->type == EFI_BOOT_SERVICES_CODE) ||
643 (md->type == EFI_BOOT_SERVICES_DATA))
644 continue;
Matt Fleming884f4f62016-04-25 21:06:39 +0100645 tmp = krealloc(q, (count + 1) * desc_size, GFP_KERNEL);
Dave Young926172d2013-12-20 18:02:18 +0800646 if (!tmp)
647 goto out;
648 q = tmp;
649
Matt Fleming884f4f62016-04-25 21:06:39 +0100650 memcpy(q + count * desc_size, md, desc_size);
Dave Young926172d2013-12-20 18:02:18 +0800651 count++;
652 }
653
Matt Fleming884f4f62016-04-25 21:06:39 +0100654 efi_runtime_map_setup(q, count, desc_size);
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100655 return;
Dave Young926172d2013-12-20 18:02:18 +0800656
Dave Young926172d2013-12-20 18:02:18 +0800657out:
658 kfree(q);
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100659 pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
660#endif
Dave Young1fec0532013-12-20 18:02:19 +0800661}
662
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100663static void *realloc_pages(void *old_memmap, int old_shift)
Dave Young481f75c2013-12-20 18:02:16 +0800664{
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100665 void *ret;
666
667 ret = (void *)__get_free_pages(GFP_KERNEL, old_shift + 1);
668 if (!ret)
669 goto out;
670
671 /*
672 * A first-time allocation doesn't have anything to copy.
673 */
674 if (!old_memmap)
675 return ret;
676
677 memcpy(ret, old_memmap, PAGE_SIZE << old_shift);
678
679out:
680 free_pages((unsigned long)old_memmap, old_shift);
681 return ret;
682}
683
684/*
Matt Fleminga5caa202015-09-25 23:02:18 +0100685 * Iterate the EFI memory map in reverse order because the regions
686 * will be mapped top-down. The end result is the same as if we had
687 * mapped things forward, but doesn't require us to change the
688 * existing implementation of efi_map_region().
689 */
690static inline void *efi_map_next_entry_reverse(void *entry)
691{
692 /* Initial call */
693 if (!entry)
Matt Fleming884f4f62016-04-25 21:06:39 +0100694 return efi.memmap.map_end - efi.memmap.desc_size;
Matt Fleminga5caa202015-09-25 23:02:18 +0100695
Matt Fleming884f4f62016-04-25 21:06:39 +0100696 entry -= efi.memmap.desc_size;
697 if (entry < efi.memmap.map)
Matt Fleminga5caa202015-09-25 23:02:18 +0100698 return NULL;
699
700 return entry;
701}
702
703/*
704 * efi_map_next_entry - Return the next EFI memory map descriptor
705 * @entry: Previous EFI memory map descriptor
706 *
707 * This is a helper function to iterate over the EFI memory map, which
708 * we do in different orders depending on the current configuration.
709 *
710 * To begin traversing the memory map @entry must be %NULL.
711 *
712 * Returns %NULL when we reach the end of the memory map.
713 */
714static void *efi_map_next_entry(void *entry)
715{
716 if (!efi_enabled(EFI_OLD_MEMMAP) && efi_enabled(EFI_64BIT)) {
717 /*
718 * Starting in UEFI v2.5 the EFI_PROPERTIES_TABLE
719 * config table feature requires us to map all entries
720 * in the same order as they appear in the EFI memory
721 * map. That is to say, entry N must have a lower
722 * virtual address than entry N+1. This is because the
723 * firmware toolchain leaves relative references in
724 * the code/data sections, which are split and become
725 * separate EFI memory regions. Mapping things
726 * out-of-order leads to the firmware accessing
727 * unmapped addresses.
728 *
729 * Since we need to map things this way whether or not
730 * the kernel actually makes use of
731 * EFI_PROPERTIES_TABLE, let's just switch to this
732 * scheme by default for 64-bit.
733 */
734 return efi_map_next_entry_reverse(entry);
735 }
736
737 /* Initial call */
738 if (!entry)
Matt Fleming884f4f62016-04-25 21:06:39 +0100739 return efi.memmap.map;
Matt Fleminga5caa202015-09-25 23:02:18 +0100740
Matt Fleming884f4f62016-04-25 21:06:39 +0100741 entry += efi.memmap.desc_size;
742 if (entry >= efi.memmap.map_end)
Matt Fleminga5caa202015-09-25 23:02:18 +0100743 return NULL;
744
745 return entry;
746}
747
748/*
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100749 * Map the efi memory ranges of the runtime services and update new_mmap with
750 * virtual addresses.
751 */
752static void * __init efi_map_regions(int *count, int *pg_shift)
753{
754 void *p, *new_memmap = NULL;
755 unsigned long left = 0;
Matt Fleming884f4f62016-04-25 21:06:39 +0100756 unsigned long desc_size;
Dave Young481f75c2013-12-20 18:02:16 +0800757 efi_memory_desc_t *md;
Matthew Garrett202f9d02011-05-05 15:19:44 -0400758
Matt Fleming884f4f62016-04-25 21:06:39 +0100759 desc_size = efi.memmap.desc_size;
760
Matt Fleminga5caa202015-09-25 23:02:18 +0100761 p = NULL;
762 while ((p = efi_map_next_entry(p))) {
Huang, Ying5b836832008-01-30 13:31:19 +0100763 md = p;
Josh Boyer70087012013-04-18 07:51:34 -0700764 if (!(md->attribute & EFI_MEMORY_RUNTIME)) {
765#ifdef CONFIG_X86_64
766 if (md->type != EFI_BOOT_SERVICES_CODE &&
767 md->type != EFI_BOOT_SERVICES_DATA)
768#endif
769 continue;
770 }
Huang, Ying1c083eb2008-02-04 16:48:06 +0100771
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +0100772 efi_map_region(md);
Dave Young481f75c2013-12-20 18:02:16 +0800773 get_systab_virt_addr(md);
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +0100774
Matt Fleming884f4f62016-04-25 21:06:39 +0100775 if (left < desc_size) {
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100776 new_memmap = realloc_pages(new_memmap, *pg_shift);
777 if (!new_memmap)
778 return NULL;
779
780 left += PAGE_SIZE << *pg_shift;
781 (*pg_shift)++;
782 }
783
Matt Fleming884f4f62016-04-25 21:06:39 +0100784 memcpy(new_memmap + (*count * desc_size), md, desc_size);
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100785
Matt Fleming884f4f62016-04-25 21:06:39 +0100786 left -= desc_size;
Dave Young481f75c2013-12-20 18:02:16 +0800787 (*count)++;
788 }
789
790 return new_memmap;
Dave Young481f75c2013-12-20 18:02:16 +0800791}
792
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100793static void __init kexec_enter_virtual_mode(void)
794{
Dave Young2965faa2015-09-09 15:38:55 -0700795#ifdef CONFIG_KEXEC_CORE
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100796 efi_memory_desc_t *md;
Matt Fleming753b11e2016-01-21 14:11:59 +0000797 unsigned int num_pages;
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100798
799 efi.systab = NULL;
800
801 /*
802 * We don't do virtual mode, since we don't do runtime services, on
803 * non-native EFI
804 */
805 if (!efi_is_native()) {
806 efi_unmap_memmap();
Dave Younga5a750a2014-08-14 17:15:31 +0800807 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100808 return;
809 }
810
Matt Fleming753b11e2016-01-21 14:11:59 +0000811 if (efi_alloc_page_tables()) {
812 pr_err("Failed to allocate EFI page tables\n");
813 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
814 return;
815 }
816
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100817 /*
818 * Map efi regions which were passed via setup_data. The virt_addr is a
819 * fixed addr which was used in first kernel of a kexec boot.
820 */
Matt Fleming78ce2482016-04-25 21:06:38 +0100821 for_each_efi_memory_desc(md) {
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100822 efi_map_region_fixed(md); /* FIXME: add error handling */
823 get_systab_virt_addr(md);
824 }
825
826 save_runtime_map();
827
828 BUG_ON(!efi.systab);
829
Matt Fleming884f4f62016-04-25 21:06:39 +0100830 num_pages = ALIGN(efi.memmap.nr_map * efi.memmap.desc_size, PAGE_SIZE);
Matt Fleming753b11e2016-01-21 14:11:59 +0000831 num_pages >>= PAGE_SHIFT;
832
Matt Fleming884f4f62016-04-25 21:06:39 +0100833 if (efi_setup_page_tables(efi.memmap.phys_map, num_pages)) {
Matt Fleming753b11e2016-01-21 14:11:59 +0000834 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
835 return;
836 }
837
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100838 efi_sync_low_kernel_mappings();
839
840 /*
841 * Now that EFI is in virtual mode, update the function
842 * pointers in the runtime service table to the new virtual addresses.
843 *
844 * Call EFI services through wrapper functions.
845 */
846 efi.runtime_version = efi_systab.hdr.revision;
Matt Fleming994448f2014-03-05 18:15:37 +0000847
Ard Biesheuvel022ee6c2014-06-26 12:09:05 +0200848 efi_native_runtime_setup();
Matt Fleming994448f2014-03-05 18:15:37 +0000849
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100850 efi.set_virtual_address_map = NULL;
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100851
852 if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))
853 runtime_code_page_mkexec();
854
855 /* clean DUMMY object */
Saurabh Tangrieeb9db02014-06-02 05:18:35 -0700856 efi_delete_dummy_variable();
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100857#endif
858}
859
Dave Young481f75c2013-12-20 18:02:16 +0800860/*
861 * This function will switch the EFI runtime services to virtual mode.
862 * Essentially, we look through the EFI memmap and map every region that
863 * has the runtime attribute bit set in its memory descriptor into the
Matt Fleming67a91082015-11-27 21:09:34 +0000864 * efi_pgd page table.
Dave Young481f75c2013-12-20 18:02:16 +0800865 *
866 * The old method which used to update that memory descriptor with the
867 * virtual address obtained from ioremap() is still supported when the
868 * kernel is booted with efi=old_map on its command line. Same old
869 * method enabled the runtime services to be called without having to
870 * thunk back into physical mode for every invocation.
871 *
872 * The new method does a pagetable switch in a preemption-safe manner
873 * so that we're in a different address space when calling a runtime
Matt Fleming67a91082015-11-27 21:09:34 +0000874 * function. For function arguments passing we do copy the PUDs of the
875 * kernel page table into efi_pgd prior to each call.
Dave Young1fec0532013-12-20 18:02:19 +0800876 *
877 * Specially for kexec boot, efi runtime maps in previous kernel should
878 * be passed in via setup_data. In that case runtime ranges will be mapped
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100879 * to the same virtual addresses as the first kernel, see
880 * kexec_enter_virtual_mode().
Dave Young481f75c2013-12-20 18:02:16 +0800881 */
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100882static void __init __efi_enter_virtual_mode(void)
Dave Young481f75c2013-12-20 18:02:16 +0800883{
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100884 int count = 0, pg_shift = 0;
Dave Young481f75c2013-12-20 18:02:16 +0800885 void *new_memmap = NULL;
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100886 efi_status_t status;
Dave Young481f75c2013-12-20 18:02:16 +0800887
888 efi.systab = NULL;
889
Matt Fleming67a91082015-11-27 21:09:34 +0000890 if (efi_alloc_page_tables()) {
891 pr_err("Failed to allocate EFI page tables\n");
892 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
893 return;
894 }
895
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100896 efi_merge_regions();
897 new_memmap = efi_map_regions(&count, &pg_shift);
898 if (!new_memmap) {
899 pr_err("Error reallocating memory, EFI runtime non-functional!\n");
Dave Younga5a750a2014-08-14 17:15:31 +0800900 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100901 return;
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100902 }
Dave Young926172d2013-12-20 18:02:18 +0800903
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100904 save_runtime_map();
905
Huang, Ying5b836832008-01-30 13:31:19 +0100906 BUG_ON(!efi.systab);
907
Dave Younga5a750a2014-08-14 17:15:31 +0800908 if (efi_setup_page_tables(__pa(new_memmap), 1 << pg_shift)) {
909 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100910 return;
Dave Younga5a750a2014-08-14 17:15:31 +0800911 }
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100912
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +0100913 efi_sync_low_kernel_mappings();
914
Matt Fleming994448f2014-03-05 18:15:37 +0000915 if (efi_is_native()) {
916 status = phys_efi_set_virtual_address_map(
Matt Fleming884f4f62016-04-25 21:06:39 +0100917 efi.memmap.desc_size * count,
918 efi.memmap.desc_size,
919 efi.memmap.desc_version,
Matt Fleming994448f2014-03-05 18:15:37 +0000920 (efi_memory_desc_t *)__pa(new_memmap));
921 } else {
922 status = efi_thunk_set_virtual_address_map(
923 efi_phys.set_virtual_address_map,
Matt Fleming884f4f62016-04-25 21:06:39 +0100924 efi.memmap.desc_size * count,
925 efi.memmap.desc_size,
926 efi.memmap.desc_version,
Matt Fleming994448f2014-03-05 18:15:37 +0000927 (efi_memory_desc_t *)__pa(new_memmap));
928 }
Huang, Ying5b836832008-01-30 13:31:19 +0100929
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100930 if (status != EFI_SUCCESS) {
931 pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n",
932 status);
933 panic("EFI call to SetVirtualAddressMap() failed!");
Huang, Ying5b836832008-01-30 13:31:19 +0100934 }
935
936 /*
937 * Now that EFI is in virtual mode, update the function
938 * pointers in the runtime service table to the new virtual addresses.
939 *
940 * Call EFI services through wrapper functions.
941 */
Matt Fleming712ba9e2013-01-25 10:07:25 +0000942 efi.runtime_version = efi_systab.hdr.revision;
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000943
944 if (efi_is_native())
Ard Biesheuvel022ee6c2014-06-26 12:09:05 +0200945 efi_native_runtime_setup();
Matt Fleming4f9dbcf2014-01-10 18:48:30 +0000946 else
947 efi_thunk_runtime_setup();
948
Matthew Garrett2b5e8ef2011-05-05 15:19:42 -0400949 efi.set_virtual_address_map = NULL;
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +0100950
Sai Praneeth6d0cc882016-02-17 12:36:05 +0000951 /*
952 * Apply more restrictive page table mapping attributes now that
953 * SVAM() has been called and the firmware has performed all
954 * necessary relocation fixups for the new virtual addresses.
955 */
956 efi_runtime_update_mappings();
957 efi_dump_pagetable();
Olof Johansson1adbfa32012-02-12 13:24:29 -0800958
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100959 /*
Matt Fleming67a91082015-11-27 21:09:34 +0000960 * We mapped the descriptor array into the EFI pagetable above
961 * but we're not unmapping it here because if we're running in
962 * EFI mixed mode we need all of memory to be accessible when
963 * we pass parameters to the EFI runtime services in the
964 * thunking code.
Borislav Petkovb7b898a2014-01-18 12:48:17 +0100965 */
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100966 free_pages((unsigned long)new_memmap, pg_shift);
Matthew Garrettf8b84042013-06-01 16:06:20 -0400967
968 /* clean DUMMY object */
Saurabh Tangrieeb9db02014-06-02 05:18:35 -0700969 efi_delete_dummy_variable();
Huang, Ying5b836832008-01-30 13:31:19 +0100970}
971
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100972void __init efi_enter_virtual_mode(void)
973{
Daniel Kiper9f27bc52014-06-30 19:52:58 +0200974 if (efi_enabled(EFI_PARAVIRT))
975 return;
976
Borislav Petkovfabb37c2014-01-18 12:48:18 +0100977 if (efi_setup)
978 kexec_enter_virtual_mode();
979 else
980 __efi_enter_virtual_mode();
981}
982
Huang, Ying5b836832008-01-30 13:31:19 +0100983/*
984 * Convenience functions to obtain memory types and attributes
985 */
986u32 efi_mem_type(unsigned long phys_addr)
987{
988 efi_memory_desc_t *md;
Huang, Ying5b836832008-01-30 13:31:19 +0100989
Matt Fleming83e68182012-11-14 09:42:35 +0000990 if (!efi_enabled(EFI_MEMMAP))
991 return 0;
992
Matt Fleming78ce2482016-04-25 21:06:38 +0100993 for_each_efi_memory_desc(md) {
Huang, Ying5b836832008-01-30 13:31:19 +0100994 if ((md->phys_addr <= phys_addr) &&
995 (phys_addr < (md->phys_addr +
996 (md->num_pages << EFI_PAGE_SHIFT))))
997 return md->type;
998 }
999 return 0;
1000}
1001
Dave Young5ae36832014-08-14 17:15:28 +08001002static int __init arch_parse_efi_cmdline(char *str)
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +01001003{
Ricardo Neri9115c752015-07-15 19:36:03 -07001004 if (!str) {
1005 pr_warn("need at least one option\n");
1006 return -EINVAL;
1007 }
1008
Dave Young6ccc72b2014-08-14 17:15:27 +08001009 if (parse_option_str(str, "old_map"))
1010 set_bit(EFI_OLD_MEMMAP, &efi.flags);
Borislav Petkovd2f7cbe2013-10-31 17:25:08 +01001011
1012 return 0;
1013}
Dave Young5ae36832014-08-14 17:15:28 +08001014early_param("efi", arch_parse_efi_cmdline);