[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / system.c

/*
 *  acpi_system.c - ACPI System Driver ($Revision: 63 $)
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  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/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/string.h>
#include <asm/uaccess.h>

#include <acpi/acpi_drivers.h>

#define PREFIX "ACPI: "

#define _COMPONENT		ACPI_SYSTEM_COMPONENT
ACPI_MODULE_NAME("system");

#define ACPI_SYSTEM_CLASS		"system"
#define ACPI_SYSTEM_DEVICE_NAME		"System"

u32 acpi_irq_handled;
u32 acpi_irq_not_handled;

/*
 * Make ACPICA version work as module param
 */
static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
{
	int result;

	result = sprintf(buffer, "%x", ACPI_CA_VERSION);

	return result;
}

module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);

/* --------------------------------------------------------------------------
                              FS Interface (/sys)
   -------------------------------------------------------------------------- */
static LIST_HEAD(acpi_table_attr_list);
static struct kobject *tables_kobj;
static struct kobject *dynamic_tables_kobj;

struct acpi_table_attr {
	struct bin_attribute attr;
	char name[8];
	int instance;
	struct list_head node;
};

static ssize_t acpi_table_show(struct kobject *kobj,
			       struct bin_attribute *bin_attr, char *buf,
			       loff_t offset, size_t count)
{
	struct acpi_table_attr *table_attr =
	    container_of(bin_attr, struct acpi_table_attr, attr);
	struct acpi_table_header *table_header = NULL;
	acpi_status status;
	char name[ACPI_NAME_SIZE];

	if (strncmp(table_attr->name, "NULL", 4))
		memcpy(name, table_attr->name, ACPI_NAME_SIZE);
	else
		memcpy(name, "\0\0\0\0", 4);

	status =
	    acpi_get_table(name, table_attr->instance,
			   &table_header);
	if (ACPI_FAILURE(status))
		return -ENODEV;

	return memory_read_from_buffer(buf, count, &offset,
					table_header, table_header->length);
}

static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
				 struct acpi_table_header *table_header)
{
	struct acpi_table_header *header = NULL;
	struct acpi_table_attr *attr = NULL;

	sysfs_attr_init(&table_attr->attr.attr);
	if (table_header->signature[0] != '\0')
		memcpy(table_attr->name, table_header->signature,
			ACPI_NAME_SIZE);
	else
		memcpy(table_attr->name, "NULL", 4);

	list_for_each_entry(attr, &acpi_table_attr_list, node) {
		if (!memcmp(table_attr->name, attr->name, ACPI_NAME_SIZE))
			if (table_attr->instance < attr->instance)
				table_attr->instance = attr->instance;
	}
	table_attr->instance++;

	if (table_attr->instance > 1 || (table_attr->instance == 1 &&
					!acpi_get_table
					(table_header->signature, 2, &header)))
		sprintf(table_attr->name + ACPI_NAME_SIZE, "%d",
			table_attr->instance);

	table_attr->attr.size = 0;
	table_attr->attr.read = acpi_table_show;
	table_attr->attr.attr.name = table_attr->name;
	table_attr->attr.attr.mode = 0400;

	return;
}

static acpi_status
acpi_sysfs_table_handler(u32 event, void *table, void *context)
{
	struct acpi_table_attr *table_attr;

	switch (event) {
	case ACPI_TABLE_EVENT_LOAD:
		table_attr =
			kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
		if (!table_attr)
			return AE_NO_MEMORY;

		acpi_table_attr_init(table_attr, table);
		if (sysfs_create_bin_file(dynamic_tables_kobj,
					&table_attr->attr)) {
			kfree(table_attr);
			return AE_ERROR;
		} else
			list_add_tail(&table_attr->node,
					&acpi_table_attr_list);
		break;
	case ACPI_TABLE_EVENT_UNLOAD:
		/*
		 * we do not need to do anything right now
		 * because the table is not deleted from the
		 * global table list when unloading it.
		 */
		break;
	default:
		return AE_BAD_PARAMETER;
	}
	return AE_OK;
}

static int acpi_system_sysfs_init(void)
{
	struct acpi_table_attr *table_attr;
	struct acpi_table_header *table_header = NULL;
	int table_index = 0;
	int result;

	tables_kobj = kobject_create_and_add("tables", acpi_kobj);
	if (!tables_kobj)
		goto err;

	dynamic_tables_kobj = kobject_create_and_add("dynamic", tables_kobj);
	if (!dynamic_tables_kobj)
		goto err_dynamic_tables;

	do {
		result = acpi_get_table_by_index(table_index, &table_header);
		if (!result) {
			table_index++;
			table_attr = NULL;
			table_attr =
			    kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
			if (!table_attr)
				return -ENOMEM;

			acpi_table_attr_init(table_attr, table_header);
			result =
			    sysfs_create_bin_file(tables_kobj,
						  &table_attr->attr);
			if (result) {
				kfree(table_attr);
				return result;
			} else
				list_add_tail(&table_attr->node,
					      &acpi_table_attr_list);
		}
	} while (!result);
	kobject_uevent(tables_kobj, KOBJ_ADD);
	kobject_uevent(dynamic_tables_kobj, KOBJ_ADD);
	result = acpi_install_table_handler(acpi_sysfs_table_handler, NULL);

	return result == AE_OK ? 0 : -EINVAL;
err_dynamic_tables:
	kobject_put(tables_kobj);
err:
	return -ENOMEM;
}

