[net-next-2.6.git] / drivers / acpi / apei / hest.c

/*
 * APEI Hardware Error Souce Table support
 *
 * HEST describes error sources in detail; communicates operational
 * parameters (i.e. severity levels, masking bits, and threshold
 * values) to Linux as necessary. It also allows the BIOS to report
 * non-standard error sources to Linux (for example, chipset-specific
 * error registers).
 *
 * For more information about HEST, please refer to ACPI Specification
 * version 4.0, section 17.3.2.
 *
 * Copyright 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/kdebug.h>
#include <linux/highmem.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <acpi/apei.h>

#include "apei-internal.h"

#define HEST_PFX "HEST: "

int hest_disable;
EXPORT_SYMBOL_GPL(hest_disable);

/* HEST table parsing */

static struct acpi_table_hest *hest_tab;

static int hest_esrc_len_tab[ACPI_HEST_TYPE_RESERVED] = {
	[ACPI_HEST_TYPE_IA32_CHECK] = -1,	/* need further calculation */
	[ACPI_HEST_TYPE_IA32_CORRECTED_CHECK] = -1,
	[ACPI_HEST_TYPE_IA32_NMI] = sizeof(struct acpi_hest_ia_nmi),
	[ACPI_HEST_TYPE_AER_ROOT_PORT] = sizeof(struct acpi_hest_aer_root),
	[ACPI_HEST_TYPE_AER_ENDPOINT] = sizeof(struct acpi_hest_aer),
	[ACPI_HEST_TYPE_AER_BRIDGE] = sizeof(struct acpi_hest_aer_bridge),
	[ACPI_HEST_TYPE_GENERIC_ERROR] = sizeof(struct acpi_hest_generic),
};

static int hest_esrc_len(struct acpi_hest_header *hest_hdr)
{
	u16 hest_type = hest_hdr->type;
	int len;

	if (hest_type >= ACPI_HEST_TYPE_RESERVED)
		return 0;

	len = hest_esrc_len_tab[hest_type];

	if (hest_type == ACPI_HEST_TYPE_IA32_CORRECTED_CHECK) {
		struct acpi_hest_ia_corrected *cmc;
		cmc = (struct acpi_hest_ia_corrected *)hest_hdr;
		len = sizeof(*cmc) + cmc->num_hardware_banks *
			sizeof(struct acpi_hest_ia_error_bank);
	} else if (hest_type == ACPI_HEST_TYPE_IA32_CHECK) {
		struct acpi_hest_ia_machine_check *mc;
		mc = (struct acpi_hest_ia_machine_check *)hest_hdr;
		len = sizeof(*mc) + mc->num_hardware_banks *
			sizeof(struct acpi_hest_ia_error_bank);
	}
	BUG_ON(len == -1);

	return len;
};

