[deliverable/linux.git] / drivers / firmware / efi / efi.c

/*
 * efi.c - EFI subsystem
 *
 * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
 * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
 * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
 *
 * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
 * allowing the efivarfs to be mounted or the efivars module to be loaded.
 * The existance of /sys/firmware/efi may also be used by userspace to
 * determine that the system supports EFI.
 *
 * This file is released under the GPLv2.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kobject.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/efi.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/io.h>
#include <linux/platform_device.h>

#include <asm/early_ioremap.h>

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,
	.smbios3		= 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,
	.fw_vendor		= EFI_INVALID_TABLE_ADDR,
	.runtime		= EFI_INVALID_TABLE_ADDR,
	.config_table		= EFI_INVALID_TABLE_ADDR,
	.esrt			= EFI_INVALID_TABLE_ADDR,
	.properties_table	= EFI_INVALID_TABLE_ADDR,
};
EXPORT_SYMBOL(efi);

static bool disable_runtime;
static int __init setup_noefi(char *arg)
{
	disable_runtime = true;
	return 0;
}
early_param("noefi", setup_noefi);

bool efi_runtime_disabled(void)
{
	return disable_runtime;
}

static int __init parse_efi_cmdline(char *str)
{
	if (!str) {
		pr_warn("need at least one option\n");
		return -EINVAL;
	}

	if (parse_option_str(str, "debug"))
		set_bit(EFI_DBG, &efi.flags);

	if (parse_option_str(str, "noruntime"))
		disable_runtime = true;

	return 0;
}
early_param("efi", parse_efi_cmdline);

struct kobject *efi_kobj;

/*
 * Let's not leave out systab information that snuck into
 * the efivars driver
 */
static ssize_t systab_show(struct kobject *kobj,
			   struct kobj_attribute *attr, char *buf)
{
	char *str = buf;

	if (!kobj || !buf)
		return -EINVAL;