/*
 * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
 * See Documentation/ABI/testing/sysfs-firmware-acpi
 */

#define COUNT_GPE 0
#define COUNT_SCI 1	/* acpi_irq_handled */
#define COUNT_SCI_NOT 2	/* acpi_irq_not_handled */
#define COUNT_ERROR 3	/* other */
#define NUM_COUNTERS_EXTRA 4

struct event_counter {
	u32 count;
	u32 flags;
};

static struct event_counter *all_counters;
static u32 num_gpes;
static u32 num_counters;
static struct attribute **all_attrs;
static u32 acpi_gpe_count;

static struct attribute_group interrupt_stats_attr_group = {
	.name = "interrupts",
};
static struct kobj_attribute *counter_attrs;

static void delete_gpe_attr_array(void)
{
	struct event_counter *tmp = all_counters;

	all_counters = NULL;
	kfree(tmp);

	if (counter_attrs) {
		int i;

		for (i = 0; i < num_gpes; i++)
			kfree(counter_attrs[i].attr.name);

		kfree(counter_attrs);
	}
	kfree(all_attrs);

	return;
}

void acpi_os_gpe_count(u32 gpe_number)
{
	acpi_gpe_count++;

	if (!all_counters)
		return;

	if (gpe_number < num_gpes)
		all_counters[gpe_number].count++;
	else
		all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
					count++;

	return;
}

void acpi_os_fixed_event_count(u32 event_number)
{
	if (!all_counters)
		return;

	if (event_number < ACPI_NUM_FIXED_EVENTS)
		all_counters[num_gpes + event_number].count++;
	else
		all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
				count++;

	return;
}

static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
{
	int result = 0;

	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
		goto end;

	if (index < num_gpes) {
		result = acpi_get_gpe_device(index, handle);
		if (result) {
			ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
				"Invalid GPE 0x%x\n", index));
			goto end;
		}
		result = acpi_get_gpe_status(*handle, index,
						ACPI_NOT_ISR, status);
	} else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS))
		result = acpi_get_event_status(index - num_gpes, status);

end:
	return result;
}

static ssize_t counter_show(struct kobject *kobj,
	struct kobj_attribute *attr, char *buf)
{
	int index = attr - counter_attrs;
	int size;
	acpi_handle handle;
	acpi_event_status status;
	int result = 0;

	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
		acpi_irq_handled;
	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT].count =
		acpi_irq_not_handled;
	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count =
		acpi_gpe_count;

	size = sprintf(buf, "%8d", all_counters[index].count);

	/* "gpe_all" or "sci" */
	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
		goto end;

	result = get_status(index, &status, &handle);
	if (result)
		goto end;

	if (!(status & ACPI_EVENT_FLAG_HANDLE))
		size += sprintf(buf + size, "	invalid");
	else if (status & ACPI_EVENT_FLAG_ENABLED)
		size += sprintf(buf + size, "	enabled");
	else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED)
		size += sprintf(buf + size, "	wake_enabled");
	else
		size += sprintf(buf + size, "	disabled");

end:
	size += sprintf(buf + size, "\n");
	return result ? result : size;
}

/*
 * counter_set() sets the specified counter.
 * setting the total "sci" file to any value clears all counters.
 * enable/disable/clear a gpe/fixed event in user space.
 */
static ssize_t counter_set(struct kobject *kobj,
	struct kobj_attribute *attr, const char *buf, size_t size)
{
	int index = attr - counter_attrs;
	acpi_event_status status;
	acpi_handle handle;
	int result = 0;

