efi.c 33.1 KB
Newer Older
Huang, Ying's avatar
Huang, Ying committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * Common EFI (Extensible Firmware Interface) support functions
 * Based on Extensible Firmware Interface Specification version 1.0
 *
 * Copyright (C) 1999 VA Linux Systems
 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
 * Copyright (C) 1999-2002 Hewlett-Packard Co.
 *	David Mosberger-Tang <davidm@hpl.hp.com>
 *	Stephane Eranian <eranian@hpl.hp.com>
 * Copyright (C) 2005-2008 Intel Co.
 *	Fenghua Yu <fenghua.yu@intel.com>
 *	Bibo Mao <bibo.mao@intel.com>
 *	Chandramouli Narayanan <mouli@linux.intel.com>
 *	Huang Ying <ying.huang@intel.com>
15 16
 * Copyright (C) 2013 SuSE Labs
 *	Borislav Petkov <bp@suse.de> - runtime services VA mapping
Huang, Ying's avatar
Huang, Ying committed
17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 * Copied from efi_32.c to eliminate the duplicated code between EFI
 * 32/64 support code. --ying 2007-10-26
 *
 * All EFI Runtime Services are not implemented yet as EFI only
 * supports physical mode addressing on SoftSDV. This is to be fixed
 * in a future version.  --drummond 1999-07-20
 *
 * Implemented EFI runtime services and virtual mode calls.  --davidm
 *
 * Goutham Rao: <goutham.rao@intel.com>
 *	Skip non-WB memory and ignore empty memory ranges.
 */

31 32
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Huang, Ying's avatar
Huang, Ying committed
33 34 35
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/efi.h>
36
#include <linux/efi-bgrt.h>
37
#include <linux/export.h>
Huang, Ying's avatar
Huang, Ying committed
38
#include <linux/bootmem.h>
39
#include <linux/slab.h>
40
#include <linux/memblock.h>
Huang, Ying's avatar
Huang, Ying committed
41 42 43 44 45 46 47 48 49 50
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/time.h>
#include <linux/io.h>
#include <linux/reboot.h>
#include <linux/bcd.h>

#include <asm/setup.h>
#include <asm/efi.h>
#include <asm/time.h>
51 52
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
53
#include <asm/x86_init.h>
54
#include <asm/rtc.h>
Borislav Petkov's avatar
Borislav Petkov committed
55
#include <asm/uv/uv.h>
Huang, Ying's avatar
Huang, Ying committed
56

Borislav Petkov's avatar
Borislav Petkov committed
57
#define EFI_DEBUG
Huang, Ying's avatar
Huang, Ying committed
58

59 60 61 62 63 64
#define EFI_MIN_RESERVE 5120

#define EFI_DUMMY_GUID \
	EFI_GUID(0x4424ac57, 0xbe4b, 0x47dd, 0x9e, 0x97, 0xed, 0x50, 0xf0, 0x9f, 0x92, 0xa9)

static efi_char16_t efi_dummy_name[6] = { 'D', 'U', 'M', 'M', 'Y', 0 };
65

Huang, Ying's avatar
Huang, Ying committed
66 67
struct efi_memory_map memmap;

Harvey Harrison's avatar
Harvey Harrison committed
68
static struct efi efi_phys __initdata;
Huang, Ying's avatar
Huang, Ying committed
69 70
static efi_system_table_t efi_systab __initdata;

Joe Perches's avatar
Joe Perches committed
71
static efi_config_table_type_t arch_tables[] __initdata = {
72 73 74
#ifdef CONFIG_X86_UV
	{UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab},
#endif
75
	{NULL_GUID, NULL, NULL},
76 77
};

78
u64 efi_setup;		/* efi setup_data physical address */
79

Joe Perches's avatar
Joe Perches committed
80
static bool disable_runtime __initdata = false;
81 82
static int __init setup_noefi(char *arg)
{
83
	disable_runtime = true;
84 85 86 87
	return 0;
}
early_param("noefi", setup_noefi);

88 89 90 91 92 93 94 95 96 97
int add_efi_memmap;
EXPORT_SYMBOL(add_efi_memmap);

static int __init setup_add_efi_memmap(char *arg)
{
	add_efi_memmap = 1;
	return 0;
}
early_param("add_efi_memmap", setup_add_efi_memmap);

98 99 100 101 102 103 104 105 106
static bool efi_no_storage_paranoia;

static int __init setup_storage_paranoia(char *arg)
{
	efi_no_storage_paranoia = true;
	return 0;
}
early_param("efi_no_storage_paranoia", setup_storage_paranoia);

Huang, Ying's avatar
Huang, Ying committed
107 108
static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
{
109 110 111 112
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
113
	status = efi_call_virt(get_time, tm, tc);
114 115
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
116 117 118 119
}

