ACPI, APEI, APEI supporting infrastructure (a643ce20) · Commits · e / devices / android_kernel_teracube_emerald

drivers/acpi/Kconfig

+2 −0

Original line number	Diff line number	Diff line
		@@ -360,4 +360,6 @@ config ACPI_SBS
		To compile this driver as a module, choose M here:
		the modules will be called sbs and sbshc.

		source "drivers/acpi/apei/Kconfig"

		endif # ACPI

drivers/acpi/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -67,3 +67,5 @@ processor-y += processor_idle.o processor_thermal.o
		processor-$(CONFIG_CPU_FREQ) += processor_perflib.o

		obj-$(CONFIG_ACPI_PROCESSOR_AGGREGATOR) += acpi_pad.o

		obj-$(CONFIG_ACPI_APEI) += apei/

drivers/acpi/apei/Kconfig

0 → 100644

+8 −0

Original line number	Diff line number	Diff line
		config ACPI_APEI
		bool "ACPI Platform Error Interface (APEI)"
		depends on X86
		help
		APEI allows to report errors (for example from the chipset)
		to the operating system. This improves NMI handling
		especially. In addition it supports error serialization and
		error injection.

drivers/acpi/apei/Makefile

0 → 100644

+3 −0

Original line number	Diff line number	Diff line
		obj-$(CONFIG_ACPI_APEI) += apei.o

		apei-y := apei-base.o

drivers/acpi/apei/apei-base.c

0 → 100644

+593 −0