	if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) {
		int i;
		for (i = 0; i < num_counters; ++i)
			all_counters[i].count = 0;
		acpi_gpe_count = 0;
		acpi_irq_handled = 0;
		acpi_irq_not_handled = 0;
		goto end;
	}

	/* show the event status for both GPEs and Fixed Events */
	result = get_status(index, &status, &handle);
	if (result)
		goto end;

	if (!(status & ACPI_EVENT_FLAG_HANDLE)) {
		printk(KERN_WARNING PREFIX
			"Can not change Invalid GPE/Fixed Event status\n");
		return -EINVAL;
	}

	if (index < num_gpes) {
		if (!strcmp(buf, "disable\n") &&
				(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_set_gpe(handle, index, ACPI_GPE_DISABLE);
		else if (!strcmp(buf, "enable\n") &&
				!(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_set_gpe(handle, index, ACPI_GPE_ENABLE);
		else if (!strcmp(buf, "clear\n") &&
				(status & ACPI_EVENT_FLAG_SET))
			result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR);
		else
			all_counters[index].count = strtoul(buf, NULL, 0);
	} else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
		int event = index - num_gpes;
		if (!strcmp(buf, "disable\n") &&
				(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_disable_event(event, ACPI_NOT_ISR);
		else if (!strcmp(buf, "enable\n") &&
				!(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_enable_event(event, ACPI_NOT_ISR);
		else if (!strcmp(buf, "clear\n") &&
				(status & ACPI_EVENT_FLAG_SET))
			result = acpi_clear_event(event);
		else
			all_counters[index].count = strtoul(buf, NULL, 0);
	} else
		all_counters[index].count = strtoul(buf, NULL, 0);

	if (ACPI_FAILURE(result))
		result = -EINVAL;
end:
	return result ? result : size;
}

void acpi_irq_stats_init(void)
{
	int i;

	if (all_counters)
		return;

	num_gpes = acpi_current_gpe_count;
	num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;

	all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
			GFP_KERNEL);
	if (all_attrs == NULL)
		return;

	all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
				GFP_KERNEL);
	if (all_counters == NULL)
		goto fail;

	counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
			GFP_KERNEL);
	if (counter_attrs == NULL)
		goto fail;

	for (i = 0; i < num_counters; ++i) {
		char buffer[12];
		char *name;

		if (i < num_gpes)
			sprintf(buffer, "gpe%02X", i);
		else if (i == num_gpes + ACPI_EVENT_PMTIMER)
			sprintf(buffer, "ff_pmtimer");
		else if (i == num_gpes + ACPI_EVENT_GLOBAL)
			sprintf(buffer, "ff_gbl_lock");
		else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON)
			sprintf(buffer, "ff_pwr_btn");
		else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON)
			sprintf(buffer, "ff_slp_btn");
		else if (i == num_gpes + ACPI_EVENT_RTC)
			sprintf(buffer, "ff_rt_clk");
		else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE)
			sprintf(buffer, "gpe_all");
		else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI)
			sprintf(buffer, "sci");
		else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT)
			sprintf(buffer, "sci_not");
		else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR)
			sprintf(buffer, "error");
		else
			sprintf(buffer, "bug%02X", i);

		name = kzalloc(strlen(buffer) + 1, GFP_KERNEL);
		if (name == NULL)
			goto fail;
		strncpy(name, buffer, strlen(buffer) + 1);

		sysfs_attr_init(&counter_attrs[i].attr);
		counter_attrs[i].attr.name = name;
		counter_attrs[i].attr.mode = 0644;
		counter_attrs[i].show = counter_show;
		counter_attrs[i].store = counter_set;

		all_attrs[i] = &counter_attrs[i].attr;
	}

	interrupt_stats_attr_group.attrs = all_attrs;
	if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group))
		return;

fail:
	delete_gpe_attr_array();
	return;
}

static void __exit interrupt_stats_exit(void)
{
	sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group);

	delete_gpe_attr_array();

	return;
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */
#ifdef CONFIG_ACPI_PROCFS
#define ACPI_SYSTEM_FILE_INFO		"info"
#define ACPI_SYSTEM_FILE_EVENT		"event"
#define ACPI_SYSTEM_FILE_DSDT		"dsdt"
#define ACPI_SYSTEM_FILE_FADT		"fadt"

static int acpi_system_read_info(struct seq_file *seq, void *offset)
{

	seq_printf(seq, "version:                 %x\n", ACPI_CA_VERSION);
	return 0;
}

static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_system_read_info, PDE(inode)->data);
}

static const struct file_operations acpi_system_info_ops = {
	.owner = THIS_MODULE,
	.open = acpi_system_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
				     loff_t *);

static const struct file_operations acpi_system_dsdt_ops = {
	.owner = THIS_MODULE,
	.read = acpi_system_read_dsdt,
};

static ssize_t
acpi_system_read_dsdt(struct file *file,
		      char __user * buffer, size_t count, loff_t * ppos)
{
	acpi_status status = AE_OK;
	struct acpi_table_header *dsdt = NULL;
	ssize_t res;

	status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
	if (ACPI_FAILURE(status))
		return -ENODEV;

	res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);

	return res;
}

static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
				     loff_t *);

static const struct file_operations acpi_system_fadt_ops = {
	.owner = THIS_MODULE,
	.read = acpi_system_read_fadt,
};

static ssize_t
acpi_system_read_fadt(struct file *file,
		      char __user * buffer, size_t count, loff_t * ppos)
{
	acpi_status status = AE_OK;
	struct acpi_table_header *fadt = NULL;
	ssize_t res;

	status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
	if (ACPI_FAILURE(status))
		return -ENODEV;

	res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);

	return res;
}

