[linux-2.6-block.git] / drivers / firmware / efi / arm-init.c

/*
 * Extensible Firmware Interface
 *
 * Based on Extensible Firmware Interface Specification version 2.4
 *
 * Copyright (C) 2013 - 2015 Linaro Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#define pr_fmt(fmt)	"efi: " fmt

#include <linux/efi.h>
#include <linux/init.h>
#include <linux/memblock.h>
#include <linux/mm_types.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/platform_device.h>
#include <linux/screen_info.h>

#include <asm/efi.h>

u64 efi_system_table;

static int __init is_normal_ram(efi_memory_desc_t *md)
{
	if (md->attribute & EFI_MEMORY_WB)
		return 1;
	return 0;
}

/*
 * Translate a EFI virtual address into a physical address: this is necessary,
 * as some data members of the EFI system table are virtually remapped after
 * SetVirtualAddressMap() has been called.
 */
static phys_addr_t efi_to_phys(unsigned long addr)
{
	efi_memory_desc_t *md;

	for_each_efi_memory_desc(md) {
		if (!(md->attribute & EFI_MEMORY_RUNTIME))
			continue;
		if (md->virt_addr == 0)
			/* no virtual mapping has been installed by the stub */
			break;
		if (md->virt_addr <= addr &&
		    (addr - md->virt_addr) < (md->num_pages << EFI_PAGE_SHIFT))
			return md->phys_addr + addr - md->virt_addr;
	}
	return addr;
}

static __initdata unsigned long screen_info_table = EFI_INVALID_TABLE_ADDR;

static __initdata efi_config_table_type_t arch_tables[] = {
	{LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID, NULL, &screen_info_table},
	{NULL_GUID, NULL, NULL}
};

static void __init init_screen_info(void)
{
	struct screen_info *si;

	if (screen_info_table != EFI_INVALID_TABLE_ADDR) {
		si = early_memremap_ro(screen_info_table, sizeof(*si));
		if (!si) {
			pr_err("Could not map screen_info config table\n");
			return;
		}
		screen_info = *si;
		early_memunmap(si, sizeof(*si));

		/* dummycon on ARM needs non-zero values for columns/lines */
		screen_info.orig_video_cols = 80;
		screen_info.orig_video_lines = 25;
	}

	if (screen_info.orig_video_isVGA == VIDEO_TYPE_EFI &&
	    memblock_is_map_memory(screen_info.lfb_base))
		memblock_mark_nomap(screen_info.lfb_base, screen_info.lfb_size);
}

static int __init uefi_init(void)
{
	efi_char16_t *c16;
	void *config_tables;
	size_t table_size;
	char vendor[100] = "unknown";
	int i, retval;

	efi.systab = early_memremap_ro(efi_system_table,
				       sizeof(efi_system_table_t));
	if (efi.systab == NULL) {
		pr_warn("Unable to map EFI system table.\n");
		return -ENOMEM;
	}

	set_bit(EFI_BOOT, &efi.flags);
	if (IS_ENABLED(CONFIG_64BIT))
		set_bit(EFI_64BIT, &efi.flags);

	/*
	 * Verify the EFI Table
	 */
	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
		pr_err("System table signature incorrect\n");
		retval = -EINVAL;
		goto out;
	}
	if ((efi.systab->hdr.revision >> 16) < 2)
		pr_warn("Warning: EFI system table version %d.%02d, expected 2.00 or greater\n",
			efi.systab->hdr.revision >> 16,
			efi.systab->hdr.revision & 0xffff);

	efi.runtime_version = efi.systab->hdr.revision;

	/* Show what we know for posterity */
	c16 = early_memremap_ro(efi_to_phys(efi.systab->fw_vendor),
				sizeof(vendor) * sizeof(efi_char16_t));
	if (c16) {
		for (i = 0; i < (int) sizeof(vendor) - 1 && *c16; ++i)
			vendor[i] = c16[i];
		vendor[i] = '\0';
		early_memunmap(c16, sizeof(vendor) * sizeof(efi_char16_t));
	}

	pr_info("EFI v%u.%.02u by %s\n",
		efi.systab->hdr.revision >> 16,
		efi.systab->hdr.revision & 0xffff, vendor);

	table_size = sizeof(efi_config_table_64_t) * efi.systab->nr_tables;
	config_tables = early_memremap_ro(efi_to_phys(efi.systab->tables),
					  table_size);
	if (config_tables == NULL) {
		pr_warn("Unable to map EFI config table array.\n");
		retval = -ENOMEM;
		goto out;
	}
	retval = efi_config_parse_tables(config_tables, efi.systab->nr_tables,
					 sizeof(efi_config_table_t),
					 arch_tables);

	early_memunmap(config_tables, table_size);
