efi.c 25.5 KB
Newer Older
H
Huang, Ying 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * 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>
 *
 * 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.
 */

29 30
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

H
Huang, Ying 已提交
31 32 33
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/efi.h>
34
#include <linux/efi-bgrt.h>
35
#include <linux/export.h>
H
Huang, Ying 已提交
36
#include <linux/bootmem.h>
37
#include <linux/memblock.h>
H
Huang, Ying 已提交
38 39 40 41 42 43 44 45 46 47
#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>
48 49
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
50
#include <asm/x86_init.h>
51
#include <asm/rtc.h>
H
Huang, Ying 已提交
52 53 54

#define EFI_DEBUG	1

55 56 57 58 59 60 61 62 63 64 65
struct efi __read_mostly efi = {
	.mps        = EFI_INVALID_TABLE_ADDR,
	.acpi       = EFI_INVALID_TABLE_ADDR,
	.acpi20     = EFI_INVALID_TABLE_ADDR,
	.smbios     = EFI_INVALID_TABLE_ADDR,
	.sal_systab = EFI_INVALID_TABLE_ADDR,
	.boot_info  = EFI_INVALID_TABLE_ADDR,
	.hcdp       = EFI_INVALID_TABLE_ADDR,
	.uga        = EFI_INVALID_TABLE_ADDR,
	.uv_systab  = EFI_INVALID_TABLE_ADDR,
};
H
Huang, Ying 已提交
66 67 68 69
EXPORT_SYMBOL(efi);

struct efi_memory_map memmap;

H
Harvey Harrison 已提交
70
static struct efi efi_phys __initdata;
H
Huang, Ying 已提交
71 72
static efi_system_table_t efi_systab __initdata;

73 74 75 76 77 78 79 80
unsigned long x86_efi_facility;

/*
 * Returns 1 if 'facility' is enabled, 0 otherwise.
 */
int efi_enabled(int facility)
{
	return test_bit(facility, &x86_efi_facility) != 0;
81
}
82
EXPORT_SYMBOL(efi_enabled);
83

84
static bool __initdata disable_runtime = false;
85 86
static int __init setup_noefi(char *arg)
{
87
	disable_runtime = true;
88 89 90 91
	return 0;
}
early_param("noefi", setup_noefi);

92 93 94 95 96 97 98 99 100 101 102
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);


H
Huang, Ying 已提交
103 104
static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
{
105 106 107 108 109 110 111
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt2(get_time, tm, tc);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
H
Huang, Ying 已提交
112 113 114 115
}

static efi_status_t virt_efi_set_time(efi_time_t *tm)
{
116 117 118 119 120 121 122
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt1(set_time, tm);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
H
Huang, Ying 已提交
123 124 125 126 127 128
}

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

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt3(get_wakeup_time,
				enabled, pending, tm);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
H
Huang, Ying 已提交
137 138 139 140
}

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

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt2(set_wakeup_time,
				enabled, tm);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
H
Huang, Ying 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
}

static efi_status_t virt_efi_get_variable(efi_char16_t *name,
					  efi_guid_t *vendor,
					  u32 *attr,
					  unsigned long *data_size,
					  void *data)
{
	return efi_call_virt5(get_variable,
			      name, vendor, attr,
			      data_size, data);
}

static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
					       efi_char16_t *name,
					       efi_guid_t *vendor)
{
	return efi_call_virt3(get_next_variable,
			      name_size, name, vendor);
}

static efi_status_t virt_efi_set_variable(efi_char16_t *name,
					  efi_guid_t *vendor,
172
					  u32 attr,
H
Huang, Ying 已提交
173 174 175 176 177 178 179 180
					  unsigned long data_size,
					  void *data)
{
	return efi_call_virt5(set_variable,
			      name, vendor, attr,
			      data_size, data);
}

181 182 183 184 185 186 187 188 189 190 191 192
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;

	return efi_call_virt4(query_variable_info, attr, storage_space,
			      remaining_space, max_variable_size);
}

