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

#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,
	.mem_attr_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},
	{EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_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;
				if (table_types[i].name)
					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)
{
	efi_memory_desc_t *md;

	if (!efi_enabled(EFI_MEMMAP))
		return 0;

	for_each_efi_memory_desc(md) {
		if ((md->phys_addr <= phys_addr) &&
		    (phys_addr < (md->phys_addr +
		    (md->num_pages << EFI_PAGE_SHIFT))))
			return md->attribute;
	}
	return 0;
}

int efi_status_to_err(efi_status_t status)
{
	int err;

	switch (status) {
	case EFI_SUCCESS:
		err = 0;
		break;
	case EFI_INVALID_PARAMETER:
		err = -EINVAL;
		break;
	case EFI_OUT_OF_RESOURCES:
		err = -ENOSPC;
		break;
	case EFI_DEVICE_ERROR:
		err = -EIO;
		break;
	case EFI_WRITE_PROTECTED:
		err = -EROFS;
		break;
	case EFI_SECURITY_VIOLATION:
		err = -EACCES;
		break;
	case EFI_NOT_FOUND:
		err = -ENOENT;
		break;
	default:
		err = -EINVAL;
	}

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