static int acpi_system_procfs_init(void)
{
	struct proc_dir_entry *entry;
	int error = 0;

	/* 'info' [R] */
	entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
			    &acpi_system_info_ops);
	if (!entry)
		goto Error;

	/* 'dsdt' [R] */
	entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
			    &acpi_system_dsdt_ops);
	if (!entry)
		goto Error;

	/* 'fadt' [R] */
	entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
			    &acpi_system_fadt_ops);
	if (!entry)
		goto Error;

      Done:
	return error;

      Error:
	remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
	remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
	remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);

	error = -EFAULT;
	goto Done;
}
#else
static int acpi_system_procfs_init(void)
{
	return 0;
}
#endif

int __init acpi_system_init(void)
{
	int result;

	result = acpi_system_procfs_init();
	if (result)
		return result;

	result = acpi_system_sysfs_init();

	return result;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* acpi_system.c - ACPI System Driver ($Revision: 63 $)
	3	*
	4	* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
	5	* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
	6	*
	7	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	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 as published by
	11	* the Free Software Foundation; either version 2 of the License, or (at
	12	* your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
	22	*
	23	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	24	*/
	25
	26	#include <linux/proc_fs.h>
	27	#include <linux/seq_file.h>
	28	#include <linux/init.h>
e108526e	29	#include <linux/string.h>
1da177e4 LT	30	#include <asm/uaccess.h>
	31
	32	#include <acpi/acpi_drivers.h>
	33
a192a958 LB	34	#define PREFIX "ACPI: "
a192a958 LB	35
1da177e4	36	#define _COMPONENT ACPI_SYSTEM_COMPONENT
f52fd66d	37	ACPI_MODULE_NAME("system");
5bb730fd	38
1da177e4	39	#define ACPI_SYSTEM_CLASS "system"
1da177e4	40	#define ACPI_SYSTEM_DEVICE_NAME "System"
1da177e4	41
5229e87d	42	u32 acpi_irq_handled;
88bea188	43	u32 acpi_irq_not_handled;
5229e87d	44
5bb730fd ZR	45	/*
	46	* Make ACPICA version work as module param
	47	*/
d4c5f047 ZR	48	static int param_get_acpica_version(char buffer, struct kernel_param kp)
d4c5f047 ZR	49	{
5bb730fd ZR	50	int result;
	51
	52	result = sprintf(buffer, "%x", ACPI_CA_VERSION);
	53
	54	return result;
	55	}
	56
	57	module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
	58
d4c5f047 ZR	59	/* --------------------------------------------------------------------------
	60	FS Interface (/sys)
	61	-------------------------------------------------------------------------- */
	62	static LIST_HEAD(acpi_table_attr_list);
a77aa28a	63	static struct kobject *tables_kobj;
4658e4ef	64	static struct kobject *dynamic_tables_kobj;
d4c5f047 ZR	65
	66	struct acpi_table_attr {
	67	struct bin_attribute attr;
	68	char name[8];
	69	int instance;
	70	struct list_head node;
	71	};
	72
	73	static ssize_t acpi_table_show(struct kobject *kobj,
	74	struct bin_attribute bin_attr, char buf,
	75	loff_t offset, size_t count)
	76	{
	77	struct acpi_table_attr *table_attr =
	78	container_of(bin_attr, struct acpi_table_attr, attr);
	79	struct acpi_table_header *table_header = NULL;
	80	acpi_status status;
4feba70a PG	81	char name[ACPI_NAME_SIZE];
	82
	83	if (strncmp(table_attr->name, "NULL", 4))
	84	memcpy(name, table_attr->name, ACPI_NAME_SIZE);
	85	else
	86	memcpy(name, "\0\0\0\0", 4);
d4c5f047 ZR	87
d4c5f047 ZR	88	status =
4feba70a	89	acpi_get_table(name, table_attr->instance,
d4c5f047 ZR	90	&table_header);
	91	if (ACPI_FAILURE(status))
	92	return -ENODEV;
	93
46a21e46 AM	94	return memory_read_from_buffer(buf, count, &offset,
46a21e46 AM	95	table_header, table_header->length);
d4c5f047 ZR	96	}
	97
	98	static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
	99	struct acpi_table_header *table_header)
	100	{
	101	struct acpi_table_header *header = NULL;
	102	struct acpi_table_attr *attr = NULL;
	103
a07e4156	104	sysfs_attr_init(&table_attr->attr.attr);
4feba70a PG	105	if (table_header->signature[0] != '\0')
	106	memcpy(table_attr->name, table_header->signature,
	107	ACPI_NAME_SIZE);
	108	else
	109	memcpy(table_attr->name, "NULL", 4);
d4c5f047 ZR	110
d4c5f047 ZR	111	list_for_each_entry(attr, &acpi_table_attr_list, node) {
4feba70a	112	if (!memcmp(table_attr->name, attr->name, ACPI_NAME_SIZE))
d4c5f047 ZR	113	if (table_attr->instance < attr->instance)
	114	table_attr->instance = attr->instance;
	115	}
	116	table_attr->instance++;
	117
	118	if (table_attr->instance > 1 \|\| (table_attr->instance == 1 &&
4feba70a PG	119	!acpi_get_table
	120	(table_header->signature, 2, &header)))
	121	sprintf(table_attr->name + ACPI_NAME_SIZE, "%d",
	122	table_attr->instance);
d4c5f047 ZR	123
	124	table_attr->attr.size = 0;
	125	table_attr->attr.read = acpi_table_show;
	126	table_attr->attr.attr.name = table_attr->name;
d0006f32	127	table_attr->attr.attr.mode = 0400;
d4c5f047 ZR	128
	129	return;
	130	}
	131
4658e4ef ZR	132	static acpi_status
	133	acpi_sysfs_table_handler(u32 event, void table, void context)
	134	{
	135	struct acpi_table_attr *table_attr;
	136
	137	switch (event) {
	138	case ACPI_TABLE_EVENT_LOAD:
	139	table_attr =
	140	kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
	141	if (!table_attr)
	142	return AE_NO_MEMORY;
	143
	144	acpi_table_attr_init(table_attr, table);
	145	if (sysfs_create_bin_file(dynamic_tables_kobj,
	146	&table_attr->attr)) {
	147	kfree(table_attr);
	148	return AE_ERROR;
	149	} else
	150	list_add_tail(&table_attr->node,
	151	&acpi_table_attr_list);
	152	break;
	153	case ACPI_TABLE_EVENT_UNLOAD:
	154	/*
	155	* we do not need to do anything right now
	156	* because the table is not deleted from the
	157	* global table list when unloading it.
	158	*/
	159	break;
	160	default:
	161	return AE_BAD_PARAMETER;
	162	}
	163	return AE_OK;
	164	}
	165
d4c5f047 ZR	166	static int acpi_system_sysfs_init(void)
	167	{
	168	struct acpi_table_attr *table_attr;
	169	struct acpi_table_header *table_header = NULL;
	170	int table_index = 0;
	171	int result;
	172
a77aa28a GKH	173	tables_kobj = kobject_create_and_add("tables", acpi_kobj);
a77aa28a GKH	174	if (!tables_kobj)
4658e4ef ZR	175	goto err;
	176
	177	dynamic_tables_kobj = kobject_create_and_add("dynamic", tables_kobj);
	178	if (!dynamic_tables_kobj)
	179	goto err_dynamic_tables;
d4c5f047 ZR	180
	181	do {
	182	result = acpi_get_table_by_index(table_index, &table_header);
	183	if (!result) {
	184	table_index++;
	185	table_attr = NULL;
	186	table_attr =
	187	kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
	188	if (!table_attr)
	189	return -ENOMEM;
	190
	191	acpi_table_attr_init(table_attr, table_header);
	192	result =
a77aa28a	193	sysfs_create_bin_file(tables_kobj,
d4c5f047 ZR	194	&table_attr->attr);
	195	if (result) {
	196	kfree(table_attr);
	197	return result;
	198	} else
	199	list_add_tail(&table_attr->node,
	200	&acpi_table_attr_list);
	201	}
	202	} while (!result);
a77aa28a	203	kobject_uevent(tables_kobj, KOBJ_ADD);
4658e4ef ZR	204	kobject_uevent(dynamic_tables_kobj, KOBJ_ADD);
	205	result = acpi_install_table_handler(acpi_sysfs_table_handler, NULL);
	206
	207	return result == AE_OK ? 0 : -EINVAL;
	208	err_dynamic_tables:
	209	kobject_put(tables_kobj);
	210	err:
	211	return -ENOMEM;
d4c5f047 ZR	212	}
d4c5f047 ZR	213
5229e87d LB	214	/*
	215	* Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
	216	* See Documentation/ABI/testing/sysfs-firmware-acpi
	217	*/
	218
	219	#define COUNT_GPE 0
	220	#define COUNT_SCI 1 /* acpi_irq_handled */
88bea188 LB	221	#define COUNT_SCI_NOT 2 /* acpi_irq_not_handled */
	222	#define COUNT_ERROR 3 /* other */
	223	#define NUM_COUNTERS_EXTRA 4
5229e87d	224
71b58cbb ZR	225	struct event_counter {
	226	u32 count;
	227	u32 flags;
	228	};
	229
	230	static struct event_counter *all_counters;
5229e87d LB	231	static u32 num_gpes;
	232	static u32 num_counters;
	233	static struct attribute **all_attrs;
	234	static u32 acpi_gpe_count;
	235
	236	static struct attribute_group interrupt_stats_attr_group = {
	237	.name = "interrupts",
	238	};
	239	static struct kobj_attribute *counter_attrs;
	240
5229e87d LB	241	static void delete_gpe_attr_array(void)
5229e87d LB	242	{
71b58cbb	243	struct event_counter *tmp = all_counters;
5229e87d LB	244
	245	all_counters = NULL;
	246	kfree(tmp);
	247
	248	if (counter_attrs) {
	249	int i;
	250
	251	for (i = 0; i < num_gpes; i++)
	252	kfree(counter_attrs[i].attr.name);
	253
	254	kfree(counter_attrs);
	255	}
	256	kfree(all_attrs);
	257
	258	return;
	259	}
	260
	261	void acpi_os_gpe_count(u32 gpe_number)
	262	{
	263	acpi_gpe_count++;
	264
	265	if (!all_counters)
	266	return;
	267
	268	if (gpe_number < num_gpes)
71b58cbb	269	all_counters[gpe_number].count++;
5229e87d	270	else
71b58cbb ZR	271	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
71b58cbb ZR	272	count++;
5229e87d LB	273
	274	return;
	275	}
	276
	277	void acpi_os_fixed_event_count(u32 event_number)
	278	{
	279	if (!all_counters)
	280	return;
	281
	282	if (event_number < ACPI_NUM_FIXED_EVENTS)
71b58cbb	283	all_counters[num_gpes + event_number].count++;
5229e87d	284	else
71b58cbb ZR	285	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
71b58cbb ZR	286	count++;
5229e87d LB	287
	288	return;
	289	}
	290
71b58cbb ZR	291	static int get_status(u32 index, acpi_event_status status, acpi_handle handle)
	292	{
	293	int result = 0;
	294
	295	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
	296	goto end;
	297
	298	if (index < num_gpes) {
e97d6bf1	299	result = acpi_get_gpe_device(index, handle);
71b58cbb ZR	300	if (result) {
	301	ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
	302	"Invalid GPE 0x%x\n", index));
	303	goto end;
	304	}
	305	result = acpi_get_gpe_status(*handle, index,
	306	ACPI_NOT_ISR, status);
	307	} else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS))
	308	result = acpi_get_event_status(index - num_gpes, status);
	309
