[people/ms/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>

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,
};
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 (parse_option_str(str, "noruntime"))
		disable_runtime = true;

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

static struct kobject *efi_kobj;
static struct kobject *efivars_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 (efi.smbios != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
	if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
		str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
	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 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 attribute *efi_subsys_attrs[] = {
	&efi_attr_systab.attr,
	&efi_attr_fw_vendor.attr,
	&efi_attr_runtime.attr,
	&efi_attr_config_table.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 efivar_operations_no_const generic_ops __read_only;

static int generic_ops_register(void)
{
	pax_open_kernel();
	*(void **)&generic_ops.get_variable = efi.get_variable;
	*(void **)&generic_ops.set_variable = efi.set_variable;
	*(void **)&generic_ops.get_next_variable = efi.get_next_variable;
	*(void **)&generic_ops.query_variable_store = efi_query_variable_store;
	pax_close_kernel();

	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 */
	efivars_kobj = kobject_create_and_add("efivars", efi_kobj);
	if (!efivars_kobj) {
		pr_err("efivars: Subsystem registration failed.\n");
		error = -ENOMEM;
		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);


/*
 * 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)
{
	struct efi_memory_map *map;
	void *p;
	map = efi.memmap;
	if (!map)
		return NULL;
	if (WARN_ON(!map->map))
		return NULL;
	for (p = map->map; p < map->map_end; p += map->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;
}

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},
	{NULL_GUID, NULL, NULL},
};

static __init int match_config_table(efi_guid_t *guid,
				     unsigned long table,
				     efi_config_table_type_t *table_types)
{
	u8 str[EFI_VARIABLE_GUID_LEN + 1];
	int i;

	if (table_types) {
		efi_guid_unparse(guid, str);

		for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
			efi_guid_unparse(&table_types[i].guid, str);

			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_init(efi_config_table_type_t *arch_tables)
{
	void *config_tables, *tablep;
	int i, sz;

	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;
	}

	tablep = config_tables;
	pr_info("");
	for (i = 0; i < efi.systab->nr_tables; 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");
				early_memunmap(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;
		}

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

		tablep += sz;
	}
	pr_cont("\n");
	early_memunmap(config_tables, efi.systab->nr_tables * sz);

	set_bit(EFI_CONFIG_TABLES, &efi.flags);

	return 0;
}

#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 verbose;
	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 && strcmp(uname, "chosen@0") != 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 (info->verbose)
			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, int verbose)
{
	struct param_info info;
	int ret;

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

	info.verbose = verbose;
	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"
};

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_WP |
		     EFI_MEMORY_RP | EFI_MEMORY_XP | EFI_MEMORY_RUNTIME))
		snprintf(pos, size, "|attr=0x%016llx]",
			 (unsigned long long)attr);
	else
		snprintf(pos, size, "|%3s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
			 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
			 attr & EFI_MEMORY_XP      ? "XP"  : "",
			 attr & EFI_MEMORY_RP      ? "RP"  : "",
			 attr & EFI_MEMORY_WP      ? "WP"  : "",
			 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;
}
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 LL	27
	28	struct efi __read_mostly efi = {
	29	.mps = EFI_INVALID_TABLE_ADDR,
	30	.acpi = EFI_INVALID_TABLE_ADDR,
	31	.acpi20 = EFI_INVALID_TABLE_ADDR,
	32	.smbios = EFI_INVALID_TABLE_ADDR,
e1ccbbc9	33	.smbios3 = EFI_INVALID_TABLE_ADDR,
272686bf LL	34	.sal_systab = EFI_INVALID_TABLE_ADDR,
	35	.boot_info = EFI_INVALID_TABLE_ADDR,
	36	.hcdp = EFI_INVALID_TABLE_ADDR,
	37	.uga = EFI_INVALID_TABLE_ADDR,
	38	.uv_systab = EFI_INVALID_TABLE_ADDR,
a0998eb1 DY	39	.fw_vendor = EFI_INVALID_TABLE_ADDR,
	40	.runtime = EFI_INVALID_TABLE_ADDR,
	41	.config_table = EFI_INVALID_TABLE_ADDR,
272686bf LL	42	};
272686bf LL	43	EXPORT_SYMBOL(efi);
a9499fa7	44
b2e0a54a DY	45	static bool disable_runtime;
	46	static int __init setup_noefi(char *arg)
	47	{
	48	disable_runtime = true;
	49	return 0;
	50	}
	51	early_param("noefi", setup_noefi);
	52
	53	bool efi_runtime_disabled(void)
	54	{
	55	return disable_runtime;
	56	}
	57
5ae3683c DY	58	static int __init parse_efi_cmdline(char *str)
	59	{
	60	if (parse_option_str(str, "noruntime"))
	61	disable_runtime = true;
	62
	63	return 0;
	64	}
	65	early_param("efi", parse_efi_cmdline);
	66
a9499fa7 TG	67	static struct kobject *efi_kobj;
	68	static struct kobject *efivars_kobj;
	69
	70	/*
	71	* Let's not leave out systab information that snuck into
	72	* the efivars driver
	73	*/
	74	static ssize_t systab_show(struct kobject *kobj,
	75	struct kobj_attribute attr, char buf)
	76	{
	77	char *str = buf;
	78
	79	if (!kobj \|\| !buf)
	80	return -EINVAL;
	81
	82	if (efi.mps != EFI_INVALID_TABLE_ADDR)
	83	str += sprintf(str, "MPS=0x%lx\n", efi.mps);
	84	if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
	85	str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
	86	if (efi.acpi != EFI_INVALID_TABLE_ADDR)
	87	str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
	88	if (efi.smbios != EFI_INVALID_TABLE_ADDR)
	89	str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
e1ccbbc9 AB	90	if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
e1ccbbc9 AB	91	str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
a9499fa7 TG	92	if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
	93	str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
	94	if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
	95	str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
	96	if (efi.uga != EFI_INVALID_TABLE_ADDR)
	97	str += sprintf(str, "UGA=0x%lx\n", efi.uga);
	98
	99	return str - buf;
	100	}
	101
	102	static struct kobj_attribute efi_attr_systab =
	103	__ATTR(systab, 0400, systab_show, NULL);
	104
a0998eb1 DY	105	#define EFI_FIELD(var) efi.var
	106
	107	#define EFI_ATTR_SHOW(name) \
	108	static ssize_t name##_show(struct kobject *kobj, \
	109	struct kobj_attribute attr, char buf) \
	110	{ \
	111	return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
	112	}
	113
	114	EFI_ATTR_SHOW(fw_vendor);
	115	EFI_ATTR_SHOW(runtime);
	116	EFI_ATTR_SHOW(config_table);
	117
	118	static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
	119	static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
	120	static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
	121
a9499fa7 TG	122	static struct attribute *efi_subsys_attrs[] = {
a9499fa7 TG	123	&efi_attr_systab.attr,
a0998eb1 DY	124	&efi_attr_fw_vendor.attr,
	125	&efi_attr_runtime.attr,
	126	&efi_attr_config_table.attr,
	127	NULL,
a9499fa7 TG	128	};
a9499fa7 TG	129
a0998eb1 DY	130	static umode_t efi_attr_is_visible(struct kobject *kobj,
	131	struct attribute *attr, int n)
	132	{
9f27bc54 DK	133	if (attr == &efi_attr_fw_vendor.attr) {
	134	if (efi_enabled(EFI_PARAVIRT) \|\|
	135	efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
	136	return 0;
	137	} else if (attr == &efi_attr_runtime.attr) {
	138	if (efi.runtime == EFI_INVALID_TABLE_ADDR)
	139	return 0;
	140	} else if (attr == &efi_attr_config_table.attr) {
	141	if (efi.config_table == EFI_INVALID_TABLE_ADDR)
	142	return 0;
	143	}
a0998eb1	144
9f27bc54	145	return attr->mode;
a0998eb1 DY	146	}
a0998eb1 DY	147
a9499fa7 TG	148	static struct attribute_group efi_subsys_attr_group = {
a9499fa7 TG	149	.attrs = efi_subsys_attrs,
a0998eb1	150	.is_visible = efi_attr_is_visible,
a9499fa7 TG	151	};
	152
	153	static struct efivars generic_efivars;
63d9c273	154	static efivar_operations_no_const generic_ops __read_only;
a9499fa7 TG	155
	156	static int generic_ops_register(void)
	157	{
63d9c273 MT	158	pax_open_kernel();
	159	(void *)&generic_ops.get_variable = efi.get_variable;
	160	(void *)&generic_ops.set_variable = efi.set_variable;
	161	(void *)&generic_ops.get_next_variable = efi.get_next_variable;
	162	(void *)&generic_ops.query_variable_store = efi_query_variable_store;
	163	pax_close_kernel();
a9499fa7 TG	164
	165	return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
	166	}
	167
	168	static void generic_ops_unregister(void)
	169	{
	170	efivars_unregister(&generic_efivars);
	171	}
	172
	173	/*
	174	* We register the efi subsystem with the firmware subsystem and the
	175	* efivars subsystem with the efi subsystem, if the system was booted with
	176	* EFI.
	177	*/
	178	static int __init efisubsys_init(void)
	179	{
	180	int error;
	181
	182	if (!efi_enabled(EFI_BOOT))
	183	return 0;
	184
	185	/* We register the efi directory at /sys/firmware/efi */
	186	efi_kobj = kobject_create_and_add("efi", firmware_kobj);
	187	if (!efi_kobj) {
	188	pr_err("efi: Firmware registration failed.\n");
	189	return -ENOMEM;
	190	}
	191
	192	error = generic_ops_register();
	193	if (error)
	194	goto err_put;
	195
	196	error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
	197	if (error) {
	198	pr_err("efi: Sysfs attribute export failed with error %d.\n",
	199	error);
	200	goto err_unregister;
	201	}
	202
926172d4 DY	203	error = efi_runtime_map_init(efi_kobj);
	204	if (error)
	205	goto err_remove_group;
	206
a9499fa7 TG	207	/* and the standard mountpoint for efivarfs */
	208	efivars_kobj = kobject_create_and_add("efivars", efi_kobj);
	209	if (!efivars_kobj) {
	210	pr_err("efivars: Subsystem registration failed.\n");
	211	error = -ENOMEM;
	212	goto err_remove_group;
	213	}
	214
	215	return 0;
	216
	217	err_remove_group:
	218	sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
	219	err_unregister:
	220	generic_ops_unregister();
	221	err_put:
	222	kobject_put(efi_kobj);
	223	return error;
	224	}
	225
	226	subsys_initcall(efisubsys_init);
272686bf LL	227
272686bf LL	228
258f6fd7 LL	229	/*
	230	* We can't ioremap data in EFI boot services RAM, because we've already mapped
	231	* it as RAM. So, look it up in the existing EFI memory map instead. Only
	232	* callable after efi_enter_virtual_mode and before efi_free_boot_services.
	233	*/
	234	void __iomem *efi_lookup_mapped_addr(u64 phys_addr)
	235	{
	236	struct efi_memory_map *map;
	237	void *p;
	238	map = efi.memmap;
	239	if (!map)
	240	return NULL;
	241	if (WARN_ON(!map->map))
	242	return NULL;
	243	for (p = map->map; p < map->map_end; p += map->desc_size) {
	244	efi_memory_desc_t *md = p;
	245	u64 size = md->num_pages << EFI_PAGE_SHIFT;
	246	u64 end = md->phys_addr + size;
	247	if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
	248	md->type != EFI_BOOT_SERVICES_CODE &&
	249	md->type != EFI_BOOT_SERVICES_DATA)
	250	continue;
	251	if (!md->virt_addr)
	252	continue;
	253	if (phys_addr >= md->phys_addr && phys_addr < end) {
	254	phys_addr += md->virt_addr - md->phys_addr;
	255	return (__force void __iomem *)(unsigned long)phys_addr;
	256	}
	257	}
	258	return NULL;
	259	}
	260
272686bf LL	261	static __initdata efi_config_table_type_t common_tables[] = {
	262	{ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
	263	{ACPI_TABLE_GUID, "ACPI", &efi.acpi},
	264	{HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
	265	{MPS_TABLE_GUID, "MPS", &efi.mps},
	266	{SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
	267	{SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
e1ccbbc9	268	{SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
272686bf	269	{UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
69e60841	270	{NULL_GUID, NULL, NULL},
272686bf LL	271	};
	272
	273	static __init int match_config_table(efi_guid_t *guid,
	274	unsigned long table,
	275	efi_config_table_type_t *table_types)
	276	{
	277	u8 str[EFI_VARIABLE_GUID_LEN + 1];
	278	int i;
	279
	280	if (table_types) {
	281	efi_guid_unparse(guid, str);
	282
	283	for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
	284	efi_guid_unparse(&table_types[i].guid, str);
	285
	286	if (!efi_guidcmp(*guid, table_types[i].guid)) {
	287	*(table_types[i].ptr) = table;
	288	pr_cont(" %s=0x%lx ",
	289	table_types[i].name, table);
	290	return 1;
	291	}
	292	}
	293	}
	294
	295	return 0;
	296	}
	297
	298	int __init efi_config_init(efi_config_table_type_t *arch_tables)
	299	{
	300	void config_tables, tablep;
	301	int i, sz;
	302
	303	if (efi_enabled(EFI_64BIT))
	304	sz = sizeof(efi_config_table_64_t);
	305	else
	306	sz = sizeof(efi_config_table_32_t);
	307
	308	/*
	309	* Let's see what config tables the firmware passed to us.
	310	*/
	311	config_tables = early_memremap(efi.systab->tables,
	312	efi.systab->nr_tables * sz);
	313	if (config_tables == NULL) {
	314	pr_err("Could not map Configuration table!\n");
	315	return -ENOMEM;
	316	}
	317
	318	tablep = config_tables;
	319	pr_info("");
	320	for (i = 0; i < efi.systab->nr_tables; i++) {
	321	efi_guid_t guid;
	322	unsigned long table;
	323
	324	if (efi_enabled(EFI_64BIT)) {
	325	u64 table64;
	326	guid = ((efi_config_table_64_t *)tablep)->guid;
	327	table64 = ((efi_config_table_64_t *)tablep)->table;
	328	table = table64;
	329	#ifndef CONFIG_64BIT
	330	if (table64 >> 32) {
	331	pr_cont("\n");
	332	pr_err("Table located above 4GB, disabling EFI.\n");
abc93f8e	333	early_memunmap(config_tables,
272686bf LL	334	efi.systab->nr_tables * sz);
	335	return -EINVAL;
	336	}
	337	#endif
	338	} else {
	339	guid = ((efi_config_table_32_t *)tablep)->guid;
	340	table = ((efi_config_table_32_t *)tablep)->table;
	341	}
	342
	343	if (!match_config_table(&guid, table, common_tables))
	344	match_config_table(&guid, table, arch_tables);
	345
	346	tablep += sz;
	347	}
	348	pr_cont("\n");
abc93f8e	349	early_memunmap(config_tables, efi.systab->nr_tables * sz);
0f8093a9 MF	350
	351	set_bit(EFI_CONFIG_TABLES, &efi.flags);
	352
272686bf LL	353	return 0;
272686bf LL	354	}
0302f71c	355
28d54022 LCY	356	#ifdef CONFIG_EFI_VARS_MODULE
	357	static int __init efi_load_efivars(void)
	358	{
	359	struct platform_device *pdev;
	360
	361	if (!efi_enabled(EFI_RUNTIME_SERVICES))
	362	return 0;
	363
	364	pdev = platform_device_register_simple("efivars", 0, NULL, 0);
	365	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
	366	}
	367	device_initcall(efi_load_efivars);
	368	#endif
	369
0302f71c MS	370	#ifdef CONFIG_EFI_PARAMS_FROM_FDT
	371
	372	#define UEFI_PARAM(name, prop, field) \
	373	{ \
	374	{ name }, \
	375	{ prop }, \
	376	offsetof(struct efi_fdt_params, field), \
	377	FIELD_SIZEOF(struct efi_fdt_params, field) \
	378	}
	379
	380	static __initdata struct {
	381	const char name[32];
	382	const char propname[32];
	383	int offset;
	384	int size;
	385	} dt_params[] = {
	386	UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
	387	UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
	388	UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
	389	UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
	390	UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
	391	};
	392
	393	struct param_info {
	394	int verbose;
29e2435f	395	int found;
0302f71c MS	396	void *params;
	397	};
	398
	399	static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
	400	int depth, void *data)
	401	{
	402	struct param_info *info = data;
6fb8cc82 CM	403	const void *prop;
6fb8cc82 CM	404	void *dest;
0302f71c	405	u64 val;
6fb8cc82	406	int i, len;
0302f71c MS	407
	408	if (depth != 1 \|\|
	409	(strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
	410	return 0;
	411
0302f71c MS	412	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
0302f71c MS	413	prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
29e2435f	414	if (!prop)
0302f71c	415	return 0;
0302f71c	416	dest = info->params + dt_params[i].offset;
29e2435f	417	info->found++;
0302f71c MS	418
	419	val = of_read_number(prop, len / sizeof(u32));
	420
	421	if (dt_params[i].size == sizeof(u32))
	422	(u32 )dest = val;
	423	else
	424	(u64 )dest = val;
	425
	426	if (info->verbose)
	427	pr_info(" %s: 0x%0*llx\n", dt_params[i].name,
	428	dt_params[i].size * 2, val);
	429	}
	430	return 1;
	431	}
	432
	433	int __init efi_get_fdt_params(struct efi_fdt_params *params, int verbose)
	434	{
	435	struct param_info info;
29e2435f CM	436	int ret;
	437
	438	pr_info("Getting EFI parameters from FDT:\n");
0302f71c MS	439
0302f71c MS	440	info.verbose = verbose;
29e2435f	441	info.found = 0;
0302f71c MS	442	info.params = params;
0302f71c MS	443
29e2435f CM	444	ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
	445	if (!info.found)
	446	pr_info("UEFI not found.\n");
	447	else if (!ret)
	448	pr_err("Can't find '%s' in device tree!\n",
	449	dt_params[info.found].name);
	450
	451	return ret;
0302f71c MS	452	}
0302f71c MS	453	#endif /* CONFIG_EFI_PARAMS_FROM_FDT */
98d2a6ca LE	454
	455	static __initdata char memory_type_name[][20] = {
	456	"Reserved",
	457	"Loader Code",
	458	"Loader Data",
	459	"Boot Code",
	460	"Boot Data",
	461	"Runtime Code",
	462	"Runtime Data",
	463	"Conventional Memory",
	464	"Unusable Memory",
	465	"ACPI Reclaim Memory",
	466	"ACPI Memory NVS",
	467	"Memory Mapped I/O",
	468	"MMIO Port Space",
	469	"PAL Code"
	470	};
	471
	472	char * __init efi_md_typeattr_format(char *buf, size_t size,
	473	const efi_memory_desc_t *md)
	474	{
	475	char *pos;
	476	int type_len;
	477	u64 attr;
	478
	479	pos = buf;
	480	if (md->type >= ARRAY_SIZE(memory_type_name))
	481	type_len = snprintf(pos, size, "[type=%u", md->type);
	482	else
	483	type_len = snprintf(pos, size, "[%-*s",
	484	(int)(sizeof(memory_type_name[0]) - 1),
	485	memory_type_name[md->type]);
	486	if (type_len >= size)
	487	return buf;
	488
	489	pos += type_len;
	490	size -= type_len;
	491
	492	attr = md->attribute;
	493	if (attr & ~(EFI_MEMORY_UC \| EFI_MEMORY_WC \| EFI_MEMORY_WT \|
	494	EFI_MEMORY_WB \| EFI_MEMORY_UCE \| EFI_MEMORY_WP \|
	495	EFI_MEMORY_RP \| EFI_MEMORY_XP \| EFI_MEMORY_RUNTIME))
	496	snprintf(pos, size, "\|attr=0x%016llx]",
	497	(unsigned long long)attr);
	498	else
	499	snprintf(pos, size, "\|%3s\|%2s\|%2s\|%2s\|%3s\|%2s\|%2s\|%2s\|%2s]",
	500	attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
	501	attr & EFI_MEMORY_XP ? "XP" : "",
	502	attr & EFI_MEMORY_RP ? "RP" : "",
	503	attr & EFI_MEMORY_WP ? "WP" : "",
	504	attr & EFI_MEMORY_UCE ? "UCE" : "",
	505	attr & EFI_MEMORY_WB ? "WB" : "",
	506	attr & EFI_MEMORY_WT ? "WT" : "",
	507	attr & EFI_MEMORY_WC ? "WC" : "",
	508	attr & EFI_MEMORY_UC ? "UC" : "");
	509	return buf;
	510	}