static efi_status_t virt_efi_set_time(efi_time_t *tm)
{
120 121 122 123
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
124
	status = efi_call_virt(set_time, tm);
125 126
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
127 128 129 130 131 132
}

static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
					     efi_bool_t *pending,
					     efi_time_t *tm)
{
133 134 135 136
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
137
	status = efi_call_virt(get_wakeup_time, enabled, pending, tm);
138 139
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
140 141 142 143
}

static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
{
144 145 146 147
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
148
	status = efi_call_virt(set_wakeup_time, enabled, tm);
149 150
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
151 152 153 154 155 156 157 158
}

static efi_status_t virt_efi_get_variable(efi_char16_t *name,
					  efi_guid_t *vendor,
					  u32 *attr,
					  unsigned long *data_size,
					  void *data)
{
159 160 161
	return efi_call_virt(get_variable,
			     name, vendor, attr,
			     data_size, data);
Huang, Ying's avatar
Huang, Ying committed
162 163 164 165 166 167
}

static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
					       efi_char16_t *name,
					       efi_guid_t *vendor)
{
168 169
	return efi_call_virt(get_next_variable,
			     name_size, name, vendor);
Huang, Ying's avatar
Huang, Ying committed
170 171 172 173
}

static efi_status_t virt_efi_set_variable(efi_char16_t *name,
					  efi_guid_t *vendor,
174
					  u32 attr,
Huang, Ying's avatar
Huang, Ying committed
175 176 177
					  unsigned long data_size,
					  void *data)
{
178 179 180
	return efi_call_virt(set_variable,
			     name, vendor, attr,
			     data_size, data);
Huang, Ying's avatar
Huang, Ying committed
181 182
}

183 184 185 186 187 188 189 190
static efi_status_t virt_efi_query_variable_info(u32 attr,
						 u64 *storage_space,
						 u64 *remaining_space,
						 u64 *max_variable_size)
{
	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

191 192
	return efi_call_virt(query_variable_info, attr, storage_space,
			     remaining_space, max_variable_size);
193 194
}

Huang, Ying's avatar
Huang, Ying committed
195 196
static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
{
197
	return efi_call_virt(get_next_high_mono_count, count);
Huang, Ying's avatar
Huang, Ying committed
198 199 200 201 202 203 204
}

static void virt_efi_reset_system(int reset_type,
				  efi_status_t status,
				  unsigned long data_size,
				  efi_char16_t *data)
{
205 206
	__efi_call_virt(reset_system, reset_type, status,
			data_size, data);
Huang, Ying's avatar
Huang, Ying committed
207 208
}

209 210 211 212 213 214 215
static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
					    unsigned long count,
					    unsigned long sg_list)
{
	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

216
	return efi_call_virt(update_capsule, capsules, count, sg_list);
217 218 219 220 221 222 223 224 225 226
}

static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
						unsigned long count,
						u64 *max_size,
						int *reset_type)
{
	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

227 228
	return efi_call_virt(query_capsule_caps, capsules, count, max_size,
			     reset_type);
229 230
}

Huang, Ying's avatar
Huang, Ying committed
231 232 233 234 235 236 237 238 239
static efi_status_t __init phys_efi_set_virtual_address_map(
	unsigned long memory_map_size,
	unsigned long descriptor_size,
	u32 descriptor_version,
	efi_memory_desc_t *virtual_map)
{
	efi_status_t status;

	efi_call_phys_prelog();
240 241 242
	status = efi_call_phys(efi_phys.set_virtual_address_map,
			       memory_map_size, descriptor_size,
			       descriptor_version, virtual_map);
Huang, Ying's avatar
Huang, Ying committed
243 244 245 246
	efi_call_phys_epilog();
	return status;
}

247
int efi_set_rtc_mmss(const struct timespec *now)
Huang, Ying's avatar
Huang, Ying committed
248
{
249
	unsigned long nowtime = now->tv_sec;
Joe Perches's avatar
Joe Perches committed
250 251 252
	efi_status_t	status;
	efi_time_t	eft;
	efi_time_cap_t	cap;
253
	struct rtc_time	tm;
Huang, Ying's avatar
Huang, Ying committed
254 255 256

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS) {
257
		pr_err("Oops: efitime: can't read time!\n");
Huang, Ying's avatar
Huang, Ying committed
258 259 260
		return -1;
	}

