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