H
Huang, Ying 已提交
193 194 195 196 197 198 199 200 201 202 203 204 205 206
static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
{
	return efi_call_virt1(get_next_high_mono_count, count);
}

static void virt_efi_reset_system(int reset_type,
				  efi_status_t status,
				  unsigned long data_size,
				  efi_char16_t *data)
{
	efi_call_virt4(reset_system, reset_type, status,
		       data_size, data);
}

207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
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;

	return efi_call_virt3(update_capsule, capsules, count, sg_list);
}

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;

	return efi_call_virt4(query_capsule_caps, capsules, count, max_size,
			      reset_type);
}

H
Huang, Ying 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
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();
	status = efi_call_phys4(efi_phys.set_virtual_address_map,
				memory_map_size, descriptor_size,
				descriptor_version, virtual_map);
	efi_call_phys_epilog();
	return status;
}

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
static efi_status_t __init phys_efi_get_time(efi_time_t *tm,
					     efi_time_cap_t *tc)
{
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	efi_call_phys_prelog();
	status = efi_call_phys2(efi_phys.get_time, virt_to_phys(tm),
				virt_to_phys(tc));
	efi_call_phys_epilog();
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
}

int efi_set_rtc_mmss(unsigned long nowtime)
H
Huang, Ying 已提交
261 262 263 264
{
	efi_status_t 	status;
	efi_time_t 	eft;
	efi_time_cap_t 	cap;
265
	struct rtc_time	tm;
H
Huang, Ying 已提交
266 267 268

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS) {
269
		pr_err("Oops: efitime: can't read time!\n");
H
Huang, Ying 已提交
270 271 272
		return -1;
	}

273 274 275 276 277 278 279 280 281 282 283 284 285 286
	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 {
		printk(KERN_ERR
		       "%s: Invalid EFI RTC value: write of %lx to EFI RTC failed\n",
		       __FUNCTION__, nowtime);
		return -1;
	}
H
Huang, Ying 已提交
287 288 289

	status = efi.set_time(&eft);
	if (status != EFI_SUCCESS) {
290
		pr_err("Oops: efitime: can't write time!\n");
H
Huang, Ying 已提交
291 292 293 294 295
		return -1;
	}
	return 0;
}

296
unsigned long efi_get_time(void)
H
Huang, Ying 已提交
297 298 299 300 301 302 303
{
	efi_status_t status;
	efi_time_t eft;
	efi_time_cap_t cap;

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS)
304
		pr_err("Oops: efitime: can't read time!\n");
H
Huang, Ying 已提交
305 306 307 308 309

	return mktime(eft.year, eft.month, eft.day, eft.hour,
		      eft.minute, eft.second);
}

310 311 312 313 314 315
/*
 * 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.
 */

316
static void __init do_add_efi_memmap(void)
317 318 319 320 321 322 323 324 325
{
	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;

326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
		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
			 */
352
			e820_type = E820_RESERVED;
353 354
			break;
		}
355
		e820_add_region(start, size, e820_type);
356 357 358 359
	}
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

360
int __init efi_memblock_x86_reserve_range(void)
361 362 363
{
	unsigned long pmap;

364
#ifdef CONFIG_X86_32
365 366 367 368 369
	/* Can't handle data above 4GB at this time */
	if (boot_params.efi_info.efi_memmap_hi) {
		pr_err("Memory map is above 4GB, disabling EFI.\n");
		return -EINVAL;
	}
370
	pmap = boot_params.efi_info.efi_memmap;
371 372 373
#else
	pmap = (boot_params.efi_info.efi_memmap |
		((__u64)boot_params.efi_info.efi_memmap_hi<<32));
374 375 376 377 378 379
#endif
	memmap.phys_map = (void *)pmap;
	memmap.nr_map = boot_params.efi_info.efi_memmap_size /
		boot_params.efi_info.efi_memdesc_size;
	memmap.desc_version = boot_params.efi_info.efi_memdesc_version;
	memmap.desc_size = boot_params.efi_info.efi_memdesc_size;
380
	memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
381 382

	return 0;
383 384
}