261 262 263 264 265 266 267 268 269
	rtc_time_to_tm(nowtime, &tm);
	if (!rtc_valid_tm(&tm)) {
		eft.year = tm.tm_year + 1900;
		eft.month = tm.tm_mon + 1;
		eft.day = tm.tm_mday;
		eft.minute = tm.tm_min;
		eft.second = tm.tm_sec;
		eft.nanosecond = 0;
	} else {
Joe Perches's avatar
Joe Perches committed
270 271
		pr_err("%s: Invalid EFI RTC value: write of %lx to EFI RTC failed\n",
		       __func__, nowtime);
272 273
		return -1;
	}
Huang, Ying's avatar
Huang, Ying committed
274 275 276

	status = efi.set_time(&eft);
	if (status != EFI_SUCCESS) {
277
		pr_err("Oops: efitime: can't write time!\n");
Huang, Ying's avatar
Huang, Ying committed
278 279 280 281 282
		return -1;
	}
	return 0;
}

283
void efi_get_time(struct timespec *now)
Huang, Ying's avatar
Huang, Ying committed
284 285 286 287 288 289 290
{
	efi_status_t status;
	efi_time_t eft;
	efi_time_cap_t cap;

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS)
291
		pr_err("Oops: efitime: can't read time!\n");
Huang, Ying's avatar
Huang, Ying committed
292

293 294 295
	now->tv_sec = mktime(eft.year, eft.month, eft.day, eft.hour,
			     eft.minute, eft.second);
	now->tv_nsec = 0;
Huang, Ying's avatar
Huang, Ying committed
296 297
}

298 299 300 301 302 303
/*
 * Tell the kernel about the EFI memory map.  This might include
 * more than the max 128 entries that can fit in the e820 legacy
 * (zeropage) memory map.
 */

304
static void __init do_add_efi_memmap(void)
305 306 307 308 309 310 311 312 313
{
	void *p;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
		unsigned long long start = md->phys_addr;
		unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
		int e820_type;

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
		switch (md->type) {
		case EFI_LOADER_CODE:
		case EFI_LOADER_DATA:
		case EFI_BOOT_SERVICES_CODE:
		case EFI_BOOT_SERVICES_DATA:
		case EFI_CONVENTIONAL_MEMORY:
			if (md->attribute & EFI_MEMORY_WB)
				e820_type = E820_RAM;
			else
				e820_type = E820_RESERVED;
			break;
		case EFI_ACPI_RECLAIM_MEMORY:
			e820_type = E820_ACPI;
			break;
		case EFI_ACPI_MEMORY_NVS:
			e820_type = E820_NVS;
			break;
		case EFI_UNUSABLE_MEMORY:
			e820_type = E820_UNUSABLE;
			break;
		default:
			/*
			 * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE
			 * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
			 * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
			 */
340
			e820_type = E820_RESERVED;
341 342
			break;
		}
343
		e820_add_region(start, size, e820_type);
344 345 346 347
	}
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

348
int __init efi_memblock_x86_reserve_range(void)
349
{
350
	struct efi_info *e = &boot_params.efi_info;
351 352
	unsigned long pmap;

353
#ifdef CONFIG_X86_32
354
	/* Can't handle data above 4GB at this time */
355
	if (e->efi_memmap_hi) {
356 357 358
		pr_err("Memory map is above 4GB, disabling EFI.\n");
		return -EINVAL;
	}
359
	pmap =  e->efi_memmap;
360
#else
361
	pmap = (e->efi_memmap |	((__u64)e->efi_memmap_hi << 32));
362
#endif
363 364 365 366 367 368
	memmap.phys_map		= (void *)pmap;
	memmap.nr_map		= e->efi_memmap_size /
				  e->efi_memdesc_size;
	memmap.desc_size	= e->efi_memdesc_size;
	memmap.desc_version	= e->efi_memdesc_version;

369
	memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
370

371 372
	efi.memmap = &memmap;

373
	return 0;
374 375
}

Huang, Ying's avatar
Huang, Ying committed
376 377
static void __init print_efi_memmap(void)
{
Borislav Petkov's avatar
Borislav Petkov committed
378
#ifdef EFI_DEBUG
Huang, Ying's avatar
Huang, Ying committed
379 380 381 382 383 384 385 386
	efi_memory_desc_t *md;
	void *p;
	int i;

	for (p = memmap.map, i = 0;
	     p < memmap.map_end;
	     p += memmap.desc_size, i++) {
		md = p;
Joe Perches's avatar
Joe Perches committed
387
		pr_info("mem%02u: type=%u, attr=0x%llx, range=[0x%016llx-0x%016llx) (%lluMB)\n",
Huang, Ying's avatar
Huang, Ying committed
388 389 390 391 392
			i, md->type, md->attribute, md->phys_addr,
			md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
			(md->num_pages >> (20 - EFI_PAGE_SHIFT)));
	}
#endif  /*  EFI_DEBUG  */
Borislav Petkov's avatar
Borislav Petkov committed
393
}
Huang, Ying's avatar
Huang, Ying committed
394