out:
	early_memunmap(efi.systab,  sizeof(efi_system_table_t));
	return retval;
}

/*
 * Return true for RAM regions we want to permanently reserve.
 */
static __init int is_reserve_region(efi_memory_desc_t *md)
{
	switch (md->type) {
	case EFI_LOADER_CODE:
	case EFI_LOADER_DATA:
	case EFI_BOOT_SERVICES_CODE:
	case EFI_BOOT_SERVICES_DATA:
	case EFI_CONVENTIONAL_MEMORY:
	case EFI_PERSISTENT_MEMORY:
		return 0;
	default:
		break;
	}
	return is_normal_ram(md);
}

static __init void reserve_regions(void)
{
	efi_memory_desc_t *md;
	u64 paddr, npages, size;
	int resv;

	if (efi_enabled(EFI_DBG))
		pr_info("Processing EFI memory map:\n");

	/*
	 * Discard memblocks discovered so far: if there are any at this
	 * point, they originate from memory nodes in the DT, and UEFI
	 * uses its own memory map instead.
	 */
	memblock_dump_all();
	memblock_remove(0, (phys_addr_t)ULLONG_MAX);

	for_each_efi_memory_desc(md) {
		paddr = md->phys_addr;
		npages = md->num_pages;

		resv = is_reserve_region(md);
		if (efi_enabled(EFI_DBG)) {
			char buf[64];

			pr_info("  0x%012llx-0x%012llx %s%s\n",
				paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1,
				efi_md_typeattr_format(buf, sizeof(buf), md),
				resv ? "*" : "");
		}

		memrange_efi_to_native(&paddr, &npages);
		size = npages << PAGE_SHIFT;

		if (is_normal_ram(md))
			early_init_dt_add_memory_arch(paddr, size);

		if (resv)
			memblock_mark_nomap(paddr, size);

	}

	set_bit(EFI_MEMMAP, &efi.flags);
}

void __init efi_init(void)
{
	struct efi_fdt_params params;

	/* Grab UEFI information placed in FDT by stub */
	if (!efi_get_fdt_params(&params))
		return;

	efi_system_table = params.system_table;

	efi.memmap.phys_map = params.mmap;
	efi.memmap.map = early_memremap_ro(params.mmap, params.mmap_size);
	if (efi.memmap.map == NULL) {
		/*
		* If we are booting via UEFI, the UEFI memory map is the only
		* description of memory we have, so there is little point in
		* proceeding if we cannot access it.
		*/
		panic("Unable to map EFI memory map.\n");
	}
	efi.memmap.map_end = efi.memmap.map + params.mmap_size;
	efi.memmap.desc_size = params.desc_size;
	efi.memmap.desc_version = params.desc_ver;

	WARN(efi.memmap.desc_version != 1,
	     "Unexpected EFI_MEMORY_DESCRIPTOR version %ld",
	      efi.memmap.desc_version);

	if (uefi_init() < 0)
		return;

	reserve_regions();
	efi_memattr_init();
	early_memunmap(efi.memmap.map, params.mmap_size);

	memblock_reserve(params.mmap & PAGE_MASK,
			 PAGE_ALIGN(params.mmap_size +
				    (params.mmap & ~PAGE_MASK)));

	init_screen_info();
}