H
Huang, Ying 已提交
385 386 387 388 389 390 391 392 393 394 395
#if EFI_DEBUG
static void __init print_efi_memmap(void)
{
	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;
396
		pr_info("mem%02u: type=%u, attr=0x%llx, "
H
Huang, Ying 已提交
397 398 399 400 401 402 403 404
			"range=[0x%016llx-0x%016llx) (%lluMB)\n",
			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  */

405 406 407 408 409 410
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;
411 412
		u64 start = md->phys_addr;
		u64 size = md->num_pages << EFI_PAGE_SHIFT;
413 414 415 416

		if (md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;
417 418 419 420 421 422
		/* 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
		*/
423 424
		if ((start+size >= __pa_symbol(_text)
				&& start <= __pa_symbol(_end)) ||
425
			!e820_all_mapped(start, start+size, E820_RAM) ||
426
			memblock_is_region_reserved(start, size)) {
427 428
			/* Could not reserve, skip it */
			md->num_pages = 0;
429
			memblock_dbg("Could not reserve boot range "
430 431 432
					"[0x%010llx-0x%010llx]\n",
						start, start+size-1);
		} else
433
			memblock_reserve(start, size);
434 435 436
	}
}

437
void __init efi_unmap_memmap(void)
438
{
439
	clear_bit(EFI_MEMMAP, &x86_efi_facility);
440 441 442 443 444 445 446
	if (memmap.map) {
		early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
		memmap.map = NULL;
	}
}

void __init efi_free_boot_services(void)
447 448 449
{
	void *p;

450
	if (!efi_is_native())
451 452
		return;

453 454 455 456 457 458 459 460 461
	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;

462 463 464 465
		/* Could not reserve boot area */
		if (!size)
			continue;

466 467
		free_bootmem_late(start, size);
	}
468 469

	efi_unmap_memmap();
470 471
}

472
static int __init efi_systab_init(void *phys)
H
Huang, Ying 已提交
473
{
474
	if (efi_enabled(EFI_64BIT)) {
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 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
		efi_system_table_64_t *systab64;
		u64 tmp = 0;

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

		efi_systab.hdr = systab64->hdr;
		efi_systab.fw_vendor = systab64->fw_vendor;
		tmp |= systab64->fw_vendor;
		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;
		efi_systab.runtime = (void *)(unsigned long)systab64->runtime;
		tmp |= systab64->runtime;
		efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
		tmp |= systab64->boottime;
		efi_systab.nr_tables = systab64->nr_tables;
		efi_systab.tables = systab64->tables;
		tmp |= systab64->tables;

		early_iounmap(systab64, sizeof(*systab64));
#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

H
Huang, Ying 已提交
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;
	}
H
Huang, Ying 已提交
552
	if ((efi.systab->hdr.revision >> 16) == 0)
553
		pr_err("Warning: System table version "
H
Huang, Ying 已提交
554 555 556
		       "%d.%02d, expected 1.00 or greater!\n",
		       efi.systab->hdr.revision >> 16,
		       efi.systab->hdr.revision & 0xffff);
557 558

	return 0;
559
}
H
Huang, Ying 已提交
560