	if (efi.mps != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "MPS=0x%lx\n", efi.mps);
	if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
	if (efi.acpi != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
	/*
	 * If both SMBIOS and SMBIOS3 entry points are implemented, the
	 * SMBIOS3 entry point shall be preferred, so we list it first to
	 * let applications stop parsing after the first match.
	 */
	if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
	if (efi.smbios != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
	if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
	if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
	if (efi.uga != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "UGA=0x%lx\n", efi.uga);

	return str - buf;
}

static struct kobj_attribute efi_attr_systab =
			__ATTR(systab, 0400, systab_show, NULL);

#define EFI_FIELD(var) efi.var

#define EFI_ATTR_SHOW(name) \
static ssize_t name##_show(struct kobject *kobj, \
				struct kobj_attribute *attr, char *buf) \
{ \
	return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
}

EFI_ATTR_SHOW(fw_vendor);
EFI_ATTR_SHOW(runtime);
EFI_ATTR_SHOW(config_table);

static ssize_t fw_platform_size_show(struct kobject *kobj,
				     struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
}

static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
static struct kobj_attribute efi_attr_fw_platform_size =
	__ATTR_RO(fw_platform_size);

static struct attribute *efi_subsys_attrs[] = {
	&efi_attr_systab.attr,
	&efi_attr_fw_vendor.attr,
	&efi_attr_runtime.attr,
	&efi_attr_config_table.attr,
	&efi_attr_fw_platform_size.attr,
	NULL,
};

static umode_t efi_attr_is_visible(struct kobject *kobj,
				   struct attribute *attr, int n)
{
	if (attr == &efi_attr_fw_vendor.attr) {
		if (efi_enabled(EFI_PARAVIRT) ||
				efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
			return 0;
	} else if (attr == &efi_attr_runtime.attr) {
		if (efi.runtime == EFI_INVALID_TABLE_ADDR)
			return 0;
	} else if (attr == &efi_attr_config_table.attr) {
		if (efi.config_table == EFI_INVALID_TABLE_ADDR)
			return 0;
	}

	return attr->mode;
}

static struct attribute_group efi_subsys_attr_group = {
	.attrs = efi_subsys_attrs,
	.is_visible = efi_attr_is_visible,
};

static struct efivars generic_efivars;
static struct efivar_operations generic_ops;

static int generic_ops_register(void)
{
	generic_ops.get_variable = efi.get_variable;
	generic_ops.set_variable = efi.set_variable;
	generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
	generic_ops.get_next_variable = efi.get_next_variable;
	generic_ops.query_variable_store = efi_query_variable_store;

	return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
}

static void generic_ops_unregister(void)
{
	efivars_unregister(&generic_efivars);
}

/*
 * We register the efi subsystem with the firmware subsystem and the
 * efivars subsystem with the efi subsystem, if the system was booted with
 * EFI.
 */
static int __init efisubsys_init(void)
{
	int error;

	if (!efi_enabled(EFI_BOOT))
		return 0;

	/* We register the efi directory at /sys/firmware/efi */
	efi_kobj = kobject_create_and_add("efi", firmware_kobj);
	if (!efi_kobj) {
		pr_err("efi: Firmware registration failed.\n");
		return -ENOMEM;
	}

	error = generic_ops_register();
	if (error)
		goto err_put;

	error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
	if (error) {
		pr_err("efi: Sysfs attribute export failed with error %d.\n",
		       error);
		goto err_unregister;
	}

	error = efi_runtime_map_init(efi_kobj);
	if (error)
		goto err_remove_group;

	/* and the standard mountpoint for efivarfs */
	error = sysfs_create_mount_point(efi_kobj, "efivars");
	if (error) {
		pr_err("efivars: Subsystem registration failed.\n");
		goto err_remove_group;
	}

	return 0;

err_remove_group:
	sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
err_unregister:
	generic_ops_unregister();
err_put:
	kobject_put(efi_kobj);
	return error;
}

subsys_initcall(efisubsys_init);

/*
 * Find the efi memory descriptor for a given physical address.  Given a
 * physicall address, determine if it exists within an EFI Memory Map entry,
 * and if so, populate the supplied memory descriptor with the appropriate
 * data.
 */
int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
{
	struct efi_memory_map *map = efi.memmap;
	phys_addr_t p, e;

	if (!efi_enabled(EFI_MEMMAP)) {
		pr_err_once("EFI_MEMMAP is not enabled.\n");
		return -EINVAL;
	}

	if (!map) {
		pr_err_once("efi.memmap is not set.\n");
		return -EINVAL;
	}
	if (!out_md) {
		pr_err_once("out_md is null.\n");
		return -EINVAL;
        }
	if (WARN_ON_ONCE(!map->phys_map))
		return -EINVAL;
	if (WARN_ON_ONCE(map->nr_map == 0) || WARN_ON_ONCE(map->desc_size == 0))
		return -EINVAL;

	e = map->phys_map + map->nr_map * map->desc_size;
	for (p = map->phys_map; p < e; p += map->desc_size) {
		efi_memory_desc_t *md;
		u64 size;
		u64 end;

		/*
		 * If a driver calls this after efi_free_boot_services,
		 * ->map will be NULL, and the target may also not be mapped.
		 * So just always get our own virtual map on the CPU.
		 *
		 */
		md = early_memremap(p, sizeof (*md));
		if (!md) {
			pr_err_once("early_memremap(%pa, %zu) failed.\n",
				    &p, sizeof (*md));
			return -ENOMEM;
		}

		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
		    md->type != EFI_BOOT_SERVICES_DATA &&
		    md->type != EFI_RUNTIME_SERVICES_DATA) {
			early_memunmap(md, sizeof (*md));
			continue;
		}

		size = md->num_pages << EFI_PAGE_SHIFT;
		end = md->phys_addr + size;
		if (phys_addr >= md->phys_addr && phys_addr < end) {
			memcpy(out_md, md, sizeof(*out_md));
			early_memunmap(md, sizeof (*md));
			return 0;
		}

		early_memunmap(md, sizeof (*md));
	}
	pr_err_once("requested map not found.\n");
	return -ENOENT;
}

/*
 * Calculate the highest address of an efi memory descriptor.
 */
u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
{
	u64 size = md->num_pages << EFI_PAGE_SHIFT;
	u64 end = md->phys_addr + size;
	return end;
}

static __initdata efi_config_table_type_t common_tables[] = {
	{ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
	{ACPI_TABLE_GUID, "ACPI", &efi.acpi},
	{HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
	{MPS_TABLE_GUID, "MPS", &efi.mps},
	{SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
	{SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
	{SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
	{UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
	{EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
	{EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
	{NULL_GUID, NULL, NULL},
};

static __init int match_config_table(efi_guid_t *guid,
				     unsigned long table,
				     efi_config_table_type_t *table_types)
{
	int i;

	if (table_types) {
		for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
			if (!efi_guidcmp(*guid, table_types[i].guid)) {
				*(table_types[i].ptr) = table;
				pr_cont(" %s=0x%lx ",
					table_types[i].name, table);
				return 1;
			}
		}
	}

	return 0;
}

int __init efi_config_parse_tables(void *config_tables, int count, int sz,
				   efi_config_table_type_t *arch_tables)
{
	void *tablep;
	int i;

	tablep = config_tables;
	pr_info("");
	for (i = 0; i < count; i++) {
		efi_guid_t guid;
		unsigned long table;

		if (efi_enabled(EFI_64BIT)) {
			u64 table64;
			guid = ((efi_config_table_64_t *)tablep)->guid;
			table64 = ((efi_config_table_64_t *)tablep)->table;
			table = table64;
#ifndef CONFIG_64BIT
			if (table64 >> 32) {
				pr_cont("\n");
				pr_err("Table located above 4GB, disabling EFI.\n");
				return -EINVAL;
			}
#endif
		} else {
			guid = ((efi_config_table_32_t *)tablep)->guid;
			table = ((efi_config_table_32_t *)tablep)->table;
		}

		if (!match_config_table(&guid, table, common_tables))
			match_config_table(&guid, table, arch_tables);

		tablep += sz;
	}
	pr_cont("\n");
	set_bit(EFI_CONFIG_TABLES, &efi.flags);

	/* Parse the EFI Properties table if it exists */
	if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
		efi_properties_table_t *tbl;

		tbl = early_memremap(efi.properties_table, sizeof(*tbl));
		if (tbl == NULL) {
			pr_err("Could not map Properties table!\n");
			return -ENOMEM;
		}

		if (tbl->memory_protection_attribute &
		    EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
			set_bit(EFI_NX_PE_DATA, &efi.flags);

		early_memunmap(tbl, sizeof(*tbl));
	}

	return 0;
}

int __init efi_config_init(efi_config_table_type_t *arch_tables)
{
	void *config_tables;
	int sz, ret;

	if (efi_enabled(EFI_64BIT))
		sz = sizeof(efi_config_table_64_t);
	else
		sz = sizeof(efi_config_table_32_t);

	/*
	 * Let's see what config tables the firmware passed to us.
	 */
	config_tables = early_memremap(efi.systab->tables,
				       efi.systab->nr_tables * sz);
	if (config_tables == NULL) {
		pr_err("Could not map Configuration table!\n");
		return -ENOMEM;
	}

	ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
				      arch_tables);

	early_memunmap(config_tables, efi.systab->nr_tables * sz);
	return ret;
}

#ifdef CONFIG_EFI_VARS_MODULE
static int __init efi_load_efivars(void)
{
	struct platform_device *pdev;

	if (!efi_enabled(EFI_RUNTIME_SERVICES))
		return 0;

	pdev = platform_device_register_simple("efivars", 0, NULL, 0);
	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
}
device_initcall(efi_load_efivars);
#endif

#ifdef CONFIG_EFI_PARAMS_FROM_FDT

#define UEFI_PARAM(name, prop, field)			   \
	{						   \
		{ name },				   \
		{ prop },				   \
		offsetof(struct efi_fdt_params, field),    \
		FIELD_SIZEOF(struct efi_fdt_params, field) \
	}

static __initdata struct {
	const char name[32];
	const char propname[32];
	int offset;
	int size;
} dt_params[] = {
	UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
	UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
	UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
	UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
	UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
};

struct param_info {
	int found;
	void *params;
};

static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
				       int depth, void *data)
{
	struct param_info *info = data;
	const void *prop;
	void *dest;
	u64 val;
	int i, len;

	if (depth != 1 || strcmp(uname, "chosen") != 0)
		return 0;

	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
		prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
		if (!prop)
			return 0;
		dest = info->params + dt_params[i].offset;
		info->found++;

		val = of_read_number(prop, len / sizeof(u32));

		if (dt_params[i].size == sizeof(u32))
			*(u32 *)dest = val;
		else
			*(u64 *)dest = val;

		if (efi_enabled(EFI_DBG))
			pr_info("  %s: 0x%0*llx\n", dt_params[i].name,
				dt_params[i].size * 2, val);
	}
	return 1;
}

int __init efi_get_fdt_params(struct efi_fdt_params *params)
{
	struct param_info info;
	int ret;

	pr_info("Getting EFI parameters from FDT:\n");

	info.found = 0;
	info.params = params;

	ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
	if (!info.found)
		pr_info("UEFI not found.\n");
	else if (!ret)
		pr_err("Can't find '%s' in device tree!\n",
		       dt_params[info.found].name);

	return ret;
}
#endif /* CONFIG_EFI_PARAMS_FROM_FDT */

static __initdata char memory_type_name[][20] = {
	"Reserved",
	"Loader Code",
	"Loader Data",
	"Boot Code",
	"Boot Data",
	"Runtime Code",
	"Runtime Data",
	"Conventional Memory",
	"Unusable Memory",
	"ACPI Reclaim Memory",
	"ACPI Memory NVS",
	"Memory Mapped I/O",
	"MMIO Port Space",
	"PAL Code",
	"Persistent Memory",
};

char * __init efi_md_typeattr_format(char *buf, size_t size,
				     const efi_memory_desc_t *md)
{
	char *pos;
	int type_len;
	u64 attr;

	pos = buf;
	if (md->type >= ARRAY_SIZE(memory_type_name))
		type_len = snprintf(pos, size, "[type=%u", md->type);
	else
		type_len = snprintf(pos, size, "[%-*s",
				    (int)(sizeof(memory_type_name[0]) - 1),
				    memory_type_name[md->type]);
	if (type_len >= size)
		return buf;

	pos += type_len;
	size -= type_len;

	attr = md->attribute;
	if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
		     EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
		     EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
		     EFI_MEMORY_NV |
		     EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
		snprintf(pos, size, "|attr=0x%016llx]",
			 (unsigned long long)attr);
	else
		snprintf(pos, size,
			 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
			 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
			 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
			 attr & EFI_MEMORY_NV      ? "NV"  : "",
			 attr & EFI_MEMORY_XP      ? "XP"  : "",
			 attr & EFI_MEMORY_RP      ? "RP"  : "",
			 attr & EFI_MEMORY_WP      ? "WP"  : "",
			 attr & EFI_MEMORY_RO      ? "RO"  : "",
			 attr & EFI_MEMORY_UCE     ? "UCE" : "",
			 attr & EFI_MEMORY_WB      ? "WB"  : "",
			 attr & EFI_MEMORY_WT      ? "WT"  : "",
			 attr & EFI_MEMORY_WC      ? "WC"  : "",
			 attr & EFI_MEMORY_UC      ? "UC"  : "");
	return buf;
}

/*
 * efi_mem_attributes - lookup memmap attributes for physical address
 * @phys_addr: the physical address to lookup
 *
 * Search in the EFI memory map for the region covering
 * @phys_addr. Returns the EFI memory attributes if the region
 * was found in the memory map, 0 otherwise.
 *
 * Despite being marked __weak, most architectures should *not*
 * override this function. It is __weak solely for the benefit
 * of ia64 which has a funky EFI memory map that doesn't work
 * the same way as other architectures.
 */
u64 __weak efi_mem_attributes(unsigned long phys_addr)
{
	struct efi_memory_map *map;
	efi_memory_desc_t *md;
	void *p;

	if (!efi_enabled(EFI_MEMMAP))
		return 0;

	map = efi.memmap;
	for (p = map->map; p < map->map_end; p += map->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;
}
Commit	Line	Data
a9499fa7 TG	1	/*
	2	* efi.c - EFI subsystem
	3	*
	4	* Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
	5	* Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
	6	* Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
	7	*
	8	* This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
	9	* allowing the efivarfs to be mounted or the efivars module to be loaded.
	10	* The existance of /sys/firmware/efi may also be used by userspace to
	11	* determine that the system supports EFI.
	12	*
	13	* This file is released under the GPLv2.
	14	*/
	15
272686bf LL	16	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
272686bf LL	17
a9499fa7 TG	18	#include <linux/kobject.h>
	19	#include <linux/module.h>
	20	#include <linux/init.h>
	21	#include <linux/device.h>
	22	#include <linux/efi.h>
0302f71c MS	23	#include <linux/of.h>
0302f71c MS	24	#include <linux/of_fdt.h>
272686bf	25	#include <linux/io.h>
28d54022	26	#include <linux/platform_device.h>
272686bf	27
0f7f2f0c	28	#include <asm/early_ioremap.h>
f7d92489	29
272686bf	30	struct efi __read_mostly efi = {
bf924863 AB	31	.mps = EFI_INVALID_TABLE_ADDR,
	32	.acpi = EFI_INVALID_TABLE_ADDR,
	33	.acpi20 = EFI_INVALID_TABLE_ADDR,
	34	.smbios = EFI_INVALID_TABLE_ADDR,
	35	.smbios3 = EFI_INVALID_TABLE_ADDR,
	36	.sal_systab = EFI_INVALID_TABLE_ADDR,
	37	.boot_info = EFI_INVALID_TABLE_ADDR,
	38	.hcdp = EFI_INVALID_TABLE_ADDR,
	39	.uga = EFI_INVALID_TABLE_ADDR,
	40	.uv_systab = EFI_INVALID_TABLE_ADDR,
	41	.fw_vendor = EFI_INVALID_TABLE_ADDR,
	42	.runtime = EFI_INVALID_TABLE_ADDR,
	43	.config_table = EFI_INVALID_TABLE_ADDR,
	44	.esrt = EFI_INVALID_TABLE_ADDR,
	45	.properties_table = EFI_INVALID_TABLE_ADDR,
272686bf LL	46	};
272686bf LL	47	EXPORT_SYMBOL(efi);
a9499fa7	48
b2e0a54a DY	49	static bool disable_runtime;
	50	static int __init setup_noefi(char *arg)
	51	{
	52	disable_runtime = true;
	53	return 0;
	54	}
	55	early_param("noefi", setup_noefi);
	56
	57	bool efi_runtime_disabled(void)
	58	{
	59	return disable_runtime;
	60	}
	61
5ae3683c DY	62	static int __init parse_efi_cmdline(char *str)
5ae3683c DY	63	{
9115c758 RN	64	if (!str) {
	65	pr_warn("need at least one option\n");
	66	return -EINVAL;
	67	}
	68
12dd00e8 LL	69	if (parse_option_str(str, "debug"))
	70	set_bit(EFI_DBG, &efi.flags);
	71
5ae3683c DY	72	if (parse_option_str(str, "noruntime"))
	73	disable_runtime = true;
	74
	75	return 0;
	76	}
	77	early_param("efi", parse_efi_cmdline);
	78
0bb54905	79	struct kobject *efi_kobj;
a9499fa7 TG	80
	81	/*
	82	* Let's not leave out systab information that snuck into
	83	* the efivars driver
	84	*/
	85	static ssize_t systab_show(struct kobject *kobj,
	86	struct kobj_attribute attr, char buf)
	87	{
	88	char *str = buf;
	89
	90	if (!kobj \|\| !buf)
	91	return -EINVAL;
	92
	93	if (efi.mps != EFI_INVALID_TABLE_ADDR)
	94	str += sprintf(str, "MPS=0x%lx\n", efi.mps);
	95	if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
	96	str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
	97	if (efi.acpi != EFI_INVALID_TABLE_ADDR)
	98	str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
b119fe08 JD	99	/*
	100	* If both SMBIOS and SMBIOS3 entry points are implemented, the
	101	* SMBIOS3 entry point shall be preferred, so we list it first to
	102	* let applications stop parsing after the first match.
	103	*/
e1ccbbc9 AB	104	if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
e1ccbbc9 AB	105	str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
b119fe08 JD	106	if (efi.smbios != EFI_INVALID_TABLE_ADDR)
b119fe08 JD	107	str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
a9499fa7 TG	108	if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
	109	str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
	110	if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
	111	str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
	112	if (efi.uga != EFI_INVALID_TABLE_ADDR)
	113	str += sprintf(str, "UGA=0x%lx\n", efi.uga);
	114
	115	return str - buf;
	116	}
	117
	118	static struct kobj_attribute efi_attr_systab =
	119	__ATTR(systab, 0400, systab_show, NULL);
	120
a0998eb1 DY	121	#define EFI_FIELD(var) efi.var
	122
	123	#define EFI_ATTR_SHOW(name) \
	124	static ssize_t name##_show(struct kobject *kobj, \
	125	struct kobj_attribute attr, char buf) \
	126	{ \
	127	return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
	128	}
	129
	130	EFI_ATTR_SHOW(fw_vendor);
	131	EFI_ATTR_SHOW(runtime);
	132	EFI_ATTR_SHOW(config_table);
	133
2859dff9 SM	134	static ssize_t fw_platform_size_show(struct kobject *kobj,
	135	struct kobj_attribute attr, char buf)
	136	{
	137	return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
	138	}
	139
a0998eb1 DY	140	static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
	141	static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
	142	static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
2859dff9 SM	143	static struct kobj_attribute efi_attr_fw_platform_size =
2859dff9 SM	144	__ATTR_RO(fw_platform_size);
a0998eb1	145
a9499fa7 TG	146	static struct attribute *efi_subsys_attrs[] = {
a9499fa7 TG	147	&efi_attr_systab.attr,
a0998eb1 DY	148	&efi_attr_fw_vendor.attr,
	149	&efi_attr_runtime.attr,
	150	&efi_attr_config_table.attr,
2859dff9	151	&efi_attr_fw_platform_size.attr,
a0998eb1	152	NULL,
a9499fa7 TG	153	};
a9499fa7 TG	154
a0998eb1 DY	155	static umode_t efi_attr_is_visible(struct kobject *kobj,
	156	struct attribute *attr, int n)
	157	{
9f27bc54 DK	158	if (attr == &efi_attr_fw_vendor.attr) {
	159	if (efi_enabled(EFI_PARAVIRT) \|\|
	160	efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
	161	return 0;
	162	} else if (attr == &efi_attr_runtime.attr) {
	163	if (efi.runtime == EFI_INVALID_TABLE_ADDR)
	164	return 0;
	165	} else if (attr == &efi_attr_config_table.attr) {
	166	if (efi.config_table == EFI_INVALID_TABLE_ADDR)
	167	return 0;
	168	}
a0998eb1	169
9f27bc54	170	return attr->mode;
a0998eb1 DY	171	}
a0998eb1 DY	172
a9499fa7 TG	173	static struct attribute_group efi_subsys_attr_group = {
a9499fa7 TG	174	.attrs = efi_subsys_attrs,
a0998eb1	175	.is_visible = efi_attr_is_visible,
a9499fa7 TG	176	};
	177
	178	static struct efivars generic_efivars;
	179	static struct efivar_operations generic_ops;
	180
	181	static int generic_ops_register(void)
	182	{
	183	generic_ops.get_variable = efi.get_variable;
	184	generic_ops.set_variable = efi.set_variable;
9c6672ac	185	generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
a9499fa7	186	generic_ops.get_next_variable = efi.get_next_variable;
a614e192	187	generic_ops.query_variable_store = efi_query_variable_store;
a9499fa7 TG	188
	189	return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
	190	}
	191
	192	static void generic_ops_unregister(void)
	193	{
	194	efivars_unregister(&generic_efivars);
	195	}
	196
	197	/*
	198	* We register the efi subsystem with the firmware subsystem and the
	199	* efivars subsystem with the efi subsystem, if the system was booted with
	200	* EFI.
	201	*/
	202	static int __init efisubsys_init(void)
	203	{
	204	int error;
	205
	206	if (!efi_enabled(EFI_BOOT))
	207	return 0;
	208
	209	/* We register the efi directory at /sys/firmware/efi */
	210	efi_kobj = kobject_create_and_add("efi", firmware_kobj);
	211	if (!efi_kobj) {
	212	pr_err("efi: Firmware registration failed.\n");
	213	return -ENOMEM;
	214	}
	215
	216	error = generic_ops_register();
	217	if (error)
	218	goto err_put;
	219
	220	error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
	221	if (error) {
	222	pr_err("efi: Sysfs attribute export failed with error %d.\n",
	223	error);
	224	goto err_unregister;
	225	}
	226
926172d4 DY	227	error = efi_runtime_map_init(efi_kobj);
	228	if (error)
	229	goto err_remove_group;
	230
a9499fa7	231	/* and the standard mountpoint for efivarfs */
f9bb4882 EB	232	error = sysfs_create_mount_point(efi_kobj, "efivars");
f9bb4882 EB	233	if (error) {
a9499fa7	234	pr_err("efivars: Subsystem registration failed.\n");
a9499fa7 TG	235	goto err_remove_group;
	236	}
	237
	238	return 0;
	239
	240	err_remove_group:
	241	sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
	242	err_unregister:
	243	generic_ops_unregister();
	244	err_put:
	245	kobject_put(efi_kobj);
	246	return error;
	247	}
	248
	249	subsys_initcall(efisubsys_init);
272686bf	250
0bb54905 PJ	251	/*
	252	* Find the efi memory descriptor for a given physical address. Given a
	253	* physicall address, determine if it exists within an EFI Memory Map entry,
	254	* and if so, populate the supplied memory descriptor with the appropriate
	255	* data.
	256	*/
	257	int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
	258	{
	259	struct efi_memory_map *map = efi.memmap;
44511fb9	260	phys_addr_t p, e;
0bb54905 PJ	261
	262	if (!efi_enabled(EFI_MEMMAP)) {
	263	pr_err_once("EFI_MEMMAP is not enabled.\n");
	264	return -EINVAL;
	265	}
	266
	267	if (!map) {
	268	pr_err_once("efi.memmap is not set.\n");
	269	return -EINVAL;
	270	}
	271	if (!out_md) {
	272	pr_err_once("out_md is null.\n");
	273	return -EINVAL;
	274	}
	275	if (WARN_ON_ONCE(!map->phys_map))
	276	return -EINVAL;
	277	if (WARN_ON_ONCE(map->nr_map == 0) \|\| WARN_ON_ONCE(map->desc_size == 0))
	278	return -EINVAL;
	279
	280	e = map->phys_map + map->nr_map * map->desc_size;
	281	for (p = map->phys_map; p < e; p += map->desc_size) {
	282	efi_memory_desc_t *md;
	283	u64 size;
	284	u64 end;
	285
	286	/*
	287	* If a driver calls this after efi_free_boot_services,
	288	* ->map will be NULL, and the target may also not be mapped.
	289	* So just always get our own virtual map on the CPU.
	290	*
	291	*/
44511fb9	292	md = early_memremap(p, sizeof (*md));
0bb54905	293	if (!md) {
44511fb9 AB	294	pr_err_once("early_memremap(%pa, %zu) failed.\n",
44511fb9 AB	295	&p, sizeof (*md));
0bb54905 PJ	296	return -ENOMEM;
	297	}
	298
	299	if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
	300	md->type != EFI_BOOT_SERVICES_DATA &&
	301	md->type != EFI_RUNTIME_SERVICES_DATA) {
	302	early_memunmap(md, sizeof (*md));
	303	continue;
	304	}
	305
	306	size = md->num_pages << EFI_PAGE_SHIFT;
	307	end = md->phys_addr + size;
	308	if (phys_addr >= md->phys_addr && phys_addr < end) {
	309	memcpy(out_md, md, sizeof(*out_md));
	310	early_memunmap(md, sizeof (*md));
	311	return 0;
	312	}
	313
	314	early_memunmap(md, sizeof (*md));
	315	}
	316	pr_err_once("requested map not found.\n");
	317	return -ENOENT;
	318	}
	319
	320	/*
	321	* Calculate the highest address of an efi memory descriptor.
	322	*/
	323	u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
	324	{
	325	u64 size = md->num_pages << EFI_PAGE_SHIFT;
	326	u64 end = md->phys_addr + size;
	327	return end;
	328	}
272686bf LL	329
	330	static __initdata efi_config_table_type_t common_tables[] = {
	331	{ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
	332	{ACPI_TABLE_GUID, "ACPI", &efi.acpi},
	333	{HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
	334	{MPS_TABLE_GUID, "MPS", &efi.mps},
	335	{SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
	336	{SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
e1ccbbc9	337	{SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
272686bf	338	{UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
0bb54905	339	{EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
bf924863	340	{EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
69e60841	341	{NULL_GUID, NULL, NULL},
272686bf LL	342	};
	343
	344	static __init int match_config_table(efi_guid_t *guid,
	345	unsigned long table,
	346	efi_config_table_type_t *table_types)
	347	{
272686bf LL	348	int i;
	349
	350	if (table_types) {
272686bf	351	for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
272686bf LL	352	if (!efi_guidcmp(*guid, table_types[i].guid)) {
	353	*(table_types[i].ptr) = table;
	354	pr_cont(" %s=0x%lx ",
	355	table_types[i].name, table);
	356	return 1;
	357	}
	358	}
	359	}
	360
	361	return 0;
	362	}
	363
7bb68410 AB	364	int __init efi_config_parse_tables(void *config_tables, int count, int sz,
7bb68410 AB	365	efi_config_table_type_t *arch_tables)
272686bf	366	{
7bb68410 AB	367	void *tablep;
7bb68410 AB	368	int i;
272686bf LL	369
	370	tablep = config_tables;
	371	pr_info("");
7bb68410	372	for (i = 0; i < count; i++) {
272686bf LL	373	efi_guid_t guid;
	374	unsigned long table;
	375
	376	if (efi_enabled(EFI_64BIT)) {
	377	u64 table64;
	378	guid = ((efi_config_table_64_t *)tablep)->guid;
	379	table64 = ((efi_config_table_64_t *)tablep)->table;
	380	table = table64;
	381	#ifndef CONFIG_64BIT
	382	if (table64 >> 32) {
	383	pr_cont("\n");
	384	pr_err("Table located above 4GB, disabling EFI.\n");
272686bf LL	385	return -EINVAL;
	386	}
	387	#endif
	388	} else {
	389	guid = ((efi_config_table_32_t *)tablep)->guid;
	390	table = ((efi_config_table_32_t *)tablep)->table;
	391	}
	392
	393	if (!match_config_table(&guid, table, common_tables))
	394	match_config_table(&guid, table, arch_tables);
	395
	396	tablep += sz;
	397	}
	398	pr_cont("\n");
0f8093a9	399	set_bit(EFI_CONFIG_TABLES, &efi.flags);
a1041713 AB	400
	401	/* Parse the EFI Properties table if it exists */
	402	if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
	403	efi_properties_table_t *tbl;
	404
	405	tbl = early_memremap(efi.properties_table, sizeof(*tbl));
	406	if (tbl == NULL) {
	407	pr_err("Could not map Properties table!\n");
	408	return -ENOMEM;
	409	}
	410
	411	if (tbl->memory_protection_attribute &
	412	EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
	413	set_bit(EFI_NX_PE_DATA, &efi.flags);
	414
	415	early_memunmap(tbl, sizeof(*tbl));
	416	}
	417
272686bf LL	418	return 0;
272686bf LL	419	}
0302f71c	420
7bb68410 AB	421	int __init efi_config_init(efi_config_table_type_t *arch_tables)
	422	{
	423	void *config_tables;
	424	int sz, ret;
	425
	426	if (efi_enabled(EFI_64BIT))
	427	sz = sizeof(efi_config_table_64_t);
	428	else
	429	sz = sizeof(efi_config_table_32_t);
	430
	431	/*
	432	* Let's see what config tables the firmware passed to us.
	433	*/
	434	config_tables = early_memremap(efi.systab->tables,
	435	efi.systab->nr_tables * sz);
	436	if (config_tables == NULL) {
	437	pr_err("Could not map Configuration table!\n");
	438	return -ENOMEM;
	439	}
	440
	441	ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
	442	arch_tables);
	443
	444	early_memunmap(config_tables, efi.systab->nr_tables * sz);
	445	return ret;
	446	}
	447
28d54022 LCY	448	#ifdef CONFIG_EFI_VARS_MODULE
	449	static int __init efi_load_efivars(void)
	450	{
	451	struct platform_device *pdev;
	452
	453	if (!efi_enabled(EFI_RUNTIME_SERVICES))
	454	return 0;
	455
	456	pdev = platform_device_register_simple("efivars", 0, NULL, 0);
	457	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
	458	}
	459	device_initcall(efi_load_efivars);
	460	#endif
	461
0302f71c MS	462	#ifdef CONFIG_EFI_PARAMS_FROM_FDT
	463
	464	#define UEFI_PARAM(name, prop, field) \
	465	{ \
	466	{ name }, \
	467	{ prop }, \
	468	offsetof(struct efi_fdt_params, field), \
	469	FIELD_SIZEOF(struct efi_fdt_params, field) \
	470	}
	471
	472	static __initdata struct {
	473	const char name[32];
	474	const char propname[32];
	475	int offset;
	476	int size;
	477	} dt_params[] = {
	478	UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
	479	UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
	480	UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
	481	UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
	482	UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
	483	};
	484
	485	struct param_info {
29e2435f	486	int found;
0302f71c MS	487	void *params;
	488	};
	489
	490	static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
	491	int depth, void *data)
	492	{
	493	struct param_info *info = data;
6fb8cc82 CM	494	const void *prop;
6fb8cc82 CM	495	void *dest;
0302f71c	496	u64 val;
6fb8cc82	497	int i, len;
0302f71c	498
11629305	499	if (depth != 1 \|\| strcmp(uname, "chosen") != 0)
0302f71c MS	500	return 0;
0302f71c MS	501
0302f71c MS	502	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
0302f71c MS	503	prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
29e2435f	504	if (!prop)
0302f71c	505	return 0;
0302f71c	506	dest = info->params + dt_params[i].offset;
29e2435f	507	info->found++;
0302f71c MS	508
	509	val = of_read_number(prop, len / sizeof(u32));
	510
	511	if (dt_params[i].size == sizeof(u32))
	512	(u32 )dest = val;
	513	else
	514	(u64 )dest = val;
	515
7968c0e3	516	if (efi_enabled(EFI_DBG))
0302f71c MS	517	pr_info(" %s: 0x%0*llx\n", dt_params[i].name,
	518	dt_params[i].size * 2, val);
	519	}
	520	return 1;
	521	}
	522
7968c0e3	523	int __init efi_get_fdt_params(struct efi_fdt_params *params)
0302f71c MS	524	{
0302f71c MS	525	struct param_info info;
29e2435f CM	526	int ret;
	527
	528	pr_info("Getting EFI parameters from FDT:\n");
0302f71c	529
29e2435f	530	info.found = 0;
0302f71c MS	531	info.params = params;
0302f71c MS	532
29e2435f CM	533	ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
	534	if (!info.found)
	535	pr_info("UEFI not found.\n");
	536	else if (!ret)
	537	pr_err("Can't find '%s' in device tree!\n",
	538	dt_params[info.found].name);
	539
	540	return ret;
0302f71c MS	541	}
0302f71c MS	542	#endif /* CONFIG_EFI_PARAMS_FROM_FDT */
98d2a6ca LE	543
	544	static __initdata char memory_type_name[][20] = {
	545	"Reserved",
	546	"Loader Code",
	547	"Loader Data",
	548	"Boot Code",
	549	"Boot Data",
	550	"Runtime Code",
	551	"Runtime Data",
	552	"Conventional Memory",
	553	"Unusable Memory",
	554	"ACPI Reclaim Memory",
	555	"ACPI Memory NVS",
	556	"Memory Mapped I/O",
	557	"MMIO Port Space",
35575e0e RE	558	"PAL Code",
35575e0e RE	559	"Persistent Memory",
98d2a6ca LE	560	};
	561
	562	char * __init efi_md_typeattr_format(char *buf, size_t size,
	563	const efi_memory_desc_t *md)
	564	{
	565	char *pos;
	566	int type_len;
	567	u64 attr;
	568
	569	pos = buf;
	570	if (md->type >= ARRAY_SIZE(memory_type_name))
	571	type_len = snprintf(pos, size, "[type=%u", md->type);
	572	else
	573	type_len = snprintf(pos, size, "[%-*s",
	574	(int)(sizeof(memory_type_name[0]) - 1),
	575	memory_type_name[md->type]);
	576	if (type_len >= size)
	577	return buf;
	578
	579	pos += type_len;
	580	size -= type_len;
	581
	582	attr = md->attribute;
	583	if (attr & ~(EFI_MEMORY_UC \| EFI_MEMORY_WC \| EFI_MEMORY_WT \|
87db73ae AB	584	EFI_MEMORY_WB \| EFI_MEMORY_UCE \| EFI_MEMORY_RO \|
87db73ae AB	585	EFI_MEMORY_WP \| EFI_MEMORY_RP \| EFI_MEMORY_XP \|
c016ca08	586	EFI_MEMORY_NV \|
8be4432e	587	EFI_MEMORY_RUNTIME \| EFI_MEMORY_MORE_RELIABLE))
98d2a6ca LE	588	snprintf(pos, size, "\|attr=0x%016llx]",
	589	(unsigned long long)attr);
	590	else
c016ca08 RE	591	snprintf(pos, size,
c016ca08 RE	592	"\|%3s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%3s\|%2s\|%2s\|%2s\|%2s]",
98d2a6ca	593	attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
8be4432e	594	attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
c016ca08	595	attr & EFI_MEMORY_NV ? "NV" : "",
98d2a6ca LE	596	attr & EFI_MEMORY_XP ? "XP" : "",
	597	attr & EFI_MEMORY_RP ? "RP" : "",
	598	attr & EFI_MEMORY_WP ? "WP" : "",
87db73ae	599	attr & EFI_MEMORY_RO ? "RO" : "",
98d2a6ca LE	600	attr & EFI_MEMORY_UCE ? "UCE" : "",
	601	attr & EFI_MEMORY_WB ? "WB" : "",
	602	attr & EFI_MEMORY_WT ? "WT" : "",
	603	attr & EFI_MEMORY_WC ? "WC" : "",
	604	attr & EFI_MEMORY_UC ? "UC" : "");
	605	return buf;
	606	}
7bf79311 JZZ	607
	608	/*
	609	* efi_mem_attributes - lookup memmap attributes for physical address
	610	* @phys_addr: the physical address to lookup
	611	*
	612	* Search in the EFI memory map for the region covering
	613	* @phys_addr. Returns the EFI memory attributes if the region
	614	* was found in the memory map, 0 otherwise.
	615	*
	616	* Despite being marked __weak, most architectures should not
	617	* override this function. It is __weak solely for the benefit
	618	* of ia64 which has a funky EFI memory map that doesn't work
	619	* the same way as other architectures.
	620	*/
	621	u64 __weak efi_mem_attributes(unsigned long phys_addr)
	622	{
0ce423b6	623	struct efi_memory_map *map;
7bf79311 JZZ	624	efi_memory_desc_t *md;
	625	void *p;
	626
	627	if (!efi_enabled(EFI_MEMMAP))
	628	return 0;
	629
0ce423b6 MF	630	map = efi.memmap;
0ce423b6 MF	631	for (p = map->map; p < map->map_end; p += map->desc_size) {
7bf79311 JZZ	632	md = p;
	633	if ((md->phys_addr <= phys_addr) &&
	634	(phys_addr < (md->phys_addr +
	635	(md->num_pages << EFI_PAGE_SHIFT))))
	636	return md->attribute;
	637	}
	638	return 0;
	639	}