int apei_hest_parse(apei_hest_func_t func, void *data)
{
	struct acpi_hest_header *hest_hdr;
	int i, rc, len;

	if (hest_disable)
		return -EINVAL;

	hest_hdr = (struct acpi_hest_header *)(hest_tab + 1);
	for (i = 0; i < hest_tab->error_source_count; i++) {
		len = hest_esrc_len(hest_hdr);
		if (!len) {
			pr_warning(FW_WARN HEST_PFX
				   "Unknown or unused hardware error source "
				   "type: %d for hardware error source: %d.\n",
				   hest_hdr->type, hest_hdr->source_id);
			return -EINVAL;
		}
		if ((void *)hest_hdr + len >
		    (void *)hest_tab + hest_tab->header.length) {
			pr_warning(FW_BUG HEST_PFX
		"Table contents overflow for hardware error source: %d.\n",
				hest_hdr->source_id);
			return -EINVAL;
		}

		rc = func(hest_hdr, data);
		if (rc)
			return rc;

		hest_hdr = (void *)hest_hdr + len;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(apei_hest_parse);

struct ghes_arr {
	struct platform_device **ghes_devs;
	unsigned int count;
};

static int hest_parse_ghes_count(struct acpi_hest_header *hest_hdr, void *data)
{
	int *count = data;

	if (hest_hdr->type == ACPI_HEST_TYPE_GENERIC_ERROR)
		(*count)++;
	return 0;
}

static int hest_parse_ghes(struct acpi_hest_header *hest_hdr, void *data)
{
	struct acpi_hest_generic *generic;
	struct platform_device *ghes_dev;
	struct ghes_arr *ghes_arr = data;
	int rc;

	if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR)
		return 0;
	generic = (struct acpi_hest_generic *)hest_hdr;
	if (!generic->enabled)
		return 0;
	ghes_dev = platform_device_alloc("GHES", hest_hdr->source_id);
	if (!ghes_dev)
		return -ENOMEM;
	ghes_dev->dev.platform_data = generic;
	rc = platform_device_add(ghes_dev);
	if (rc)
		goto err;
	ghes_arr->ghes_devs[ghes_arr->count++] = ghes_dev;

	return 0;
err:
	platform_device_put(ghes_dev);
	return rc;
}

static int hest_ghes_dev_register(unsigned int ghes_count)
{
	int rc, i;
	struct ghes_arr ghes_arr;

	ghes_arr.count = 0;
	ghes_arr.ghes_devs = kmalloc(sizeof(void *) * ghes_count, GFP_KERNEL);
	if (!ghes_arr.ghes_devs)
		return -ENOMEM;

	rc = apei_hest_parse(hest_parse_ghes, &ghes_arr);
	if (rc)
		goto err;
out:
	kfree(ghes_arr.ghes_devs);
	return rc;
err:
	for (i = 0; i < ghes_arr.count; i++)
		platform_device_unregister(ghes_arr.ghes_devs[i]);
	goto out;
}

static int __init setup_hest_disable(char *str)
{
	hest_disable = 1;
	return 0;
}

__setup("hest_disable", setup_hest_disable);

static int __init hest_init(void)
{
	acpi_status status;
	int rc = -ENODEV;
	unsigned int ghes_count = 0;

	if (acpi_disabled)
		goto err;

	if (hest_disable) {
		pr_info(HEST_PFX "HEST tabling parsing is disabled.\n");
		goto err;
	}

	status = acpi_get_table(ACPI_SIG_HEST, 0,
				(struct acpi_table_header **)&hest_tab);
	if (status == AE_NOT_FOUND) {
		pr_info(HEST_PFX "Table is not found!\n");
		goto err;
	} else if (ACPI_FAILURE(status)) {
		const char *msg = acpi_format_exception(status);
		pr_err(HEST_PFX "Failed to get table, %s\n", msg);
		rc = -EINVAL;
		goto err;
	}

	rc = apei_hest_parse(hest_parse_ghes_count, &ghes_count);
	if (rc)
		goto err;

	rc = hest_ghes_dev_register(ghes_count);
	if (rc)
		goto err;

	pr_info(HEST_PFX "HEST table parsing is initialized.\n");

	return 0;
err:
	hest_disable = 1;
	return rc;
}

subsys_initcall(hest_init);
Commit	Line	Data
9dc96664 HY	1	/*
	2	* APEI Hardware Error Souce Table support
	3	*
	4	* HEST describes error sources in detail; communicates operational
	5	* parameters (i.e. severity levels, masking bits, and threshold
	6	* values) to Linux as necessary. It also allows the BIOS to report
	7	* non-standard error sources to Linux (for example, chipset-specific
	8	* error registers).
	9	*
	10	* For more information about HEST, please refer to ACPI Specification
	11	* version 4.0, section 17.3.2.
	12	*
	13	* Copyright 2009 Intel Corp.
	14	* Author: Huang Ying <ying.huang@intel.com>
	15	*
	16	* This program is free software; you can redistribute it and/or
	17	* modify it under the terms of the GNU General Public License version
	18	* 2 as published by the Free Software Foundation;
	19	*
	20	* This program is distributed in the hope that it will be useful,
	21	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	23	* GNU General Public License for more details.
	24	*
	25	* You should have received a copy of the GNU General Public License
	26	* along with this program; if not, write to the Free Software
	27	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	28	*/
	29
	30	#include <linux/kernel.h>
	31	#include <linux/module.h>
	32	#include <linux/init.h>
	33	#include <linux/acpi.h>
	34	#include <linux/kdebug.h>
	35	#include <linux/highmem.h>
	36	#include <linux/io.h>
7ad6e943	37	#include <linux/platform_device.h>
9dc96664 HY	38	#include <acpi/apei.h>
	39
	40	#include "apei-internal.h"
	41
	42	#define HEST_PFX "HEST: "
	43
	44	int hest_disable;
	45	EXPORT_SYMBOL_GPL(hest_disable);
	46
	47	/* HEST table parsing */
	48
	49	static struct acpi_table_hest *hest_tab;
	50
9dc96664 HY	51	static int hest_esrc_len_tab[ACPI_HEST_TYPE_RESERVED] = {
	52	[ACPI_HEST_TYPE_IA32_CHECK] = -1, /* need further calculation */
	53	[ACPI_HEST_TYPE_IA32_CORRECTED_CHECK] = -1,
	54	[ACPI_HEST_TYPE_IA32_NMI] = sizeof(struct acpi_hest_ia_nmi),
	55	[ACPI_HEST_TYPE_AER_ROOT_PORT] = sizeof(struct acpi_hest_aer_root),
	56	[ACPI_HEST_TYPE_AER_ENDPOINT] = sizeof(struct acpi_hest_aer),
	57	[ACPI_HEST_TYPE_AER_BRIDGE] = sizeof(struct acpi_hest_aer_bridge),
	58	[ACPI_HEST_TYPE_GENERIC_ERROR] = sizeof(struct acpi_hest_generic),
	59	};
	60
	61	static int hest_esrc_len(struct acpi_hest_header *hest_hdr)
	62	{
	63	u16 hest_type = hest_hdr->type;
	64	int len;
	65
	66	if (hest_type >= ACPI_HEST_TYPE_RESERVED)
	67	return 0;
	68
	69	len = hest_esrc_len_tab[hest_type];
	70
	71	if (hest_type == ACPI_HEST_TYPE_IA32_CORRECTED_CHECK) {
	72	struct acpi_hest_ia_corrected *cmc;
	73	cmc = (struct acpi_hest_ia_corrected *)hest_hdr;
	74	len = sizeof(cmc) + cmc->num_hardware_banks
	75	sizeof(struct acpi_hest_ia_error_bank);
	76	} else if (hest_type == ACPI_HEST_TYPE_IA32_CHECK) {
	77	struct acpi_hest_ia_machine_check *mc;
	78	mc = (struct acpi_hest_ia_machine_check *)hest_hdr;
	79	len = sizeof(mc) + mc->num_hardware_banks
	80	sizeof(struct acpi_hest_ia_error_bank);
	81	}
	82	BUG_ON(len == -1);
	83
	84	return len;
	85	};
	86
	87	int apei_hest_parse(apei_hest_func_t func, void *data)
	88	{
	89	struct acpi_hest_header *hest_hdr;
	90	int i, rc, len;
	91
	92	if (hest_disable)
	93	return -EINVAL;
	94
	95	hest_hdr = (struct acpi_hest_header *)(hest_tab + 1);
	96	for (i = 0; i < hest_tab->error_source_count; i++) {
	97	len = hest_esrc_len(hest_hdr);
	98	if (!len) {
	99	pr_warning(FW_WARN HEST_PFX
	100	"Unknown or unused hardware error source "
	101	"type: %d for hardware error source: %d.\n",
	102	hest_hdr->type, hest_hdr->source_id);
	103	return -EINVAL;
	104	}
	105	if ((void *)hest_hdr + len >
	106	(void *)hest_tab + hest_tab->header.length) {
	107	pr_warning(FW_BUG HEST_PFX
	108	"Table contents overflow for hardware error source: %d.\n",
	109	hest_hdr->source_id);
	110	return -EINVAL;
	111	}
	112
	113	rc = func(hest_hdr, data);
	114	if (rc)
115	return rc;
116
117	hest_hdr = (void *)hest_hdr + len;
118	}
119
120	return 0;
121	}
122	EXPORT_SYMBOL_GPL(apei_hest_parse);
123
7ad6e943 HY	124	struct ghes_arr {
	125	struct platform_device **ghes_devs;
	126	unsigned int count;
	127	};
	128
	129	static int hest_parse_ghes_count(struct acpi_hest_header hest_hdr, void data)
	130	{
	131	int *count = data;
	132
	133	if (hest_hdr->type == ACPI_HEST_TYPE_GENERIC_ERROR)
	134	(*count)++;
	135	return 0;
	136	}
	137
	138	static int hest_parse_ghes(struct acpi_hest_header hest_hdr, void data)
	139	{
	140	struct acpi_hest_generic *generic;
	141	struct platform_device *ghes_dev;
	142	struct ghes_arr *ghes_arr = data;
	143	int rc;
	144
	145	if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR)
	146	return 0;
	147	generic = (struct acpi_hest_generic *)hest_hdr;
	148	if (!generic->enabled)
	149	return 0;
	150	ghes_dev = platform_device_alloc("GHES", hest_hdr->source_id);
	151	if (!ghes_dev)
	152	return -ENOMEM;
	153	ghes_dev->dev.platform_data = generic;
	154	rc = platform_device_add(ghes_dev);
	155	if (rc)
	156	goto err;
	157	ghes_arr->ghes_devs[ghes_arr->count++] = ghes_dev;
	158
	159	return 0;
	160	err:
	161	platform_device_put(ghes_dev);
	162	return rc;
	163	}
	164
	165	static int hest_ghes_dev_register(unsigned int ghes_count)
	166	{
	167	int rc, i;
	168	struct ghes_arr ghes_arr;
	169
	170	ghes_arr.count = 0;
	171	ghes_arr.ghes_devs = kmalloc(sizeof(void ) ghes_count, GFP_KERNEL);
	172	if (!ghes_arr.ghes_devs)
	173	return -ENOMEM;
	174
	175	rc = apei_hest_parse(hest_parse_ghes, &ghes_arr);
	176	if (rc)
	177	goto err;
	178	out:
	179	kfree(ghes_arr.ghes_devs);
	180	return rc;
	181	err:
	182	for (i = 0; i < ghes_arr.count; i++)
	183	platform_device_unregister(ghes_arr.ghes_devs[i]);
	184	goto out;
	185	}
	186