71b58cbb ZR	310	end:
	311	return result;
	312	}
	313
5229e87d LB	314	static ssize_t counter_show(struct kobject *kobj,
	315	struct kobj_attribute attr, char buf)
	316	{
71b58cbb ZR	317	int index = attr - counter_attrs;
	318	int size;
	319	acpi_handle handle;
	320	acpi_event_status status;
	321	int result = 0;
	322
	323	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
5229e87d	324	acpi_irq_handled;
88bea188 LB	325	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT].count =
88bea188 LB	326	acpi_irq_not_handled;
71b58cbb	327	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count =
5229e87d LB	328	acpi_gpe_count;
5229e87d LB	329
71b58cbb ZR	330	size = sprintf(buf, "%8d", all_counters[index].count);
	331
	332	/* "gpe_all" or "sci" */
	333	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
	334	goto end;
	335
	336	result = get_status(index, &status, &handle);
	337	if (result)
	338	goto end;
	339
ed206fac ZR	340	if (!(status & ACPI_EVENT_FLAG_HANDLE))
ed206fac ZR	341	size += sprintf(buf + size, " invalid");
71b58cbb	342	else if (status & ACPI_EVENT_FLAG_ENABLED)
ed206fac ZR	343	size += sprintf(buf + size, " enabled");
	344	else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED)
	345	size += sprintf(buf + size, " wake_enabled");