static int __init register_gop_device(void)
{
	void *pd;

	if (screen_info.orig_video_isVGA != VIDEO_TYPE_EFI)
		return 0;

	pd = platform_device_register_data(NULL, "efi-framebuffer", 0,
					   &screen_info, sizeof(screen_info));
	return PTR_ERR_OR_ZERO(pd);
}
subsys_initcall(register_gop_device);
Commit	Line	Data
e5bc22a4 AB	1	/*
	2	* Extensible Firmware Interface
	3	*
	4	* Based on Extensible Firmware Interface Specification version 2.4
	5	*
	6	* Copyright (C) 2013 - 2015 Linaro Ltd.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	*/
	13
801820be AB	14	#define pr_fmt(fmt) "efi: " fmt
801820be AB	15
e5bc22a4 AB	16	#include <linux/efi.h>
	17	#include <linux/init.h>
	18	#include <linux/memblock.h>
	19	#include <linux/mm_types.h>
	20	#include <linux/of.h>
	21	#include <linux/of_fdt.h>
e3271c96	22	#include <linux/platform_device.h>
801820be	23	#include <linux/screen_info.h>
e5bc22a4 AB	24
	25	#include <asm/efi.h>
	26
e5bc22a4 AB	27	u64 efi_system_table;
	28
	29	static int __init is_normal_ram(efi_memory_desc_t *md)
	30	{
	31	if (md->attribute & EFI_MEMORY_WB)
	32	return 1;
	33	return 0;
	34	}
	35
	36	/*
	37	* Translate a EFI virtual address into a physical address: this is necessary,
	38	* as some data members of the EFI system table are virtually remapped after
	39	* SetVirtualAddressMap() has been called.
	40	*/
	41	static phys_addr_t efi_to_phys(unsigned long addr)
	42	{
	43	efi_memory_desc_t *md;
	44
884f4f66	45	for_each_efi_memory_desc(md) {
e5bc22a4 AB	46	if (!(md->attribute & EFI_MEMORY_RUNTIME))
	47	continue;
	48	if (md->virt_addr == 0)
	49	/* no virtual mapping has been installed by the stub */
	50	break;
	51	if (md->virt_addr <= addr &&
	52	(addr - md->virt_addr) < (md->num_pages << EFI_PAGE_SHIFT))
	53	return md->phys_addr + addr - md->virt_addr;
	54	}
	55	return addr;
	56	}
	57
801820be AB	58	static __initdata unsigned long screen_info_table = EFI_INVALID_TABLE_ADDR;
	59
	60	static __initdata efi_config_table_type_t arch_tables[] = {
	61	{LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID, NULL, &screen_info_table},
	62	{NULL_GUID, NULL, NULL}
	63	};
	64
	65	static void __init init_screen_info(void)
	66	{
	67	struct screen_info *si;
	68
	69	if (screen_info_table != EFI_INVALID_TABLE_ADDR) {
	70	si = early_memremap_ro(screen_info_table, sizeof(*si));
	71	if (!si) {
	72	pr_err("Could not map screen_info config table\n");
	73	return;
	74	}
	75	screen_info = *si;
	76	early_memunmap(si, sizeof(*si));
	77
	78	/* dummycon on ARM needs non-zero values for columns/lines */
	79	screen_info.orig_video_cols = 80;
	80	screen_info.orig_video_lines = 25;
	81	}
e3271c96 AB	82
	83	if (screen_info.orig_video_isVGA == VIDEO_TYPE_EFI &&
	84	memblock_is_map_memory(screen_info.lfb_base))
	85	memblock_mark_nomap(screen_info.lfb_base, screen_info.lfb_size);
801820be AB	86	}
801820be AB	87
e5bc22a4 AB	88	static int __init uefi_init(void)
	89	{
	90	efi_char16_t *c16;
	91	void *config_tables;
f7d92489	92	size_t table_size;
e5bc22a4 AB	93	char vendor[100] = "unknown";
	94	int i, retval;
	95
2eec5ded AB	96	efi.systab = early_memremap_ro(efi_system_table,
2eec5ded AB	97	sizeof(efi_system_table_t));
e5bc22a4 AB	98	if (efi.systab == NULL) {
	99	pr_warn("Unable to map EFI system table.\n");
	100	return -ENOMEM;
	101	}
	102
	103	set_bit(EFI_BOOT, &efi.flags);
f7d92489 AB	104	if (IS_ENABLED(CONFIG_64BIT))
f7d92489 AB	105	set_bit(EFI_64BIT, &efi.flags);
e5bc22a4 AB	106
	107	/*
	108	* Verify the EFI Table
	109	*/
	110	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
	111	pr_err("System table signature incorrect\n");
	112	retval = -EINVAL;
	113	goto out;
	114	}
	115	if ((efi.systab->hdr.revision >> 16) < 2)
	116	pr_warn("Warning: EFI system table version %d.%02d, expected 2.00 or greater\n",
	117	efi.systab->hdr.revision >> 16,
	118	efi.systab->hdr.revision & 0xffff);
	119
