[mirror_ubuntu-zesty-kernel.git] / arch / x86 / platform / efi / efi-bgrt.c

/*
 * Copyright 2012 Intel Corporation
 * Author: Josh Triplett <josh@joshtriplett.org>
 *
 * Based on the bgrt driver:
 * Copyright 2012 Red Hat, Inc <mjg@redhat.com>
 * Author: Matthew Garrett
 *
 * 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.
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/acpi.h>
#include <linux/efi.h>
#include <linux/efi-bgrt.h>

struct acpi_table_bgrt *bgrt_tab;
void *__initdata bgrt_image;
size_t __initdata bgrt_image_size;

struct bmp_header {
	u16 id;
	u32 size;
} __packed;

void __init efi_bgrt_init(void)
{
	acpi_status status;
	void __iomem *image;
	bool ioremapped = false;
	struct bmp_header bmp_header;

	if (acpi_disabled)
		return;

	status = acpi_get_table("BGRT", 0,
	                        (struct acpi_table_header **)&bgrt_tab);
	if (ACPI_FAILURE(status))
		return;

	if (bgrt_tab->header.length < sizeof(*bgrt_tab)) {
		pr_err("Ignoring BGRT: invalid length %u (expected %zu)\n",
		       bgrt_tab->header.length, sizeof(*bgrt_tab));
		return;
	}
	if (bgrt_tab->version != 1) {
		pr_err("Ignoring BGRT: invalid version %u (expected 1)\n",
		       bgrt_tab->version);
		return;
	}
	if (bgrt_tab->status != 1) {
		pr_err("Ignoring BGRT: invalid status %u (expected 1)\n",
		       bgrt_tab->status);
		return;
	}
	if (bgrt_tab->image_type != 0) {
		pr_err("Ignoring BGRT: invalid image type %u (expected 0)\n",
		       bgrt_tab->image_type);
		return;
	}
	if (!bgrt_tab->image_address) {
		pr_err("Ignoring BGRT: null image address\n");
		return;
	}

	image = efi_lookup_mapped_addr(bgrt_tab->image_address);
	if (!image) {
		image = early_ioremap(bgrt_tab->image_address,
				       sizeof(bmp_header));
		ioremapped = true;
		if (!image) {
			pr_err("Ignoring BGRT: failed to map image header memory\n");
			return;
		}
	}

	memcpy_fromio(&bmp_header, image, sizeof(bmp_header));
	if (ioremapped)
		early_iounmap(image, sizeof(bmp_header));
	bgrt_image_size = bmp_header.size;

	bgrt_image = kmalloc(bgrt_image_size, GFP_KERNEL | __GFP_NOWARN);
	if (!bgrt_image) {
		pr_err("Ignoring BGRT: failed to allocate memory for image (wanted %zu bytes)\n",
		       bgrt_image_size);
		return;
	}

	if (ioremapped) {
		image = early_ioremap(bgrt_tab->image_address,
				       bmp_header.size);
		if (!image) {
			pr_err("Ignoring BGRT: failed to map image memory\n");
			kfree(bgrt_image);
			bgrt_image = NULL;
			return;
		}
	}

	memcpy_fromio(bgrt_image, image, bgrt_image_size);
	if (ioremapped)
		early_iounmap(image, bmp_header.size);
}
Commit	Line	Data
2223af38 JT	1	/*
	2	* Copyright 2012 Intel Corporation
	3	* Author: Josh Triplett <josh@joshtriplett.org>
	4	*
	5	* Based on the bgrt driver:
	6	* Copyright 2012 Red Hat, Inc <mjg@redhat.com>
	7	* Author: Matthew Garrett
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
	13	#include <linux/kernel.h>
13f0e4d2	14	#include <linux/init.h>
2223af38 JT	15	#include <linux/acpi.h>
	16	#include <linux/efi.h>
	17	#include <linux/efi-bgrt.h>
	18
	19	struct acpi_table_bgrt *bgrt_tab;
13f0e4d2 JB	20	void *__initdata bgrt_image;
13f0e4d2 JB	21	size_t __initdata bgrt_image_size;
2223af38 JT	22
	23	struct bmp_header {
	24	u16 id;
	25	u32 size;
	26	} __packed;
	27
13f0e4d2	28	void __init efi_bgrt_init(void)
2223af38 JT	29	{
	30	acpi_status status;
	31	void __iomem *image;
	32	bool ioremapped = false;
	33	struct bmp_header bmp_header;
	34
	35	if (acpi_disabled)
	36	return;
	37
	38	status = acpi_get_table("BGRT", 0,
	39	(struct acpi_table_header **)&bgrt_tab);
	40	if (ACPI_FAILURE(status))
	41	return;
	42
1282278e JT	43	if (bgrt_tab->header.length < sizeof(*bgrt_tab)) {
	44	pr_err("Ignoring BGRT: invalid length %u (expected %zu)\n",
	45	bgrt_tab->header.length, sizeof(*bgrt_tab));
5d6d578c	46	return;
1282278e JT	47	}
	48	if (bgrt_tab->version != 1) {
	49	pr_err("Ignoring BGRT: invalid version %u (expected 1)\n",
	50	bgrt_tab->version);
	51	return;
	52	}
	53	if (bgrt_tab->status != 1) {
	54	pr_err("Ignoring BGRT: invalid status %u (expected 1)\n",
	55	bgrt_tab->status);
	56	return;
	57	}
	58	if (bgrt_tab->image_type != 0) {
	59	pr_err("Ignoring BGRT: invalid image type %u (expected 0)\n",
	60	bgrt_tab->image_type);
2223af38	61	return;
1282278e JT	62	}
	63	if (!bgrt_tab->image_address) {
	64	pr_err("Ignoring BGRT: null image address\n");
2223af38	65	return;
1282278e	66	}
2223af38 JT	67
	68	image = efi_lookup_mapped_addr(bgrt_tab->image_address);
	69	if (!image) {
954e12f7	70	image = early_ioremap(bgrt_tab->image_address,
081cd62a	71	sizeof(bmp_header));
2223af38	72	ioremapped = true;
1282278e JT	73	if (!image) {
1282278e JT	74	pr_err("Ignoring BGRT: failed to map image header memory\n");
2223af38	75	return;
1282278e	76	}
2223af38 JT	77	}
	78
	79	memcpy_fromio(&bmp_header, image, sizeof(bmp_header));
	80	if (ioremapped)
081cd62a	81	early_iounmap(image, sizeof(bmp_header));
2223af38 JT	82	bgrt_image_size = bmp_header.size;
2223af38 JT	83
1282278e JT	84	bgrt_image = kmalloc(bgrt_image_size, GFP_KERNEL \| __GFP_NOWARN);
	85	if (!bgrt_image) {
	86	pr_err("Ignoring BGRT: failed to allocate memory for image (wanted %zu bytes)\n",
	87	bgrt_image_size);
2223af38	88	return;
1282278e	89	}
2223af38 JT	90
2223af38 JT	91	if (ioremapped) {
954e12f7	92	image = early_ioremap(bgrt_tab->image_address,
081cd62a	93	bmp_header.size);
2223af38	94	if (!image) {
1282278e	95	pr_err("Ignoring BGRT: failed to map image memory\n");
2223af38 JT	96	kfree(bgrt_image);
	97	bgrt_image = NULL;
	98	return;
	99	}
	100	}
	101
	102	memcpy_fromio(bgrt_image, image, bgrt_image_size);
	103	if (ioremapped)
081cd62a	104	early_iounmap(image, bmp_header.size);
2223af38	105	}