71b58cbb	346	else
ed206fac	347	size += sprintf(buf + size, " disabled");
71b58cbb ZR	348
	349	end:
	350	size += sprintf(buf + size, "\n");
	351	return result ? result : size;
5229e87d LB	352	}
	353
	354	/*
	355	* counter_set() sets the specified counter.
	356	* setting the total "sci" file to any value clears all counters.
71b58cbb	357	* enable/disable/clear a gpe/fixed event in user space.
5229e87d LB	358	*/
	359	static ssize_t counter_set(struct kobject *kobj,
	360	struct kobj_attribute attr, const char buf, size_t size)
	361	{
	362	int index = attr - counter_attrs;
71b58cbb ZR	363	acpi_event_status status;
	364	acpi_handle handle;
	365	int result = 0;
5229e87d LB	366
	367	if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) {
	368	int i;
	369	for (i = 0; i < num_counters; ++i)
71b58cbb	370	all_counters[i].count = 0;
5229e87d LB	371	acpi_gpe_count = 0;
5229e87d LB	372	acpi_irq_handled = 0;
88bea188	373	acpi_irq_not_handled = 0;
71b58cbb ZR	374	goto end;
	375	}
	376
	377	/* show the event status for both GPEs and Fixed Events */
	378	result = get_status(index, &status, &handle);
	379	if (result)
	380	goto end;
	381