561
static int __init efi_config_init(u64 tables, int nr_tables)
562
{
563 564 565
	void *config_tables, *tablep;
	int i, sz;

566
	if (efi_enabled(EFI_64BIT))
567 568 569
		sz = sizeof(efi_config_table_64_t);
	else
		sz = sizeof(efi_config_table_32_t);
H
Huang, Ying 已提交
570 571 572 573

	/*
	 * Let's see what config tables the firmware passed to us.
	 */
574
	config_tables = early_ioremap(tables, nr_tables * sz);
575
	if (config_tables == NULL) {
576
		pr_err("Could not map Configuration table!\n");
577 578
		return -ENOMEM;
	}
H
Huang, Ying 已提交
579

580
	tablep = config_tables;
581
	pr_info("");
H
Huang, Ying 已提交
582
	for (i = 0; i < efi.systab->nr_tables; i++) {
583 584 585
		efi_guid_t guid;
		unsigned long table;

586
		if (efi_enabled(EFI_64BIT)) {
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
			u64 table64;
			guid = ((efi_config_table_64_t *)tablep)->guid;
			table64 = ((efi_config_table_64_t *)tablep)->table;
			table = table64;
#ifdef CONFIG_X86_32
			if (table64 >> 32) {
				pr_cont("\n");
				pr_err("Table located above 4GB, disabling EFI.\n");
				early_iounmap(config_tables,
					      efi.systab->nr_tables * sz);
				return -EINVAL;
			}
#endif
		} else {
			guid = ((efi_config_table_32_t *)tablep)->guid;
			table = ((efi_config_table_32_t *)tablep)->table;
		}
604 605 606 607 608 609 610 611 612 613 614 615
		if (!efi_guidcmp(guid, MPS_TABLE_GUID)) {
			efi.mps = table;
			pr_cont(" MPS=0x%lx ", table);
		} else if (!efi_guidcmp(guid, ACPI_20_TABLE_GUID)) {
			efi.acpi20 = table;
			pr_cont(" ACPI 2.0=0x%lx ", table);
		} else if (!efi_guidcmp(guid, ACPI_TABLE_GUID)) {
			efi.acpi = table;
			pr_cont(" ACPI=0x%lx ", table);
		} else if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID)) {
			efi.smbios = table;
			pr_cont(" SMBIOS=0x%lx ", table);
N
Nick Piggin 已提交
616
#ifdef CONFIG_X86_UV
617 618 619
		} else if (!efi_guidcmp(guid, UV_SYSTEM_TABLE_GUID)) {
			efi.uv_systab = table;
			pr_cont(" UVsystab=0x%lx ", table);
N
Nick Piggin 已提交
620
#endif
621 622 623 624 625 626
		} else if (!efi_guidcmp(guid, HCDP_TABLE_GUID)) {
			efi.hcdp = table;
			pr_cont(" HCDP=0x%lx ", table);
		} else if (!efi_guidcmp(guid, UGA_IO_PROTOCOL_GUID)) {
			efi.uga = table;
			pr_cont(" UGA=0x%lx ", table);
H
Huang, Ying 已提交
627
		}
628
		tablep += sz;
H
Huang, Ying 已提交
629
	}
630
	pr_cont("\n");
631
	early_iounmap(config_tables, efi.systab->nr_tables * sz);
632
	return 0;
633 634
}

635
static int __init efi_runtime_init(void)
636 637
{
	efi_runtime_services_t *runtime;
H
Huang, Ying 已提交
638 639 640 641 642 643 644

	/*
	 * 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.
	 */
645 646
	runtime = early_ioremap((unsigned long)efi.systab->runtime,
				sizeof(efi_runtime_services_t));
647
	if (!runtime) {
648
		pr_err("Could not map the runtime service table!\n");
649 650 651 652
		return -ENOMEM;
	}
	/*
	 * We will only need *early* access to the following
653
	 * two EFI runtime services before set_virtual_address_map
654 655
	 * is invoked.
	 */
656
	efi_phys.get_time = (efi_get_time_t *)runtime->get_time;
657 658 659
	efi_phys.set_virtual_address_map =
		(efi_set_virtual_address_map_t *)
		runtime->set_virtual_address_map;
660 661 662 663 664
	/*
	 * Make efi_get_time can be called before entering
	 * virtual mode.
	 */
	efi.get_time = phys_efi_get_time;
665
	early_iounmap(runtime, sizeof(efi_runtime_services_t));
666 667

	return 0;
668
}
H
Huang, Ying 已提交
669

670
static int __init efi_memmap_init(void)
671
{
H
Huang, Ying 已提交
672
	/* Map the EFI memory map */
673 674
	memmap.map = early_ioremap((unsigned long)memmap.phys_map,
				   memmap.nr_map * memmap.desc_size);
675
	if (memmap.map == NULL) {
676
		pr_err("Could not map the memory map!\n");
677 678
		return -ENOMEM;
	}
H
Huang, Ying 已提交
679
	memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
R
Russ Anderson 已提交
680

681 682
	if (add_efi_memmap)
		do_add_efi_memmap();
683 684

	return 0;
685 686 687 688 689 690 691 692 693 694
}