395 396 397 398 399 400
void __init efi_reserve_boot_services(void)
{
	void *p;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
401 402
		u64 start = md->phys_addr;
		u64 size = md->num_pages << EFI_PAGE_SHIFT;
403 404 405 406

		if (md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;
407 408 409 410 411 412
		/* Only reserve where possible:
		 * - Not within any already allocated areas
		 * - Not over any memory area (really needed, if above?)
		 * - Not within any part of the kernel
		 * - Not the bios reserved area
		*/
413
		if ((start + size > __pa_symbol(_text)
414
				&& start <= __pa_symbol(_end)) ||
415
			!e820_all_mapped(start, start+size, E820_RAM) ||
416
			memblock_is_region_reserved(start, size)) {
417 418
			/* Could not reserve, skip it */
			md->num_pages = 0;
Joe Perches's avatar
Joe Perches committed
419 420
			memblock_dbg("Could not reserve boot range [0x%010llx-0x%010llx]\n",
				     start, start+size-1);
421
		} else
422
			memblock_reserve(start, size);
423 424 425
	}
}

426
void __init efi_unmap_memmap(void)
427
{
428
	clear_bit(EFI_MEMMAP, &efi.flags);
429 430 431 432 433 434 435
	if (memmap.map) {
		early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
		memmap.map = NULL;
	}
}

void __init efi_free_boot_services(void)
436 437 438 439 440 441 442 443 444 445 446 447
{
	void *p;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
		unsigned long long start = md->phys_addr;
		unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;

		if (md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;

448 449 450 451
		/* Could not reserve boot area */
		if (!size)
			continue;

452 453
		free_bootmem_late(start, size);
	}
454 455

	efi_unmap_memmap();
456 457
}

458
static int __init efi_systab_init(void *phys)
Huang, Ying's avatar
Huang, Ying committed
459
{
460
	if (efi_enabled(EFI_64BIT)) {
461
		efi_system_table_64_t *systab64;
462
		struct efi_setup_data *data = NULL;
463 464
		u64 tmp = 0;

465 466 467 468 469
		if (efi_setup) {
			data = early_memremap(efi_setup, sizeof(*data));
			if (!data)
				return -ENOMEM;
		}
470 471 472 473
		systab64 = early_ioremap((unsigned long)phys,
					 sizeof(*systab64));
		if (systab64 == NULL) {
			pr_err("Couldn't map the system table!\n");
474 475
			if (data)
				early_iounmap(data, sizeof(*data));
476 477 478 479
			return -ENOMEM;
		}

		efi_systab.hdr = systab64->hdr;
480 481 482
		efi_systab.fw_vendor = data ? (unsigned long)data->fw_vendor :
					      systab64->fw_vendor;
		tmp |= data ? data->fw_vendor : systab64->fw_vendor;
483 484 485 486 487 488 489 490 491 492 493 494 495
		efi_systab.fw_revision = systab64->fw_revision;
		efi_systab.con_in_handle = systab64->con_in_handle;
		tmp |= systab64->con_in_handle;
		efi_systab.con_in = systab64->con_in;
		tmp |= systab64->con_in;
		efi_systab.con_out_handle = systab64->con_out_handle;
		tmp |= systab64->con_out_handle;
		efi_systab.con_out = systab64->con_out;
		tmp |= systab64->con_out;
		efi_systab.stderr_handle = systab64->stderr_handle;
		tmp |= systab64->stderr_handle;
		efi_systab.stderr = systab64->stderr;
		tmp |= systab64->stderr;
496 497 498 499
		efi_systab.runtime = data ?
				     (void *)(unsigned long)data->runtime :
				     (void *)(unsigned long)systab64->runtime;
		tmp |= data ? data->runtime : systab64->runtime;
500 501 502
		efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
		tmp |= systab64->boottime;
		efi_systab.nr_tables = systab64->nr_tables;
503 504 505
		efi_systab.tables = data ? (unsigned long)data->tables :
					   systab64->tables;
		tmp |= data ? data->tables : systab64->tables;
506 507

		early_iounmap(systab64, sizeof(*systab64));
508 509
		if (data)
			early_iounmap(data, sizeof(*data));
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
#ifdef CONFIG_X86_32
		if (tmp >> 32) {
			pr_err("EFI data located above 4GB, disabling EFI.\n");
			return -EINVAL;
		}
#endif
	} else {
		efi_system_table_32_t *systab32;

		systab32 = early_ioremap((unsigned long)phys,
					 sizeof(*systab32));
		if (systab32 == NULL) {
			pr_err("Couldn't map the system table!\n");
			return -ENOMEM;
		}

		efi_systab.hdr = systab32->hdr;
		efi_systab.fw_vendor = systab32->fw_vendor;
		efi_systab.fw_revision = systab32->fw_revision;
		efi_systab.con_in_handle = systab32->con_in_handle;
		efi_systab.con_in = systab32->con_in;
		efi_systab.con_out_handle = systab32->con_out_handle;
		efi_systab.con_out = systab32->con_out;
		efi_systab.stderr_handle = systab32->stderr_handle;
		efi_systab.stderr = systab32->stderr;
		efi_systab.runtime = (void *)(unsigned long)systab32->runtime;
		efi_systab.boottime = (void *)(unsigned long)systab32->boottime;
		efi_systab.nr_tables = systab32->nr_tables;
		efi_systab.tables = systab32->tables;

		early_iounmap(systab32, sizeof(*systab32));
541
	}
542

Huang, Ying's avatar
Huang, Ying committed
543 544 545 546 547
	efi.systab = &efi_systab;

	/*
	 * Verify the EFI Table
	 */
548
	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
549
		pr_err("System table signature incorrect!\n");
550 551
		return -EINVAL;
	}
