[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>

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