void __init efi_init(void)
{
	efi_char16_t *c16;
	char vendor[100] = "unknown";
	int i = 0;
	void *tmp;

#ifdef CONFIG_X86_32
695 696 697 698 699
	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;
	}
700 701 702
	efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
#else
	efi_phys.systab = (efi_system_table_t *)
703 704
			  (boot_params.efi_info.efi_systab |
			  ((__u64)boot_params.efi_info.efi_systab_hi<<32));
705 706
#endif

707
	if (efi_systab_init(efi_phys.systab))
708
		return;
709 710

	set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility);
711 712 713 714 715 716 717 718 719 720

	/*
	 * 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
721
		pr_err("Could not map the firmware vendor!\n");
722 723
	early_iounmap(tmp, 2);

724 725 726
	pr_info("EFI v%u.%.02u by %s\n",
		efi.systab->hdr.revision >> 16,
		efi.systab->hdr.revision & 0xffff, vendor);
727

728
	if (efi_config_init(efi.systab->tables, efi.systab->nr_tables))
729
		return;
730 731

	set_bit(EFI_CONFIG_TABLES, &x86_efi_facility);
732

733 734 735 736 737
	/*
	 * Note: We currently don't support runtime services on an EFI
	 * that doesn't match the kernel 32/64-bit mode.
	 */

738
	if (!efi_is_native())
739
		pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
740
	else {
741
		if (disable_runtime || efi_runtime_init())
742 743
			return;
		set_bit(EFI_RUNTIME_SERVICES, &x86_efi_facility);
744
	}
745

746
	if (efi_memmap_init())
747
		return;
748 749 750

	set_bit(EFI_MEMMAP, &x86_efi_facility);

751
#ifdef CONFIG_X86_32
752
	if (efi_is_native()) {
753 754 755
		x86_platform.get_wallclock = efi_get_time;
		x86_platform.set_wallclock = efi_set_rtc_mmss;
	}
756
#endif
757

H
Huang, Ying 已提交
758 759 760 761 762
#if EFI_DEBUG
	print_efi_memmap();
#endif
}

763 764 765 766 767
void __init efi_late_init(void)
{
	efi_bgrt_init();
}

768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
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);
}

783 784 785 786 787 788 789 790
static void __init runtime_code_page_mkexec(void)
{
	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;
H
Huang, Ying 已提交
791 792 793 794

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

795
		efi_set_executable(md, true);
796 797 798
	}
}

799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
/*
 * We can't ioremap data in EFI boot services RAM, because we've already mapped
 * it as RAM.  So, look it up in the existing EFI memory map instead.  Only
 * callable after efi_enter_virtual_mode and before efi_free_boot_services.
 */
void __iomem *efi_lookup_mapped_addr(u64 phys_addr)
{
	void *p;
	if (WARN_ON(!memmap.map))
		return NULL;
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
		u64 size = md->num_pages << EFI_PAGE_SHIFT;
		u64 end = md->phys_addr + size;
		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
		    md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;
		if (!md->virt_addr)
			continue;
		if (phys_addr >= md->phys_addr && phys_addr < end) {
			phys_addr += md->virt_addr - md->phys_addr;
			return (__force void __iomem *)(unsigned long)phys_addr;
		}
	}
	return NULL;
}

827 828 829 830 831 832 833 834 835 836
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);
}

H
Huang, Ying 已提交
837 838 839 840 841 842 843 844 845 846
/*
 * This function will switch the EFI runtime services to virtual mode.
 * Essentially, look through the EFI memmap and map every region that
 * has the runtime attribute bit set in its memory descriptor and update
 * that memory descriptor with the virtual address obtained from ioremap().
 * This enables the runtime services to be called without having to
 * thunk back into physical mode for every invocation.
 */