Huang, Ying's avatar
Huang, Ying committed
552
	if ((efi.systab->hdr.revision >> 16) == 0)
Joe Perches's avatar
Joe Perches committed
553
		pr_err("Warning: System table version %d.%02d, expected 1.00 or greater!\n",
Huang, Ying's avatar
Huang, Ying committed
554 555
		       efi.systab->hdr.revision >> 16,
		       efi.systab->hdr.revision & 0xffff);
556

557 558
	set_bit(EFI_SYSTEM_TABLES, &efi.flags);

559
	return 0;
560
}
Huang, Ying's avatar
Huang, Ying committed
561

562
static int __init efi_runtime_init32(void)
563
{
564 565 566 567 568 569 570 571
	efi_runtime_services_32_t *runtime;

	runtime = early_ioremap((unsigned long)efi.systab->runtime,
			sizeof(efi_runtime_services_32_t));
	if (!runtime) {
		pr_err("Could not map the runtime service table!\n");
		return -ENOMEM;
	}
Huang, Ying's avatar
Huang, Ying committed
572 573

	/*
574 575 576
	 * We will only need *early* access to the following two
	 * EFI runtime services before set_virtual_address_map
	 * is invoked.
Huang, Ying's avatar
Huang, Ying committed
577
	 */
578 579 580 581 582 583 584 585 586 587 588 589
	efi_phys.set_virtual_address_map =
			(efi_set_virtual_address_map_t *)
			(unsigned long)runtime->set_virtual_address_map;
	early_iounmap(runtime, sizeof(efi_runtime_services_32_t));

	return 0;
}

static int __init efi_runtime_init64(void)
{
	efi_runtime_services_64_t *runtime;

590
	runtime = early_ioremap((unsigned long)efi.systab->runtime,
591
			sizeof(efi_runtime_services_64_t));
592
	if (!runtime) {
593
		pr_err("Could not map the runtime service table!\n");
594 595
		return -ENOMEM;
	}
596

597
	/*
598 599
	 * We will only need *early* access to the following two
	 * EFI runtime services before set_virtual_address_map
600 601 602
	 * is invoked.
	 */
	efi_phys.set_virtual_address_map =
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
			(efi_set_virtual_address_map_t *)
			(unsigned long)runtime->set_virtual_address_map;
	early_iounmap(runtime, sizeof(efi_runtime_services_64_t));

	return 0;
}

static int __init efi_runtime_init(void)
{
	int rv;

	/*
	 * Check out the runtime services table. We need to map
	 * the runtime services table so that we can grab the physical
	 * address of several of the EFI runtime functions, needed to
	 * set the firmware into virtual mode.
	 */
	if (efi_enabled(EFI_64BIT))
		rv = efi_runtime_init64();
	else
		rv = efi_runtime_init32();

	if (rv)
		return rv;
627

628 629
	set_bit(EFI_RUNTIME_SERVICES, &efi.flags);

630
	return 0;
631
}
Huang, Ying's avatar
Huang, Ying committed
632

633
static int __init efi_memmap_init(void)
634
{
Huang, Ying's avatar
Huang, Ying committed
635
	/* Map the EFI memory map */
636 637
	memmap.map = early_ioremap((unsigned long)memmap.phys_map,
				   memmap.nr_map * memmap.desc_size);
638
	if (memmap.map == NULL) {
639
		pr_err("Could not map the memory map!\n");
640 641
		return -ENOMEM;
	}
Huang, Ying's avatar
Huang, Ying committed
642
	memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
643

644 645
	if (add_efi_memmap)
		do_add_efi_memmap();
646

647 648
	set_bit(EFI_MEMMAP, &efi.flags);

649
	return 0;
650 651
}

