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

#define EFI_DEBUG	1

int efi_enabled;
EXPORT_SYMBOL(efi_enabled);

56 57 58 59 60 61 62 63 64 65 66
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 已提交
67 68 69 70
EXPORT_SYMBOL(efi);

struct efi_memory_map memmap;

71 72 73
bool efi_64bit;
static bool efi_native;

H
Harvey Harrison 已提交
74
static struct efi efi_phys __initdata;
H
Huang, Ying 已提交
75 76
static efi_system_table_t efi_systab __initdata;

77 78 79 80 81 82 83
static int __init setup_noefi(char *arg)
{
	efi_enabled = 0;
	return 0;
}
early_param("noefi", setup_noefi);

84 85 86 87 88 89 90 91 92 93 94
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 已提交
95 96
static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
{
97 98 99 100 101 102 103
	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 已提交
104 105 106 107
}

static efi_status_t virt_efi_set_time(efi_time_t *tm)
{
108 109 110 111 112 113 114
	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 已提交
115 116 117 118 119 120
}

static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
					     efi_bool_t *pending,
					     efi_time_t *tm)
{
121 122 123 124 125 126 127 128
	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 已提交
129 130 131 132
}

static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
{
133 134 135 136 137 138 139 140
	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 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
}

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,
164
					  u32 attr,
H
Huang, Ying 已提交
165 166 167 168 169 170 171 172
					  unsigned long data_size,
					  void *data)
{
	return efi_call_virt5(set_variable,
			      name, vendor, attr,
			      data_size, data);
}

173 174 175 176 177 178 179 180 181 182 183 184
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 已提交
185 186 187 188 189 190 191 192 193 194 195 196 197 198
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);
}

199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
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 已提交
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
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;
}

237
static int efi_set_rtc_mmss(unsigned long nowtime)
H
Huang, Ying 已提交
238 239 240 241 242 243 244 245
{
	int real_seconds, real_minutes;
	efi_status_t 	status;
	efi_time_t 	eft;
	efi_time_cap_t 	cap;

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS) {
246
		pr_err("Oops: efitime: can't read time!\n");
H
Huang, Ying 已提交
247 248 249 250 251 252 253 254 255 256 257 258 259
		return -1;
	}

	real_seconds = nowtime % 60;
	real_minutes = nowtime / 60;
	if (((abs(real_minutes - eft.minute) + 15)/30) & 1)
		real_minutes += 30;
	real_minutes %= 60;
	eft.minute = real_minutes;
	eft.second = real_seconds;

	status = efi.set_time(&eft);
	if (status != EFI_SUCCESS) {
260
		pr_err("Oops: efitime: can't write time!\n");
H
Huang, Ying 已提交
261 262 263 264 265
		return -1;
	}
	return 0;
}

266
static unsigned long efi_get_time(void)
H
Huang, Ying 已提交
267 268 269 270 271 272 273
{
	efi_status_t status;
	efi_time_t eft;
	efi_time_cap_t cap;

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS)
274
		pr_err("Oops: efitime: can't read time!\n");
H
Huang, Ying 已提交
275 276 277 278 279

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

280 281 282 283 284 285
/*
 * 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.
 */

286
static void __init do_add_efi_memmap(void)
287 288 289 290 291 292 293 294 295
{
	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;

296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
		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
			 */
322
			e820_type = E820_RESERVED;
323 324
			break;
		}
325
		e820_add_region(start, size, e820_type);
326 327 328 329
	}
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

330
int __init efi_memblock_x86_reserve_range(void)
331 332 333
{
	unsigned long pmap;

334
#ifdef CONFIG_X86_32
335 336 337 338 339
	/* 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;
	}
340
	pmap = boot_params.efi_info.efi_memmap;
341 342 343
#else
	pmap = (boot_params.efi_info.efi_memmap |
		((__u64)boot_params.efi_info.efi_memmap_hi<<32));
344 345 346 347 348 349
#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;
350
	memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
351 352

	return 0;
353 354
}

H
Huang, Ying 已提交
355 356 357 358 359 360 361 362 363 364 365
#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;
366
		pr_info("mem%02u: type=%u, attr=0x%llx, "
H
Huang, Ying 已提交
367 368 369 370 371 372 373 374
			"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  */

375 376 377 378 379 380
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;
381 382
		u64 start = md->phys_addr;
		u64 size = md->num_pages << EFI_PAGE_SHIFT;
383 384 385 386

		if (md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;
387 388 389 390 391 392 393 394 395
		/* 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
		*/
		if ((start+size >= virt_to_phys(_text)
				&& start <= virt_to_phys(_end)) ||
			!e820_all_mapped(start, start+size, E820_RAM) ||
396
			memblock_is_region_reserved(start, size)) {
397 398
			/* Could not reserve, skip it */
			md->num_pages = 0;
399
			memblock_dbg("Could not reserve boot range "
400 401 402
					"[0x%010llx-0x%010llx]\n",
						start, start+size-1);
		} else
403
			memblock_reserve(start, size);
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
	}
}