void __init efi_enter_virtual_mode(void)
{
847
	efi_memory_desc_t *md, *prev_md = NULL;
H
Huang, Ying 已提交
848
	efi_status_t status;
H
Huang, Ying 已提交
849
	unsigned long size;
850
	u64 end, systab, start_pfn, end_pfn;
851 852
	void *p, *va, *new_memmap = NULL;
	int count = 0;
H
Huang, Ying 已提交
853 854

	efi.systab = NULL;
855

856 857 858 859 860
	/*
	 * We don't do virtual mode, since we don't do runtime services, on
	 * non-native EFI
	 */

861
	if (!efi_is_native()) {
862 863 864
		efi_unmap_memmap();
		return;
	}
865

866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
	/* Merge contiguous regions of the same type and attribute */
	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;
	}

H
Huang, Ying 已提交
893 894
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
895 896 897
		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
		    md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
H
Huang, Ying 已提交
898
			continue;
H
Huang, Ying 已提交
899 900 901 902

		size = md->num_pages << EFI_PAGE_SHIFT;
		end = md->phys_addr + size;

903
		start_pfn = PFN_DOWN(md->phys_addr);
904
		end_pfn = PFN_UP(end);
905
		if (pfn_range_is_mapped(start_pfn, end_pfn)) {
H
Huang, Ying 已提交
906
			va = __va(md->phys_addr);
907 908 909 910 911 912

			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);
H
Huang, Ying 已提交
913 914 915 916

		md->virt_addr = (u64) (unsigned long) va;

		if (!va) {
917
			pr_err("ioremap of 0x%llX failed!\n",
H
Huang, Ying 已提交
918
			       (unsigned long long)md->phys_addr);
H
Huang, Ying 已提交
919 920 921 922 923 924 925 926
			continue;
		}

		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;
		}
927 928 929 930 931 932
		new_memmap = krealloc(new_memmap,
				      (count + 1) * memmap.desc_size,
				      GFP_KERNEL);
		memcpy(new_memmap + (count * memmap.desc_size), md,
		       memmap.desc_size);
		count++;
H
Huang, Ying 已提交
933 934 935 936 937
	}

	BUG_ON(!efi.systab);

	status = phys_efi_set_virtual_address_map(
938
		memmap.desc_size * count,
H
Huang, Ying 已提交
939 940
		memmap.desc_size,
		memmap.desc_version,
941
		(efi_memory_desc_t *)__pa(new_memmap));
H
Huang, Ying 已提交
942 943

	if (status != EFI_SUCCESS) {
944 945
		pr_alert("Unable to switch EFI into virtual mode "
			 "(status=%lx)!\n", status);
H
Huang, Ying 已提交
946 947 948 949 950 951 952 953 954
		panic("EFI call to SetVirtualAddressMap() failed!");
	}

	/*
	 * 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.
	 */
955
	efi.runtime_version = efi_systab.hdr.revision;
H
Huang, Ying 已提交
956 957 958 959 960 961 962 963 964
	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;
965
	efi.set_virtual_address_map = NULL;
966 967 968
	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;
969 970
	if (__supported_pte_mask & _PAGE_NX)
		runtime_code_page_mkexec();
971

972
	kfree(new_memmap);
H
Huang, Ying 已提交
973 974 975 976 977 978 979 980 981 982
}

/*
 * Convenience functions to obtain memory types and attributes
 */
u32 efi_mem_type(unsigned long phys_addr)
{
	efi_memory_desc_t *md;
	void *p;

983 984 985
	if (!efi_enabled(EFI_MEMMAP))
		return 0;

H
Huang, Ying 已提交
986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
		if ((md->phys_addr <= phys_addr) &&
		    (phys_addr < (md->phys_addr +
				  (md->num_pages << EFI_PAGE_SHIFT))))
			return md->type;
	}
	return 0;
}

u64 efi_mem_attributes(unsigned long phys_addr)
{
	efi_memory_desc_t *md;
	void *p;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
		if ((md->phys_addr <= phys_addr) &&
		    (phys_addr < (md->phys_addr +
				  (md->num_pages << EFI_PAGE_SHIFT))))
			return md->attribute;
	}
	return 0;
}