652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
/*
 * A number of config table entries get remapped to virtual addresses
 * after entering EFI virtual mode. However, the kexec kernel requires
 * their physical addresses therefore we pass them via setup_data and
 * correct those entries to their respective physical addresses here.
 *
 * Currently only handles smbios which is necessary for some firmware
 * implementation.
 */
static int __init efi_reuse_config(u64 tables, int nr_tables)
{
	int i, sz, ret = 0;
	void *p, *tablep;
	struct efi_setup_data *data;

	if (!efi_setup)
		return 0;

	if (!efi_enabled(EFI_64BIT))
		return 0;

	data = early_memremap(efi_setup, sizeof(*data));
	if (!data) {
		ret = -ENOMEM;
		goto out;
	}

	if (!data->smbios)
		goto out_memremap;

	sz = sizeof(efi_config_table_64_t);

	p = tablep = early_memremap(tables, nr_tables * sz);
	if (!p) {
		pr_err("Could not map Configuration table!\n");
		ret = -ENOMEM;
		goto out_memremap;
	}

	for (i = 0; i < efi.systab->nr_tables; i++) {
		efi_guid_t guid;

		guid = ((efi_config_table_64_t *)p)->guid;

		if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID))
			((efi_config_table_64_t *)p)->table = data->smbios;
		p += sz;
	}
	early_iounmap(tablep, nr_tables * sz);

out_memremap:
	early_iounmap(data, sizeof(*data));
out:
	return ret;
}

708 709 710 711 712 713 714 715
void __init efi_init(void)
{
	efi_char16_t *c16;
	char vendor[100] = "unknown";
	int i = 0;
	void *tmp;

#ifdef CONFIG_X86_32
716 717 718 719 720
	if (boot_params.efi_info.efi_systab_hi ||
	    boot_params.efi_info.efi_memmap_hi) {
		pr_info("Table located above 4GB, disabling EFI.\n");
		return;
	}
721 722 723
	efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
#else
	efi_phys.systab = (efi_system_table_t *)
724 725
			  (boot_params.efi_info.efi_systab |
			  ((__u64)boot_params.efi_info.efi_systab_hi<<32));
726 727
#endif

728
	if (efi_systab_init(efi_phys.systab))
729
		return;
730

731
	set_bit(EFI_SYSTEM_TABLES, &efi.flags);
732

733 734 735 736
	efi.config_table = (unsigned long)efi.systab->tables;
	efi.fw_vendor	 = (unsigned long)efi.systab->fw_vendor;
	efi.runtime	 = (unsigned long)efi.systab->runtime;

737 738 739 740 741 742 743 744 745
	/*
	 * Show what we know for posterity
	 */
	c16 = tmp = early_ioremap(efi.systab->fw_vendor, 2);
	if (c16) {
		for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
			vendor[i] = *c16++;
		vendor[i] = '\0';
	} else
746
		pr_err("Could not map the firmware vendor!\n");
747 748
	early_iounmap(tmp, 2);

749 750 751
	pr_info("EFI v%u.%.02u by %s\n",
		efi.systab->hdr.revision >> 16,
		efi.systab->hdr.revision & 0xffff, vendor);
752

753 754 755
	if (efi_reuse_config(efi.systab->tables, efi.systab->nr_tables))
		return;

756
	if (efi_config_init(arch_tables))
757
		return;
758

759 760 761 762 763
	/*
	 * Note: We currently don't support runtime services on an EFI
	 * that doesn't match the kernel 32/64-bit mode.
	 */

764
	if (!efi_runtime_supported())
765
		pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
766
	else {
767
		if (disable_runtime || efi_runtime_init())
768
			return;
769
	}
770
	if (efi_memmap_init())
771
		return;
772

773
	set_bit(EFI_MEMMAP, &efi.flags);
774

Huang, Ying's avatar
Huang, Ying committed
775 776 777
	print_efi_memmap();
}

778 779 780 781 782
void __init efi_late_init(void)
{
	efi_bgrt_init();
}

783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
{
	u64 addr, npages;

	addr = md->virt_addr;
	npages = md->num_pages;

	memrange_efi_to_native(&addr, &npages);

	if (executable)
		set_memory_x(addr, npages);
	else
		set_memory_nx(addr, npages);
}