Original line number	Diff line number	Diff line
		/*
		* apei-base.c - ACPI Platform Error Interface (APEI) supporting
		* infrastructure
		*
		* APEI allows to report errors (for example from the chipset) to the
		* the operating system. This improves NMI handling especially. In
		* addition it supports error serialization and error injection.
		*
		* For more information about APEI, please refer to ACPI Specification
		* version 4.0, chapter 17.
		*
		* This file has Common functions used by more than one APEI table,
		* including framework of interpreter for ERST and EINJ; resource
		* management for APEI registers.
		*
		* Copyright (C) 2009, Intel Corp.
		* Author: Huang Ying <ying.huang@intel.com>
		*
		* 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.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*
		* You should have received a copy of the GNU General Public License
		* along with this program; if not, write to the Free Software
		* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		*/

		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/init.h>
		#include <linux/acpi.h>
		#include <linux/io.h>
		#include <linux/kref.h>
		#include <linux/rculist.h>
		#include <linux/interrupt.h>
		#include <linux/debugfs.h>
		#include <acpi/atomicio.h>

		#include "apei-internal.h"

		#define APEI_PFX "APEI: "

		/*
		* APEI ERST (Error Record Serialization Table) and EINJ (Error
		* INJection) interpreter framework.
		*/

		#define APEI_EXEC_PRESERVE_REGISTER 0x1

		void apei_exec_ctx_init(struct apei_exec_context *ctx,
		struct apei_exec_ins_type *ins_table,
		u32 instructions,
		struct acpi_whea_header *action_table,
		u32 entries)
		{
		ctx->ins_table = ins_table;
		ctx->instructions = instructions;
		ctx->action_table = action_table;
		ctx->entries = entries;
		}
		EXPORT_SYMBOL_GPL(apei_exec_ctx_init);

		int __apei_exec_read_register(struct acpi_whea_header entry, u64 val)
		{
		int rc;

		rc = acpi_atomic_read(val, &entry->register_region);
		if (rc)
		return rc;
		*val >>= entry->register_region.bit_offset;
		*val &= entry->mask;

		return 0;
		}

		int apei_exec_read_register(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry)
		{
		int rc;
		u64 val = 0;

		rc = __apei_exec_read_register(entry, &val);
		if (rc)
		return rc;
		ctx->value = val;

		return 0;
		}
		EXPORT_SYMBOL_GPL(apei_exec_read_register);

		int apei_exec_read_register_value(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry)
		{
		int rc;

		rc = apei_exec_read_register(ctx, entry);
		if (rc)
		return rc;
		ctx->value = (ctx->value == entry->value);

		return 0;
		}
		EXPORT_SYMBOL_GPL(apei_exec_read_register_value);

		int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val)
		{
		int rc;

		val &= entry->mask;
		val <<= entry->register_region.bit_offset;
		if (entry->flags & APEI_EXEC_PRESERVE_REGISTER) {
		u64 valr = 0;
		rc = acpi_atomic_read(&valr, &entry->register_region);
		if (rc)
		return rc;
		valr &= ~(entry->mask << entry->register_region.bit_offset);
		val \|= valr;
		}
		rc = acpi_atomic_write(val, &entry->register_region);

		return rc;
		}

		int apei_exec_write_register(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry)
		{
		return __apei_exec_write_register(entry, ctx->value);
		}
		EXPORT_SYMBOL_GPL(apei_exec_write_register);

		int apei_exec_write_register_value(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry)
		{
		int rc;

		ctx->value = entry->value;
		rc = apei_exec_write_register(ctx, entry);

		return rc;
		}
		EXPORT_SYMBOL_GPL(apei_exec_write_register_value);

		int apei_exec_noop(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry)
		{
		return 0;
		}
		EXPORT_SYMBOL_GPL(apei_exec_noop);

		/*
		* Interpret the specified action. Go through whole action table,
		* execute all instructions belong to the action.
		*/
		int apei_exec_run(struct apei_exec_context *ctx, u8 action)
		{
		int rc;
		u32 i, ip;
		struct acpi_whea_header *entry;
		apei_exec_ins_func_t run;

		ctx->ip = 0;

		/*
		* "ip" is the instruction pointer of current instruction,
		* "ctx->ip" specifies the next instruction to executed,
		* instruction "run" function may change the "ctx->ip" to
		* implement "goto" semantics.
		*/
		rewind:
		ip = 0;
		for (i = 0; i < ctx->entries; i++) {
		entry = &ctx->action_table[i];
		if (entry->action != action)
		continue;
		if (ip == ctx->ip) {
		if (entry->instruction >= ctx->instructions \|\|
		!ctx->ins_table[entry->instruction].run) {
		pr_warning(FW_WARN APEI_PFX
		"Invalid action table, unknown instruction type: %d\n",
		entry->instruction);
		return -EINVAL;
		}
		run = ctx->ins_table[entry->instruction].run;
		rc = run(ctx, entry);
		if (rc < 0)
		return rc;
		else if (rc != APEI_EXEC_SET_IP)
		ctx->ip++;
		}
		ip++;
		if (ctx->ip < ip)
		goto rewind;
		}

		return 0;
		}
		EXPORT_SYMBOL_GPL(apei_exec_run);

		typedef int (apei_exec_entry_func_t)(struct apei_exec_context ctx,
		struct acpi_whea_header *entry,
		void *data);

		static int apei_exec_for_each_entry(struct apei_exec_context *ctx,
		apei_exec_entry_func_t func,
		void *data,
		int *end)
		{
		u8 ins;
		int i, rc;
		struct acpi_whea_header *entry;
		struct apei_exec_ins_type *ins_table = ctx->ins_table;

		for (i = 0; i < ctx->entries; i++) {
		entry = ctx->action_table + i;
		ins = entry->instruction;
		if (end)
		*end = i;
		if (ins >= ctx->instructions \|\| !ins_table[ins].run) {
		pr_warning(FW_WARN APEI_PFX
		"Invalid action table, unknown instruction type: %d\n",
		ins);
		return -EINVAL;
		}
		rc = func(ctx, entry, data);
		if (rc)
		return rc;
		}

		return 0;
		}

		static int pre_map_gar_callback(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry,
		void *data)
		{
		u8 ins = entry->instruction;

		if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
		return acpi_pre_map_gar(&entry->register_region);

		return 0;
		}

		/*
		* Pre-map all GARs in action table to make it possible to access them
		* in NMI handler.
		*/
		int apei_exec_pre_map_gars(struct apei_exec_context *ctx)
		{
		int rc, end;

		rc = apei_exec_for_each_entry(ctx, pre_map_gar_callback,
		NULL, &end);
		if (rc) {
		struct apei_exec_context ctx_unmap;
		memcpy(&ctx_unmap, ctx, sizeof(*ctx));
		ctx_unmap.entries = end;
		apei_exec_post_unmap_gars(&ctx_unmap);
		}

		return rc;
		}
		EXPORT_SYMBOL_GPL(apei_exec_pre_map_gars);

		static int post_unmap_gar_callback(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry,
		void *data)
		{
		u8 ins = entry->instruction;

		if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
		acpi_post_unmap_gar(&entry->register_region);

		return 0;
		}

		/* Post-unmap all GAR in action table. */
		int apei_exec_post_unmap_gars(struct apei_exec_context *ctx)
		{
		return apei_exec_for_each_entry(ctx, post_unmap_gar_callback,
		NULL, NULL);
		}
		EXPORT_SYMBOL_GPL(apei_exec_post_unmap_gars);

		/*
		* Resource management for GARs in APEI
		*/
		struct apei_res {
		struct list_head list;
		unsigned long start;
		unsigned long end;
		};

		/* Collect all resources requested, to avoid conflict */
		struct apei_resources apei_resources_all = {
		.iomem = LIST_HEAD_INIT(apei_resources_all.iomem),
		.ioport = LIST_HEAD_INIT(apei_resources_all.ioport),
		};

		static int apei_res_add(struct list_head *res_list,
		unsigned long start, unsigned long size)
		{
		struct apei_res res, resn, *res_ins = NULL;
		unsigned long end = start + size;

		if (end <= start)
		return 0;
		repeat:
		list_for_each_entry_safe(res, resn, res_list, list) {
		if (res->start > end \|\| res->end < start)
		continue;
		else if (end <= res->end && start >= res->start) {
		kfree(res_ins);
		return 0;
		}
		list_del(&res->list);
		res->start = start = min(res->start, start);
		res->end = end = max(res->end, end);
		kfree(res_ins);
		res_ins = res;
		goto repeat;
		}

		if (res_ins)
		list_add(&res_ins->list, res_list);
		else {
		res_ins = kmalloc(sizeof(*res), GFP_KERNEL);
		if (!res_ins)
		return -ENOMEM;
		res_ins->start = start;
		res_ins->end = end;
		list_add(&res_ins->list, res_list);
		}

		return 0;
		}

		static int apei_res_sub(struct list_head *res_list1,
		struct list_head *res_list2)
		{
		struct apei_res res1, resn1, res2, res;
		res1 = list_entry(res_list1->next, struct apei_res, list);
		resn1 = list_entry(res1->list.next, struct apei_res, list);
		while (&res1->list != res_list1) {
		list_for_each_entry(res2, res_list2, list) {
		if (res1->start >= res2->end \|\|
		res1->end <= res2->start)
		continue;
		else if (res1->end <= res2->end &&
		res1->start >= res2->start) {
		list_del(&res1->list);
		kfree(res1);
		break;
		} else if (res1->end > res2->end &&
		res1->start < res2->start) {
		res = kmalloc(sizeof(*res), GFP_KERNEL);
		if (!res)
		return -ENOMEM;
		res->start = res2->end;
		res->end = res1->end;
		res1->end = res2->start;
		list_add(&res->list, &res1->list);
		resn1 = res;
		} else {
		if (res1->start < res2->start)
		res1->end = res2->start;
		else
		res1->start = res2->end;
		}
		}
		res1 = resn1;
		resn1 = list_entry(resn1->list.next, struct apei_res, list);
		}

		return 0;
		}

		static void apei_res_clean(struct list_head *res_list)
		{
		struct apei_res res, resn;

		list_for_each_entry_safe(res, resn, res_list, list) {
		list_del(&res->list);
		kfree(res);
		}
		}

		void apei_resources_fini(struct apei_resources *resources)
		{
		apei_res_clean(&resources->iomem);
		apei_res_clean(&resources->ioport);
		}
		EXPORT_SYMBOL_GPL(apei_resources_fini);

		static int apei_resources_merge(struct apei_resources *resources1,
		struct apei_resources *resources2)
		{
		int rc;
		struct apei_res *res;

		list_for_each_entry(res, &resources2->iomem, list) {
		rc = apei_res_add(&resources1->iomem, res->start,
		res->end - res->start);
		if (rc)
		return rc;
		}
		list_for_each_entry(res, &resources2->ioport, list) {
		rc = apei_res_add(&resources1->ioport, res->start,
		res->end - res->start);
		if (rc)
		return rc;
		}

		return 0;
		}

		/*
		* EINJ has two groups of GARs (EINJ table entry and trigger table
		* entry), so common resources are subtracted from the trigger table
		* resources before the second requesting.
		*/
		int apei_resources_sub(struct apei_resources *resources1,
		struct apei_resources *resources2)
		{
		int rc;

		rc = apei_res_sub(&resources1->iomem, &resources2->iomem);
		if (rc)
		return rc;
		return apei_res_sub(&resources1->ioport, &resources2->ioport);
		}
		EXPORT_SYMBOL_GPL(apei_resources_sub);

		/*
		* IO memory/port rersource management mechanism is used to check
		* whether memory/port area used by GARs conflicts with normal memory
		* or IO memory/port of devices.
		*/
		int apei_resources_request(struct apei_resources *resources,
		const char *desc)
		{
		struct apei_res res, res_bak;
		struct resource *r;

		apei_resources_sub(resources, &apei_resources_all);

		list_for_each_entry(res, &resources->iomem, list) {
		r = request_mem_region(res->start, res->end - res->start,
		desc);
		if (!r) {
		pr_err(APEI_PFX
		"Can not request iomem region <%016llx-%016llx> for GARs.\n",
		(unsigned long long)res->start,
		(unsigned long long)res->end);
		res_bak = res;
		goto err_unmap_iomem;
		}
		}

		list_for_each_entry(res, &resources->ioport, list) {
		r = request_region(res->start, res->end - res->start, desc);
		if (!r) {
		pr_err(APEI_PFX
		"Can not request ioport region <%016llx-%016llx> for GARs.\n",
		(unsigned long long)res->start,
		(unsigned long long)res->end);
		res_bak = res;
		goto err_unmap_ioport;
		}
		}

		apei_resources_merge(&apei_resources_all, resources);

		return 0;
		err_unmap_ioport:
		list_for_each_entry(res, &resources->ioport, list) {
		if (res == res_bak)
		break;
		release_mem_region(res->start, res->end - res->start);
		}
		res_bak = NULL;
		err_unmap_iomem:
		list_for_each_entry(res, &resources->iomem, list) {
		if (res == res_bak)
		break;
		release_region(res->start, res->end - res->start);
		}
		return -EINVAL;
		}
		EXPORT_SYMBOL_GPL(apei_resources_request);

		void apei_resources_release(struct apei_resources *resources)
		{
		struct apei_res *res;

		list_for_each_entry(res, &resources->iomem, list)
		release_mem_region(res->start, res->end - res->start);
		list_for_each_entry(res, &resources->ioport, list)
		release_region(res->start, res->end - res->start);

		apei_resources_sub(&apei_resources_all, resources);
		}
		EXPORT_SYMBOL_GPL(apei_resources_release);

		static int apei_check_gar(struct acpi_generic_address reg, u64 paddr)
		{
		u32 width, space_id;

		width = reg->bit_width;
		space_id = reg->space_id;
		/* Handle possible alignment issues */
		memcpy(paddr, &reg->address, sizeof(*paddr));
		if (!*paddr) {
		pr_warning(FW_BUG APEI_PFX
		"Invalid physical address in GAR [0x%llx/%u/%u]\n",
		*paddr, width, space_id);
		return -EINVAL;
		}

		if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) {
		pr_warning(FW_BUG APEI_PFX
		"Invalid bit width in GAR [0x%llx/%u/%u]\n",
		*paddr, width, space_id);
		return -EINVAL;
		}

		if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
		space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
		pr_warning(FW_BUG APEI_PFX
		"Invalid address space type in GAR [0x%llx/%u/%u]\n",
		*paddr, width, space_id);
		return -EINVAL;
		}

		return 0;
		}

		static int collect_res_callback(struct apei_exec_context *ctx,
		struct acpi_whea_header *entry,
		void *data)
		{
		struct apei_resources *resources = data;
		struct acpi_generic_address *reg = &entry->register_region;
		u8 ins = entry->instruction;
		u64 paddr;
		int rc;

		if (!(ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER))
		return 0;

		rc = apei_check_gar(reg, &paddr);
		if (rc)
		return rc;

		switch (reg->space_id) {
		case ACPI_ADR_SPACE_SYSTEM_MEMORY:
		return apei_res_add(&resources->iomem, paddr,
		reg->bit_width / 8);
		case ACPI_ADR_SPACE_SYSTEM_IO:
		return apei_res_add(&resources->ioport, paddr,
		reg->bit_width / 8);
		default:
		return -EINVAL;
		}
		}

		/*
		* Same register may be used by multiple instructions in GARs, so
		* resources are collected before requesting.
		*/
		int apei_exec_collect_resources(struct apei_exec_context *ctx,
		struct apei_resources *resources)
		{
		return apei_exec_for_each_entry(ctx, collect_res_callback,
		resources, NULL);
		}
		EXPORT_SYMBOL_GPL(apei_exec_collect_resources);

		struct dentry *apei_get_debugfs_dir(void)
		{
		static struct dentry *dapei;

		if (!dapei)
		dapei = debugfs_create_dir("apei", NULL);

		return dapei;
		}
		EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);