static void __init efi_free_boot_services(void)
{
	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;

420 421 422 423
		/* Could not reserve boot area */
		if (!size)
			continue;

424 425 426 427
		free_bootmem_late(start, size);
	}
}

428
static int __init efi_systab_init(void *phys)
H
Huang, Ying 已提交
429
{
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
	if (efi_64bit) {
		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));
497
	}
498

H
Huang, Ying 已提交
499 500 501 502 503
	efi.systab = &efi_systab;

	/*
	 * Verify the EFI Table
	 */
504
	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
505
		pr_err("System table signature incorrect!\n");
506 507
		return -EINVAL;
	}
H
Huang, Ying 已提交
508
	if ((efi.systab->hdr.revision >> 16) == 0)
509
		pr_err("Warning: System table version "
H
Huang, Ying 已提交
510 511 512
		       "%d.%02d, expected 1.00 or greater!\n",
		       efi.systab->hdr.revision >> 16,
		       efi.systab->hdr.revision & 0xffff);
513 514

	return 0;
515
}
H
Huang, Ying 已提交
516

517
static int __init efi_config_init(u64 tables, int nr_tables)
518
{
519 520 521 522 523 524 525
	void *config_tables, *tablep;
	int i, sz;

	if (efi_64bit)
		sz = sizeof(efi_config_table_64_t);
	else
		sz = sizeof(efi_config_table_32_t);
H
Huang, Ying 已提交
526 527 528 529

	/*
	 * Let's see what config tables the firmware passed to us.
	 */
530
	config_tables = early_ioremap(tables, nr_tables * sz);
531
	if (config_tables == NULL) {
532
		pr_err("Could not map Configuration table!\n");
533 534
		return -ENOMEM;
	}
H
Huang, Ying 已提交
535

536
	tablep = config_tables;
537
	pr_info("");
H
Huang, Ying 已提交
538
	for (i = 0; i < efi.systab->nr_tables; i++) {
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
		efi_guid_t guid;
		unsigned long table;

		if (efi_64bit) {
			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;
		}
560 561 562 563 564 565 566 567 568 569 570 571
		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 已提交
572
#ifdef CONFIG_X86_UV
573 574 575
		} else if (!efi_guidcmp(guid, UV_SYSTEM_TABLE_GUID)) {
			efi.uv_systab = table;
			pr_cont(" UVsystab=0x%lx ", table);
N
Nick Piggin 已提交
576
#endif
577 578 579 580 581 582
		} 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 已提交
583
		}
584
		tablep += sz;
H
Huang, Ying 已提交
585
	}
586
	pr_cont("\n");
587
	early_iounmap(config_tables, efi.systab->nr_tables * sz);
588
	return 0;
589 590
}

591
static int __init efi_runtime_init(void)
592 593
{
	efi_runtime_services_t *runtime;
H
Huang, Ying 已提交
594 595 596 597 598 599 600

	/*
	 * 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.
	 */
601 602
	runtime = early_ioremap((unsigned long)efi.systab->runtime,
				sizeof(efi_runtime_services_t));
603
	if (!runtime) {
604
		pr_err("Could not map the runtime service table!\n");
605 606 607 608
		return -ENOMEM;
	}
	/*
	 * We will only need *early* access to the following
609
	 * EFI runtime service before set_virtual_address_map
610 611 612 613 614
	 * is invoked.
	 */
	efi_phys.set_virtual_address_map =
		(efi_set_virtual_address_map_t *)
		runtime->set_virtual_address_map;
615

616
	early_iounmap(runtime, sizeof(efi_runtime_services_t));
617 618

	return 0;
619
}
H
Huang, Ying 已提交
620

621
static int __init efi_memmap_init(void)
622
{
H
Huang, Ying 已提交
623
	/* Map the EFI memory map */
624 625
	memmap.map = early_ioremap((unsigned long)memmap.phys_map,
				   memmap.nr_map * memmap.desc_size);
626
	if (memmap.map == NULL) {
627
		pr_err("Could not map the memory map!\n");
628 629
		return -ENOMEM;
	}
H
Huang, Ying 已提交
630
	memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
R
Russ Anderson 已提交
631

632 633
	if (add_efi_memmap)
		do_add_efi_memmap();
634 635

	return 0;
636 637 638 639 640 641 642 643 644 645
}

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

#ifdef CONFIG_X86_32
646 647 648 649 650 651
	if (boot_params.efi_info.efi_systab_hi ||
	    boot_params.efi_info.efi_memmap_hi) {
		pr_info("Table located above 4GB, disabling EFI.\n");
		efi_enabled = 0;
		return;
	}
652
	efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
653
	efi_native = !efi_64bit;
654 655
#else
	efi_phys.systab = (efi_system_table_t *)
656 657 658
			  (boot_params.efi_info.efi_systab |
			  ((__u64)boot_params.efi_info.efi_systab_hi<<32));
	efi_native = efi_64bit;
659 660
#endif