Borislav Petkov's avatar
Borislav Petkov committed
798
void __init runtime_code_page_mkexec(void)
799 800 801 802 803 804 805
{
	efi_memory_desc_t *md;
	void *p;

	/* Make EFI runtime service code area executable */
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
Huang, Ying's avatar
Huang, Ying committed
806 807 808 809

		if (md->type != EFI_RUNTIME_SERVICES_CODE)
			continue;

810
		efi_set_executable(md, true);
811 812 813
	}
}

814 815 816 817 818 819 820 821 822 823
void efi_memory_uc(u64 addr, unsigned long size)
{
	unsigned long page_shift = 1UL << EFI_PAGE_SHIFT;
	u64 npages;

	npages = round_up(size, page_shift) / page_shift;
	memrange_efi_to_native(&addr, &npages);
	set_memory_uc(addr, npages);
}

824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
void __init old_map_region(efi_memory_desc_t *md)
{
	u64 start_pfn, end_pfn, end;
	unsigned long size;
	void *va;

	start_pfn = PFN_DOWN(md->phys_addr);
	size	  = md->num_pages << PAGE_SHIFT;
	end	  = md->phys_addr + size;
	end_pfn   = PFN_UP(end);

	if (pfn_range_is_mapped(start_pfn, end_pfn)) {
		va = __va(md->phys_addr);

		if (!(md->attribute & EFI_MEMORY_WB))
			efi_memory_uc((u64)(unsigned long)va, size);
	} else
		va = efi_ioremap(md->phys_addr, size,
				 md->type, md->attribute);

	md->virt_addr = (u64) (unsigned long) va;
	if (!va)
		pr_err("ioremap of 0x%llX failed!\n",
		       (unsigned long long)md->phys_addr);
}

850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
static void native_runtime_setup(void)
{
	efi.get_time = virt_efi_get_time;
	efi.set_time = virt_efi_set_time;
	efi.get_wakeup_time = virt_efi_get_wakeup_time;
	efi.set_wakeup_time = virt_efi_set_wakeup_time;
	efi.get_variable = virt_efi_get_variable;
	efi.get_next_variable = virt_efi_get_next_variable;
	efi.set_variable = virt_efi_set_variable;
	efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
	efi.reset_system = virt_efi_reset_system;
	efi.query_variable_info = virt_efi_query_variable_info;
	efi.update_capsule = virt_efi_update_capsule;
	efi.query_capsule_caps = virt_efi_query_capsule_caps;
}

866 867
/* Merge contiguous regions of the same type and attribute */
static void __init efi_merge_regions(void)
Huang, Ying's avatar
Huang, Ying committed
868
{
869
	void *p;
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
	efi_memory_desc_t *md, *prev_md = NULL;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		u64 prev_size;
		md = p;

		if (!prev_md) {
			prev_md = md;
			continue;
		}

		if (prev_md->type != md->type ||
		    prev_md->attribute != md->attribute) {
			prev_md = md;
			continue;
		}

		prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;

		if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
			prev_md->num_pages += md->num_pages;
			md->type = EFI_RESERVED_TYPE;
			md->attribute = 0;
			continue;
		}
		prev_md = md;
896 897 898 899 900 901 902
	}
}

static void __init get_systab_virt_addr(efi_memory_desc_t *md)
{
	unsigned long size;
	u64 end, systab;
903

904 905 906 907 908 909
	size = md->num_pages << EFI_PAGE_SHIFT;
	end = md->phys_addr + size;
	systab = (u64)(unsigned long)efi_phys.systab;
	if (md->phys_addr <= systab && systab < end) {
		systab += md->virt_addr - md->phys_addr;
		efi.systab = (efi_system_table_t *)(unsigned long)systab;
910
	}
911 912
}

913
static void __init save_runtime_map(void)
914
{
915
#ifdef CONFIG_KEXEC
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
	efi_memory_desc_t *md;
	void *tmp, *p, *q = NULL;
	int count = 0;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;

		if (!(md->attribute & EFI_MEMORY_RUNTIME) ||
		    (md->type == EFI_BOOT_SERVICES_CODE) ||
		    (md->type == EFI_BOOT_SERVICES_DATA))
			continue;
		tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL);
		if (!tmp)
			goto out;
		q = tmp;

		memcpy(q + count * memmap.desc_size, md, memmap.desc_size);
		count++;
	}

936
	efi_runtime_map_setup(q, count, memmap.desc_size);
937
	return;
938 939 940

out:
	kfree(q);
941 942
	pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
#endif
943 944
}

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
static void *realloc_pages(void *old_memmap, int old_shift)
{
	void *ret;

	ret = (void *)__get_free_pages(GFP_KERNEL, old_shift + 1);
	if (!ret)
		goto out;

	/*
	 * A first-time allocation doesn't have anything to copy.
	 */
	if (!old_memmap)
		return ret;

	memcpy(ret, old_memmap, PAGE_SIZE << old_shift);

out:
	free_pages((unsigned long)old_memmap, old_shift);
	return ret;
}