14c43be6 AB	120	efi.runtime_version = efi.systab->hdr.revision;
14c43be6 AB	121
e5bc22a4	122	/* Show what we know for posterity */
2eec5ded AB	123	c16 = early_memremap_ro(efi_to_phys(efi.systab->fw_vendor),
2eec5ded AB	124	sizeof(vendor) * sizeof(efi_char16_t));
e5bc22a4 AB	125	if (c16) {
	126	for (i = 0; i < (int) sizeof(vendor) - 1 && *c16; ++i)
	127	vendor[i] = c16[i];
	128	vendor[i] = '\0';
	129	early_memunmap(c16, sizeof(vendor) * sizeof(efi_char16_t));
	130	}
	131
	132	pr_info("EFI v%u.%.02u by %s\n",
	133	efi.systab->hdr.revision >> 16,
	134	efi.systab->hdr.revision & 0xffff, vendor);
	135
	136	table_size = sizeof(efi_config_table_64_t) * efi.systab->nr_tables;
2eec5ded AB	137	config_tables = early_memremap_ro(efi_to_phys(efi.systab->tables),
2eec5ded AB	138	table_size);
e5bc22a4 AB	139	if (config_tables == NULL) {
	140	pr_warn("Unable to map EFI config table array.\n");
	141	retval = -ENOMEM;
	142	goto out;
	143	}
	144	retval = efi_config_parse_tables(config_tables, efi.systab->nr_tables,
801820be AB	145	sizeof(efi_config_table_t),
801820be AB	146	arch_tables);
e5bc22a4 AB	147
	148	early_memunmap(config_tables, table_size);
	149	out:
	150	early_memunmap(efi.systab, sizeof(efi_system_table_t));
	151	return retval;
	152	}
	153
	154	/*
	155	* Return true for RAM regions we want to permanently reserve.
	156	*/
	157	static __init int is_reserve_region(efi_memory_desc_t *md)
	158	{
	159	switch (md->type) {
	160	case EFI_LOADER_CODE:
	161	case EFI_LOADER_DATA:
	162	case EFI_BOOT_SERVICES_CODE:
	163	case EFI_BOOT_SERVICES_DATA:
	164	case EFI_CONVENTIONAL_MEMORY:
	165	case EFI_PERSISTENT_MEMORY:
	166	return 0;
	167	default:
	168	break;
	169	}
	170	return is_normal_ram(md);
	171	}
	172
	173	static __init void reserve_regions(void)
	174	{
	175	efi_memory_desc_t *md;
	176	u64 paddr, npages, size;
c7534397	177	int resv;
e5bc22a4 AB	178
	179	if (efi_enabled(EFI_DBG))
	180	pr_info("Processing EFI memory map:\n");
	181
500899c2 AB	182	/*
	183	* Discard memblocks discovered so far: if there are any at this
	184	* point, they originate from memory nodes in the DT, and UEFI
	185	* uses its own memory map instead.
	186	*/
	187	memblock_dump_all();
7464b6e3	188	memblock_remove(0, (phys_addr_t)ULLONG_MAX);
500899c2	189
884f4f66	190	for_each_efi_memory_desc(md) {
e5bc22a4 AB	191	paddr = md->phys_addr;
	192	npages = md->num_pages;
	193
c7534397	194	resv = is_reserve_region(md);
e5bc22a4 AB	195	if (efi_enabled(EFI_DBG)) {
	196	char buf[64];
	197
c7534397	198	pr_info(" 0x%012llx-0x%012llx %s%s\n",
e5bc22a4	199	paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1,
c7534397 DC	200	efi_md_typeattr_format(buf, sizeof(buf), md),
c7534397 DC	201	resv ? "*" : "");
e5bc22a4 AB	202	}
	203
	204	memrange_efi_to_native(&paddr, &npages);
	205	size = npages << PAGE_SHIFT;
	206
	207	if (is_normal_ram(md))
	208	early_init_dt_add_memory_arch(paddr, size);
	209
c7534397	210	if (resv)
e5bc22a4	211	memblock_mark_nomap(paddr, size);
e5bc22a4	212
e5bc22a4 AB	213	}
	214
	215	set_bit(EFI_MEMMAP, &efi.flags);
	216	}
	217
	218	void __init efi_init(void)
	219	{
	220	struct efi_fdt_params params;
	221
	222	/* Grab UEFI information placed in FDT by stub */
	223	if (!efi_get_fdt_params(&params))
	224	return;
	225
	226	efi_system_table = params.system_table;
	227
884f4f66 MF	228	efi.memmap.phys_map = params.mmap;
	229	efi.memmap.map = early_memremap_ro(params.mmap, params.mmap_size);
	230	if (efi.memmap.map == NULL) {
e5bc22a4 AB	231	/*
	232	* If we are booting via UEFI, the UEFI memory map is the only
	233	* description of memory we have, so there is little point in
	234	* proceeding if we cannot access it.
	235	*/
	236	panic("Unable to map EFI memory map.\n");
	237	}
884f4f66 MF	238	efi.memmap.map_end = efi.memmap.map + params.mmap_size;
	239	efi.memmap.desc_size = params.desc_size;
	240	efi.memmap.desc_version = params.desc_ver;
e5bc22a4	241
0d054ad9 AB	242	WARN(efi.memmap.desc_version != 1,
	243	"Unexpected EFI_MEMORY_DESCRIPTOR version %ld",
	244	efi.memmap.desc_version);
	245
e5bc22a4 AB	246	if (uefi_init() < 0)
	247	return;
	248
	249	reserve_regions();
789957ef	250	efi_memattr_init();
884f4f66	251	early_memunmap(efi.memmap.map, params.mmap_size);
7cc8cbcf	252
249f7632 AB	253	memblock_reserve(params.mmap & PAGE_MASK,
	254	PAGE_ALIGN(params.mmap_size +
	255	(params.mmap & ~PAGE_MASK)));
801820be AB	256
801820be AB	257	init_screen_info();
e5bc22a4	258	}
e3271c96 AB	259
	260	static int __init register_gop_device(void)
	261	{
	262	void *pd;
	263
	264	if (screen_info.orig_video_isVGA != VIDEO_TYPE_EFI)
	265	return 0;
	266
	267	pd = platform_device_register_data(NULL, "efi-framebuffer", 0,
	268	&screen_info, sizeof(screen_info));
	269	return PTR_ERR_OR_ZERO(pd);
	270	}
	271	subsys_initcall(register_gop_device);