661 662 663 664
	if (efi_systab_init(efi_phys.systab)) {
		efi_enabled = 0;
		return;
	}
665 666 667 668 669 670 671 672 673 674

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

678 679 680
	pr_info("EFI v%u.%.02u by %s\n",
		efi.systab->hdr.revision >> 16,
		efi.systab->hdr.revision & 0xffff, vendor);
681

682 683 684 685
	if (efi_config_init(efi.systab->tables, efi.systab->nr_tables)) {
		efi_enabled = 0;
		return;
	}
686

687 688 689 690 691 692 693 694
	/*
	 * Note: We currently don't support runtime services on an EFI
	 * that doesn't match the kernel 32/64-bit mode.
	 */

	if (!efi_native)
		pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
	else if (efi_runtime_init()) {
695 696 697
		efi_enabled = 0;
		return;
	}
698

699 700 701 702
	if (efi_memmap_init()) {
		efi_enabled = 0;
		return;
	}
703 704 705 706
	if (efi_native) {
		x86_platform.get_wallclock = efi_get_time;
		x86_platform.set_wallclock = efi_set_rtc_mmss;
	}
707

H
Huang, Ying 已提交
708 709 710 711 712
#if EFI_DEBUG
	print_efi_memmap();
#endif
}

713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
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);
}

728 729 730 731 732 733 734 735
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 已提交
736 737 738 739

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

740
		efi_set_executable(md, true);
741 742 743
	}
}

H
Huang, Ying 已提交
744 745 746 747 748 749 750 751 752 753
/*
 * 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)
{
754
	efi_memory_desc_t *md, *prev_md = NULL;
H
Huang, Ying 已提交
755
	efi_status_t status;
H
Huang, Ying 已提交
756
	unsigned long size;
757
	u64 end, systab, addr, npages, end_pfn;
758 759
	void *p, *va, *new_memmap = NULL;
	int count = 0;
H
Huang, Ying 已提交
760 761

	efi.systab = NULL;
762

763 764 765 766 767 768 769 770
	/*
	 * We don't do virtual mode, since we don't do runtime services, on
	 * non-native EFI
	 */

	if (!efi_native)
		goto out;

771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
	/* 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 已提交
798 799
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
800 801 802
		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
		    md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
H
Huang, Ying 已提交
803
			continue;
H
Huang, Ying 已提交
804 805 806 807

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

808 809 810 811
		end_pfn = PFN_UP(end);
		if (end_pfn <= max_low_pfn_mapped
		    || (end_pfn > (1UL << (32 - PAGE_SHIFT))
			&& end_pfn <= max_pfn_mapped))
H
Huang, Ying 已提交
812
			va = __va(md->phys_addr);
H
Huang, Ying 已提交
813
		else
814
			va = efi_ioremap(md->phys_addr, size, md->type);
H
Huang, Ying 已提交
815 816 817 818

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

		if (!va) {
819
			pr_err("ioremap of 0x%llX failed!\n",
H
Huang, Ying 已提交
820
			       (unsigned long long)md->phys_addr);
H
Huang, Ying 已提交
821 822 823
			continue;
		}

H
Huang, Ying 已提交
824 825 826 827 828 829
		if (!(md->attribute & EFI_MEMORY_WB)) {
			addr = md->virt_addr;
			npages = md->num_pages;
			memrange_efi_to_native(&addr, &npages);
			set_memory_uc(addr, npages);
		}
830

H
Huang, Ying 已提交
831 832 833 834 835
		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;
		}
836 837 838 839 840 841
		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 已提交
842 843 844 845 846
	}

	BUG_ON(!efi.systab);

	status = phys_efi_set_virtual_address_map(
847
		memmap.desc_size * count,
H
Huang, Ying 已提交
848 849
		memmap.desc_size,
		memmap.desc_version,
850
		(efi_memory_desc_t *)__pa(new_memmap));
H
Huang, Ying 已提交
851 852

	if (status != EFI_SUCCESS) {
853 854
		pr_alert("Unable to switch EFI into virtual mode "
			 "(status=%lx)!\n", status);
H
Huang, Ying 已提交
855 856 857
		panic("EFI call to SetVirtualAddressMap() failed!");
	}

858 859 860 861 862 863 864
	/*
	 * Thankfully, it does seem that no runtime services other than
	 * SetVirtualAddressMap() will touch boot services code, so we can
	 * get rid of it all at this point
	 */
	efi_free_boot_services();

H
Huang, Ying 已提交
865 866 867 868 869 870 871 872 873 874 875 876 877 878 879
	/*
	 * 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.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;
880
	efi.set_virtual_address_map = NULL;
881 882 883
	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;
884 885
	if (__supported_pte_mask & _PAGE_NX)
		runtime_code_page_mkexec();
886 887

out:
888 889
	early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
	memmap.map = NULL;
890
	kfree(new_memmap);
H
Huang, Ying 已提交
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
}

/*
 * Convenience functions to obtain memory types and attributes
 */
u32 efi_mem_type(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->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;
}