ed206fac	382	if (!(status & ACPI_EVENT_FLAG_HANDLE)) {
55ac9a01 LM	383	printk(KERN_WARNING PREFIX
55ac9a01 LM	384	"Can not change Invalid GPE/Fixed Event status\n");
71b58cbb ZR	385	return -EINVAL;
71b58cbb ZR	386	}
5229e87d	387
71b58cbb ZR	388	if (index < num_gpes) {
	389	if (!strcmp(buf, "disable\n") &&
	390	(status & ACPI_EVENT_FLAG_ENABLED))
9630bdd9	391	result = acpi_set_gpe(handle, index, ACPI_GPE_DISABLE);
71b58cbb ZR	392	else if (!strcmp(buf, "enable\n") &&
71b58cbb ZR	393	!(status & ACPI_EVENT_FLAG_ENABLED))
9630bdd9	394	result = acpi_set_gpe(handle, index, ACPI_GPE_ENABLE);
71b58cbb ZR	395	else if (!strcmp(buf, "clear\n") &&
	396	(status & ACPI_EVENT_FLAG_SET))
	397	result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR);
	398	else
	399	all_counters[index].count = strtoul(buf, NULL, 0);
	400	} else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
	401	int event = index - num_gpes;
	402	if (!strcmp(buf, "disable\n") &&
	403	(status & ACPI_EVENT_FLAG_ENABLED))
	404	result = acpi_disable_event(event, ACPI_NOT_ISR);
	405	else if (!strcmp(buf, "enable\n") &&
	406	!(status & ACPI_EVENT_FLAG_ENABLED))
	407	result = acpi_enable_event(event, ACPI_NOT_ISR);
	408	else if (!strcmp(buf, "clear\n") &&
	409	(status & ACPI_EVENT_FLAG_SET))
	410	result = acpi_clear_event(event);
	411	else
	412	all_counters[index].count = strtoul(buf, NULL, 0);
5229e87d	413	} else
71b58cbb	414	all_counters[index].count = strtoul(buf, NULL, 0);
5229e87d	415
71b58cbb ZR	416	if (ACPI_FAILURE(result))
	417	result = -EINVAL;
	418	end:
	419	return result ? result : size;
5229e87d LB	420	}
	421
	422	void acpi_irq_stats_init(void)
	423	{
	424	int i;
	425
	426	if (all_counters)
	427	return;
	428
e97d6bf1	429	num_gpes = acpi_current_gpe_count;
5229e87d LB	430	num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;
	431
	432	all_attrs = kzalloc(sizeof(struct attribute ) (num_counters + 1),
	433	GFP_KERNEL);
	434	if (all_attrs == NULL)
	435	return;
	436
71b58cbb ZR	437	all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
71b58cbb ZR	438	GFP_KERNEL);
5229e87d LB	439	if (all_counters == NULL)
	440	goto fail;
	441
	442	counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
	443	GFP_KERNEL);
	444	if (counter_attrs == NULL)
	445	goto fail;
	446
	447	for (i = 0; i < num_counters; ++i) {
c8dc9de1	448	char buffer[12];
5229e87d LB	449	char *name;
	450
	451	if (i < num_gpes)
	452	sprintf(buffer, "gpe%02X", i);
	453	else if (i == num_gpes + ACPI_EVENT_PMTIMER)
	454	sprintf(buffer, "ff_pmtimer");
	455	else if (i == num_gpes + ACPI_EVENT_GLOBAL)
	456	sprintf(buffer, "ff_gbl_lock");
	457	else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON)
	458	sprintf(buffer, "ff_pwr_btn");
	459	else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON)
	460	sprintf(buffer, "ff_slp_btn");
	461	else if (i == num_gpes + ACPI_EVENT_RTC)
	462	sprintf(buffer, "ff_rt_clk");
	463	else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE)
	464	sprintf(buffer, "gpe_all");
	465	else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI)
	466	sprintf(buffer, "sci");
88bea188 LB	467	else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT)
88bea188 LB	468	sprintf(buffer, "sci_not");
5229e87d LB	469	else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR)
	470	sprintf(buffer, "error");
	471	else
	472	sprintf(buffer, "bug%02X", i);
	473
	474	name = kzalloc(strlen(buffer) + 1, GFP_KERNEL);
	475	if (name == NULL)
	476	goto fail;
	477	strncpy(name, buffer, strlen(buffer) + 1);
	478
a07e4156	479	sysfs_attr_init(&counter_attrs[i].attr);
5229e87d LB	480	counter_attrs[i].attr.name = name;
	481	counter_attrs[i].attr.mode = 0644;
	482	counter_attrs[i].show = counter_show;
	483	counter_attrs[i].store = counter_set;
	484
	485	all_attrs[i] = &counter_attrs[i].attr;
	486	}
	487
	488	interrupt_stats_attr_group.attrs = all_attrs;
b7143156 LB	489	if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group))
b7143156 LB	490	return;
5229e87d LB	491
	492	fail:
	493	delete_gpe_attr_array();
	494	return;
	495	}
	496
	497	static void __exit interrupt_stats_exit(void)
	498	{
	499	sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group);
	500
	501	delete_gpe_attr_array();
	502
	503	return;
	504	}
	505
1da177e4 LT	506	/* --------------------------------------------------------------------------
	507	FS Interface (/proc)
	508	-------------------------------------------------------------------------- */