9dc96664 HY	187	static int __init setup_hest_disable(char *str)
	188	{
	189	hest_disable = 1;
	190	return 0;
	191	}
	192
	193	__setup("hest_disable", setup_hest_disable);
	194
	195	static int __init hest_init(void)
	196	{
	197	acpi_status status;
	198	int rc = -ENODEV;
7ad6e943	199	unsigned int ghes_count = 0;
9dc96664 HY	200
	201	if (acpi_disabled)
	202	goto err;
	203
	204	if (hest_disable) {
	205	pr_info(HEST_PFX "HEST tabling parsing is disabled.\n");
	206	goto err;
	207	}
	208
	209	status = acpi_get_table(ACPI_SIG_HEST, 0,
	210	(struct acpi_table_header **)&hest_tab);
	211	if (status == AE_NOT_FOUND) {
	212	pr_info(HEST_PFX "Table is not found!\n");
	213	goto err;
	214	} else if (ACPI_FAILURE(status)) {
	215	const char *msg = acpi_format_exception(status);
	216	pr_err(HEST_PFX "Failed to get table, %s\n", msg);
	217	rc = -EINVAL;
	218	goto err;
	219	}
	220
7ad6e943 HY	221	rc = apei_hest_parse(hest_parse_ghes_count, &ghes_count);
	222	if (rc)
	223	goto err;
	224
	225	rc = hest_ghes_dev_register(ghes_count);
9dc96664 HY	226	if (rc)
	227	goto err;
	228
	229	pr_info(HEST_PFX "HEST table parsing is initialized.\n");
	230
	231	return 0;
	232	err:
	233	hest_disable = 1;
	234	return rc;
	235	}
	236
	237	subsys_initcall(hest_init);