966
/*
967 968
 * Map the efi memory ranges of the runtime services and update new_mmap with
 * virtual addresses.
969
 */
970
static void * __init efi_map_regions(int *count, int *pg_shift)
971
{
972 973
	void *p, *new_memmap = NULL;
	unsigned long left = 0;
974
	efi_memory_desc_t *md;
975

Huang, Ying's avatar
Huang, Ying committed
976 977
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
978 979 980 981 982 983 984
		if (!(md->attribute & EFI_MEMORY_RUNTIME)) {
#ifdef CONFIG_X86_64
			if (md->type != EFI_BOOT_SERVICES_CODE &&
			    md->type != EFI_BOOT_SERVICES_DATA)
#endif
				continue;
		}
Huang, Ying's avatar
Huang, Ying committed
985

986
		efi_map_region(md);
987 988
		get_systab_virt_addr(md);

989 990 991 992 993 994 995 996 997
		if (left < memmap.desc_size) {
			new_memmap = realloc_pages(new_memmap, *pg_shift);
			if (!new_memmap)
				return NULL;

			left += PAGE_SIZE << *pg_shift;
			(*pg_shift)++;
		}

998 999
		memcpy(new_memmap + (*count * memmap.desc_size), md,
		       memmap.desc_size);
1000 1001

		left -= memmap.desc_size;
1002 1003
		(*count)++;
	}
1004

1005 1006 1007
	return new_memmap;
}

1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
static void __init kexec_enter_virtual_mode(void)
{
#ifdef CONFIG_KEXEC
	efi_memory_desc_t *md;
	void *p;

	efi.systab = NULL;

	/*
	 * We don't do virtual mode, since we don't do runtime services, on
	 * non-native EFI
	 */
	if (!efi_is_native()) {
		efi_unmap_memmap();
		return;
	}

	/*
	* Map efi regions which were passed via setup_data. The virt_addr is a
	* fixed addr which was used in first kernel of a kexec boot.
	*/
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
		efi_map_region_fixed(md); /* FIXME: add error handling */
		get_systab_virt_addr(md);
	}

	save_runtime_map();

	BUG_ON(!efi.systab);

	efi_sync_low_kernel_mappings();

	/*
	 * Now that EFI is in virtual mode, update the function
	 * pointers in the runtime service table to the new virtual addresses.
	 *
	 * Call EFI services through wrapper functions.
	 */
	efi.runtime_version = efi_systab.hdr.revision;
1048 1049 1050

	native_runtime_setup();

1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	efi.set_virtual_address_map = NULL;

	if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))
		runtime_code_page_mkexec();

	/* clean DUMMY object */
	efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
			 EFI_VARIABLE_NON_VOLATILE |
			 EFI_VARIABLE_BOOTSERVICE_ACCESS |
			 EFI_VARIABLE_RUNTIME_ACCESS,
			 0, NULL);
#endif
}

1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
/*
 * This function will switch the EFI runtime services to virtual mode.
 * Essentially, we look through the EFI memmap and map every region that
 * has the runtime attribute bit set in its memory descriptor into the
 * ->trampoline_pgd page table using a top-down VA allocation scheme.
 *
 * The old method which used to update that memory descriptor with the
 * virtual address obtained from ioremap() is still supported when the
 * kernel is booted with efi=old_map on its command line. Same old
 * method enabled the runtime services to be called without having to
 * thunk back into physical mode for every invocation.
 *
 * The new method does a pagetable switch in a preemption-safe manner
 * so that we're in a different address space when calling a runtime
 * function. For function arguments passing we do copy the PGDs of the
 * kernel page table into ->trampoline_pgd prior to each call.
1081 1082 1083
 *
 * Specially for kexec boot, efi runtime maps in previous kernel should
 * be passed in via setup_data. In that case runtime ranges will be mapped
1084 1085
 * to the same virtual addresses as the first kernel, see
 * kexec_enter_virtual_mode().
1086
 */
1087
static void __init __efi_enter_virtual_mode(void)
1088
{
1089
	int count = 0, pg_shift = 0;
1090
	void *new_memmap = NULL;
1091
	efi_status_t status;
Huang, Ying's avatar
Huang, Ying committed
1092

1093
	efi.systab = NULL;
1094

1095 1096 1097 1098 1099
	efi_merge_regions();
	new_memmap = efi_map_regions(&count, &pg_shift);
	if (!new_memmap) {
		pr_err("Error reallocating memory, EFI runtime non-functional!\n");
		return;
1100
	}
1101

1102 1103
	save_runtime_map();