5bb730fd	509	#ifdef CONFIG_ACPI_PROCFS
d4c5f047 ZR	510	#define ACPI_SYSTEM_FILE_INFO "info"
	511	#define ACPI_SYSTEM_FILE_EVENT "event"
	512	#define ACPI_SYSTEM_FILE_DSDT "dsdt"
	513	#define ACPI_SYSTEM_FILE_FADT "fadt"
1da177e4	514
4be44fcd	515	static int acpi_system_read_info(struct seq_file seq, void offset)
1da177e4	516	{
1da177e4 LT	517
1da177e4 LT	518	seq_printf(seq, "version: %x\n", ACPI_CA_VERSION);
d550d98d	519	return 0;
1da177e4 LT	520	}
	521
	522	static int acpi_system_info_open_fs(struct inode inode, struct file file)
	523	{
	524	return single_open(file, acpi_system_read_info, PDE(inode)->data);
	525	}
	526
d7508032	527	static const struct file_operations acpi_system_info_ops = {
cf7acfab	528	.owner = THIS_MODULE,
4be44fcd LB	529	.open = acpi_system_info_open_fs,
	530	.read = seq_read,
	531	.llseek = seq_lseek,
	532	.release = single_release,
1da177e4 LT	533	};
1da177e4 LT	534
4be44fcd LB	535	static ssize_t acpi_system_read_dsdt(struct file , char __user , size_t,
4be44fcd LB	536	loff_t *);
1da177e4	537
d7508032	538	static const struct file_operations acpi_system_dsdt_ops = {
cf7acfab	539	.owner = THIS_MODULE,
4be44fcd	540	.read = acpi_system_read_dsdt,
1da177e4 LT	541	};
	542
	543	static ssize_t
4be44fcd LB	544	acpi_system_read_dsdt(struct file *file,
4be44fcd LB	545	char __user * buffer, size_t count, loff_t * ppos)
1da177e4	546	{
4be44fcd	547	acpi_status status = AE_OK;
ad71860a	548	struct acpi_table_header *dsdt = NULL;
4be44fcd	549	ssize_t res;
1da177e4	550
ad71860a	551	status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
1da177e4	552	if (ACPI_FAILURE(status))
d550d98d	553	return -ENODEV;
1da177e4	554
d4c5f047	555	res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
1da177e4	556
d550d98d	557	return res;
1da177e4 LT	558	}
1da177e4 LT	559
4be44fcd LB	560	static ssize_t acpi_system_read_fadt(struct file , char __user , size_t,
4be44fcd LB	561	loff_t *);
1da177e4	562
d7508032	563	static const struct file_operations acpi_system_fadt_ops = {
cf7acfab	564	.owner = THIS_MODULE,
4be44fcd	565	.read = acpi_system_read_fadt,
1da177e4 LT	566	};
	567
	568	static ssize_t
4be44fcd LB	569	acpi_system_read_fadt(struct file *file,
4be44fcd LB	570	char __user * buffer, size_t count, loff_t * ppos)
1da177e4	571	{
4be44fcd	572	acpi_status status = AE_OK;
ad71860a	573	struct acpi_table_header *fadt = NULL;
4be44fcd	574	ssize_t res;
1da177e4	575
ad71860a	576	status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
1da177e4	577	if (ACPI_FAILURE(status))
d550d98d	578	return -ENODEV;
1da177e4	579
d4c5f047	580	res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
1da177e4	581
d550d98d	582	return res;
1da177e4 LT	583	}
1da177e4 LT	584
d4c5f047	585	static int acpi_system_procfs_init(void)
1da177e4	586	{
4be44fcd	587	struct proc_dir_entry *entry;
1da177e4	588	int error = 0;
1da177e4	589
1da177e4	590	/* 'info' [R] */
cf7acfab DL	591	entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
cf7acfab DL	592	&acpi_system_info_ops);
1da177e4 LT	593	if (!entry)
1da177e4 LT	594	goto Error;
1da177e4 LT	595
1da177e4 LT	596	/* 'dsdt' [R] */
cf7acfab DL	597	entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
	598	&acpi_system_dsdt_ops);
	599	if (!entry)
1da177e4 LT	600	goto Error;
	601
	602	/* 'fadt' [R] */
cf7acfab DL	603	entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
	604	&acpi_system_fadt_ops);
	605	if (!entry)
1da177e4 LT	606	goto Error;
1da177e4 LT	607
4be44fcd	608	Done:
d550d98d	609	return error;
1da177e4	610
4be44fcd	611	Error:
1da177e4 LT	612	remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
	613	remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
	614	remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
	615
	616	error = -EFAULT;
	617	goto Done;
	618	}
d4c5f047 ZR	619	#else
	620	static int acpi_system_procfs_init(void)
	621	{
	622	return 0;
	623	}
	624	#endif
	625
141a0af3	626	int __init acpi_system_init(void)
d4c5f047	627	{
141a0af3	628	int result;
d4c5f047 ZR	629
	630	result = acpi_system_procfs_init();
	631	if (result)
	632	return result;
	633
	634	result = acpi_system_sysfs_init();
	635
	636	return result;
	637	}