Merge branch 'acpi-debug' (51834d6a) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/acpi/Kconfig

+14 −3

Original line number	Diff line number	Diff line
		@@ -58,14 +58,25 @@ config ACPI_CCA_REQUIRED
		bool

		config ACPI_DEBUGGER
		bool "AML debugger interface (EXPERIMENTAL)"
		bool "AML debugger interface"
		select ACPI_DEBUG
		help
		Enable in-kernel debugging of AML facilities: statistics, internal
		object dump, single step control method execution.
		Enable in-kernel debugging of AML facilities: statistics,
		internal object dump, single step control method execution.
		This is still under development, currently enabling this only
		results in the compilation of the ACPICA debugger files.

		if ACPI_DEBUGGER

		config ACPI_DEBUGGER_USER
		tristate "Userspace debugger accessiblity"
		depends on DEBUG_FS
		help
		Export /sys/kernel/debug/acpi/acpidbg for userspace utilities
		to access the debugger functionalities.

		endif

		config ACPI_SLEEP
		bool
		depends on SUSPEND \|\| HIBERNATION

drivers/acpi/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -79,6 +79,7 @@ obj-$(CONFIG_ACPI_EC_DEBUGFS) += ec_sys.o
		obj-$(CONFIG_ACPI_CUSTOM_METHOD)+= custom_method.o
		obj-$(CONFIG_ACPI_BGRT) += bgrt.o
		obj-$(CONFIG_ACPI_CPPC_LIB) += cppc_acpi.o
		obj-$(CONFIG_ACPI_DEBUGGER_USER) += acpi_dbg.o

		# processor has its own "processor." module_param namespace
		processor-y := processor_driver.o

drivers/acpi/acpi_dbg.c

0 → 100644

+804 −0

Original line number	Diff line number	Diff line
		/*
		* ACPI AML interfacing support
		*
		* Copyright (C) 2015, Intel Corporation
		* Authors: Lv Zheng <lv.zheng@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.
		*/

		/* #define DEBUG */
		#define pr_fmt(fmt) "ACPI : AML: " fmt

		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/wait.h>
		#include <linux/poll.h>
		#include <linux/sched.h>
		#include <linux/kthread.h>
		#include <linux/proc_fs.h>
		#include <linux/debugfs.h>
		#include <linux/circ_buf.h>
		#include <linux/acpi.h>
		#include "internal.h"

		#define ACPI_AML_BUF_ALIGN (sizeof (acpi_size))
		#define ACPI_AML_BUF_SIZE PAGE_SIZE

		#define circ_count(circ) \
		(CIRC_CNT((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
		#define circ_count_to_end(circ) \
		(CIRC_CNT_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
		#define circ_space(circ) \
		(CIRC_SPACE((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
		#define circ_space_to_end(circ) \
		(CIRC_SPACE_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))

		#define ACPI_AML_OPENED 0x0001
		#define ACPI_AML_CLOSED 0x0002
		#define ACPI_AML_IN_USER 0x0004 /* user space is writing cmd */
		#define ACPI_AML_IN_KERN 0x0008 /* kernel space is reading cmd */
		#define ACPI_AML_OUT_USER 0x0010 /* user space is reading log */
		#define ACPI_AML_OUT_KERN 0x0020 /* kernel space is writing log */
		#define ACPI_AML_USER (ACPI_AML_IN_USER \| ACPI_AML_OUT_USER)
		#define ACPI_AML_KERN (ACPI_AML_IN_KERN \| ACPI_AML_OUT_KERN)
		#define ACPI_AML_BUSY (ACPI_AML_USER \| ACPI_AML_KERN)
		#define ACPI_AML_OPEN (ACPI_AML_OPENED \| ACPI_AML_CLOSED)

		struct acpi_aml_io {
		wait_queue_head_t wait;
		unsigned long flags;
		unsigned long users;
		struct mutex lock;
		struct task_struct *thread;
		char out_buf[ACPI_AML_BUF_SIZE] __aligned(ACPI_AML_BUF_ALIGN);
		struct circ_buf out_crc;
		char in_buf[ACPI_AML_BUF_SIZE] __aligned(ACPI_AML_BUF_ALIGN);
		struct circ_buf in_crc;
		acpi_osd_exec_callback function;
		void *context;
		unsigned long usages;
		};

		static struct acpi_aml_io acpi_aml_io;
		static bool acpi_aml_initialized;
		static struct file *acpi_aml_active_reader;
		static struct dentry *acpi_aml_dentry;

		static inline bool __acpi_aml_running(void)
		{
		return acpi_aml_io.thread ? true : false;
		}

		static inline bool __acpi_aml_access_ok(unsigned long flag)
		{
		/*
		* The debugger interface is in opened state (OPENED && !CLOSED),
		* then it is allowed to access the debugger buffers from either
		* user space or the kernel space.
		* In addition, for the kernel space, only the debugger thread
		* (thread ID matched) is allowed to access.
		*/
		if (!(acpi_aml_io.flags & ACPI_AML_OPENED) \|\|
		(acpi_aml_io.flags & ACPI_AML_CLOSED) \|\|
		!__acpi_aml_running())
		return false;
		if ((flag & ACPI_AML_KERN) &&
		current != acpi_aml_io.thread)
		return false;
		return true;
		}

		static inline bool __acpi_aml_readable(struct circ_buf *circ, unsigned long flag)
		{
		/*
		* Another read is not in progress and there is data in buffer
		* available for read.
		*/
		if (!(acpi_aml_io.flags & flag) && circ_count(circ))
		return true;
		return false;
		}

		static inline bool __acpi_aml_writable(struct circ_buf *circ, unsigned long flag)
		{
		/*
		* Another write is not in progress and there is buffer space
		* available for write.
		*/
		if (!(acpi_aml_io.flags & flag) && circ_space(circ))
		return true;
		return false;
		}

		static inline bool __acpi_aml_busy(void)
		{
		if (acpi_aml_io.flags & ACPI_AML_BUSY)
		return true;
		return false;
		}

		static inline bool __acpi_aml_opened(void)
		{
		if (acpi_aml_io.flags & ACPI_AML_OPEN)
		return true;
		return false;
		}

		static inline bool __acpi_aml_used(void)
		{
		return acpi_aml_io.usages ? true : false;
		}

		static inline bool acpi_aml_running(void)
		{
		bool ret;

		mutex_lock(&acpi_aml_io.lock);
		ret = __acpi_aml_running();
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static bool acpi_aml_busy(void)
		{
		bool ret;

		mutex_lock(&acpi_aml_io.lock);
		ret = __acpi_aml_busy();
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static bool acpi_aml_used(void)
		{
		bool ret;

		/*
		* The usage count is prepared to avoid race conditions between the
		* starts and the stops of the debugger thread.
		*/
		mutex_lock(&acpi_aml_io.lock);
		ret = __acpi_aml_used();
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static bool acpi_aml_kern_readable(void)
		{
		bool ret;

		mutex_lock(&acpi_aml_io.lock);
		ret = !__acpi_aml_access_ok(ACPI_AML_IN_KERN) \|\|
		__acpi_aml_readable(&acpi_aml_io.in_crc, ACPI_AML_IN_KERN);
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static bool acpi_aml_kern_writable(void)
		{
		bool ret;

		mutex_lock(&acpi_aml_io.lock);
		ret = !__acpi_aml_access_ok(ACPI_AML_OUT_KERN) \|\|
		__acpi_aml_writable(&acpi_aml_io.out_crc, ACPI_AML_OUT_KERN);
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static bool acpi_aml_user_readable(void)
		{
		bool ret;

		mutex_lock(&acpi_aml_io.lock);
		ret = !__acpi_aml_access_ok(ACPI_AML_OUT_USER) \|\|
		__acpi_aml_readable(&acpi_aml_io.out_crc, ACPI_AML_OUT_USER);
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static bool acpi_aml_user_writable(void)
		{
		bool ret;

		mutex_lock(&acpi_aml_io.lock);
		ret = !__acpi_aml_access_ok(ACPI_AML_IN_USER) \|\|
		__acpi_aml_writable(&acpi_aml_io.in_crc, ACPI_AML_IN_USER);
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static int acpi_aml_lock_write(struct circ_buf *circ, unsigned long flag)
		{
		int ret = 0;

		mutex_lock(&acpi_aml_io.lock);
		if (!__acpi_aml_access_ok(flag)) {
		ret = -EFAULT;
		goto out;
		}
		if (!__acpi_aml_writable(circ, flag)) {
		ret = -EAGAIN;
		goto out;
		}
		acpi_aml_io.flags \|= flag;
		out:
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static int acpi_aml_lock_read(struct circ_buf *circ, unsigned long flag)
		{
		int ret = 0;

		mutex_lock(&acpi_aml_io.lock);
		if (!__acpi_aml_access_ok(flag)) {
		ret = -EFAULT;
		goto out;
		}
		if (!__acpi_aml_readable(circ, flag)) {
		ret = -EAGAIN;
		goto out;
		}
		acpi_aml_io.flags \|= flag;
		out:
		mutex_unlock(&acpi_aml_io.lock);
		return ret;
		}

		static void acpi_aml_unlock_fifo(unsigned long flag, bool wakeup)
		{
		mutex_lock(&acpi_aml_io.lock);
		acpi_aml_io.flags &= ~flag;
		if (wakeup)
		wake_up_interruptible(&acpi_aml_io.wait);
		mutex_unlock(&acpi_aml_io.lock);
		}

		static int acpi_aml_write_kern(const char *buf, int len)
		{
		int ret;
		struct circ_buf *crc = &acpi_aml_io.out_crc;
		int n;
		char *p;

		ret = acpi_aml_lock_write(crc, ACPI_AML_OUT_KERN);
		if (IS_ERR_VALUE(ret))
		return ret;
		/* sync tail before inserting logs */
		smp_mb();
		p = &crc->buf[crc->head];
		n = min(len, circ_space_to_end(crc));
		memcpy(p, buf, n);
		/* sync head after inserting logs */
		smp_wmb();
		crc->head = (crc->head + n) & (ACPI_AML_BUF_SIZE - 1);
		acpi_aml_unlock_fifo(ACPI_AML_OUT_KERN, true);
		return n;
		}

		static int acpi_aml_readb_kern(void)
		{
		int ret;
		struct circ_buf *crc = &acpi_aml_io.in_crc;
		char *p;

		ret = acpi_aml_lock_read(crc, ACPI_AML_IN_KERN);
		if (IS_ERR_VALUE(ret))
		return ret;
		/* sync head before removing cmds */
		smp_rmb();
		p = &crc->buf[crc->tail];
		ret = (int)*p;
		/* sync tail before inserting cmds */
		smp_mb();
		crc->tail = (crc->tail + 1) & (ACPI_AML_BUF_SIZE - 1);
		acpi_aml_unlock_fifo(ACPI_AML_IN_KERN, true);
		return ret;
		}

		/*
		* acpi_aml_write_log() - Capture debugger output
		* @msg: the debugger output
		*
		* This function should be used to implement acpi_os_printf() to filter out
		* the debugger output and store the output into the debugger interface
		* buffer. Return the size of stored logs or errno.
		*/
		static ssize_t acpi_aml_write_log(const char *msg)
		{
		int ret = 0;
		int count = 0, size = 0;

		if (!acpi_aml_initialized)
		return -ENODEV;
		if (msg)
		count = strlen(msg);
		while (count > 0) {
		again:
		ret = acpi_aml_write_kern(msg + size, count);
		if (ret == -EAGAIN) {
		ret = wait_event_interruptible(acpi_aml_io.wait,
		acpi_aml_kern_writable());
		/*
		* We need to retry when the condition
		* becomes true.
		*/
		if (ret == 0)
		goto again;
		break;
		}
		if (IS_ERR_VALUE(ret))
		break;
		size += ret;
		count -= ret;
		}
		return size > 0 ? size : ret;
		}

		/*
		* acpi_aml_read_cmd() - Capture debugger input
		* @msg: the debugger input
		* @size: the size of the debugger input
		*
		* This function should be used to implement acpi_os_get_line() to capture
		* the debugger input commands and store the input commands into the
		* debugger interface buffer. Return the size of stored commands or errno.
		*/
		static ssize_t acpi_aml_read_cmd(char *msg, size_t count)
		{
		int ret = 0;
		int size = 0;

		/*
		* This is ensured by the running fact of the debugger thread
		* unless a bug is introduced.
		*/
		BUG_ON(!acpi_aml_initialized);
		while (count > 0) {
		again:
		/*
		* Check each input byte to find the end of the command.
		*/
		ret = acpi_aml_readb_kern();
		if (ret == -EAGAIN) {
		ret = wait_event_interruptible(acpi_aml_io.wait,
		acpi_aml_kern_readable());
		/*
		* We need to retry when the condition becomes
		* true.
		*/
		if (ret == 0)
		goto again;
		}
		if (IS_ERR_VALUE(ret))
		break;
		*(msg + size) = (char)ret;
		size++;
		count--;
		if (ret == '\n') {
		/*
		* acpi_os_get_line() requires a zero terminated command
		* string.
		*/
		*(msg + size - 1) = '\0';
		break;
		}
		}
		return size > 0 ? size : ret;
		}

		static int acpi_aml_thread(void *unsed)
		{
		acpi_osd_exec_callback function = NULL;
		void *context;

		mutex_lock(&acpi_aml_io.lock);
		if (acpi_aml_io.function) {
		acpi_aml_io.usages++;
		function = acpi_aml_io.function;
		context = acpi_aml_io.context;
		}
		mutex_unlock(&acpi_aml_io.lock);

		if (function)
		function(context);

		mutex_lock(&acpi_aml_io.lock);
		acpi_aml_io.usages--;
		if (!__acpi_aml_used()) {
		acpi_aml_io.thread = NULL;
		wake_up(&acpi_aml_io.wait);
		}
		mutex_unlock(&acpi_aml_io.lock);

		return 0;
		}

		/*
		* acpi_aml_create_thread() - Create AML debugger thread
		* @function: the debugger thread callback
		* @context: the context to be passed to the debugger thread
		*
		* This function should be used to implement acpi_os_execute() which is
		* used by the ACPICA debugger to create the debugger thread.
		*/
		static int acpi_aml_create_thread(acpi_osd_exec_callback function, void *context)
		{
		struct task_struct *t;

		mutex_lock(&acpi_aml_io.lock);
		acpi_aml_io.function = function;
		acpi_aml_io.context = context;
		mutex_unlock(&acpi_aml_io.lock);

		t = kthread_create(acpi_aml_thread, NULL, "aml");
		if (IS_ERR(t)) {
		pr_err("Failed to create AML debugger thread.\n");
		return PTR_ERR(t);
		}

		mutex_lock(&acpi_aml_io.lock);
		acpi_aml_io.thread = t;
		acpi_set_debugger_thread_id((acpi_thread_id)(unsigned long)t);
		wake_up_process(t);
		mutex_unlock(&acpi_aml_io.lock);
		return 0;
		}

		static int acpi_aml_wait_command_ready(bool single_step,
		char *buffer, size_t length)
		{
		acpi_status status;

		if (single_step)
		acpi_os_printf("\n%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT);
		else
		acpi_os_printf("\n%1c ", ACPI_DEBUGGER_COMMAND_PROMPT);

		status = acpi_os_get_line(buffer, length, NULL);
		if (ACPI_FAILURE(status))
		return -EINVAL;
		return 0;
		}

		static int acpi_aml_notify_command_complete(void)
		{
		return 0;
		}

		static int acpi_aml_open(struct inode inode, struct file file)
		{
		int ret = 0;
		acpi_status status;

		mutex_lock(&acpi_aml_io.lock);
		/*
		* The debugger interface is being closed, no new user is allowed
		* during this period.
		*/
		if (acpi_aml_io.flags & ACPI_AML_CLOSED) {
		ret = -EBUSY;
		goto err_lock;
		}
		if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
		/*
		* Only one reader is allowed to initiate the debugger
		* thread.
		*/
		if (acpi_aml_active_reader) {
		ret = -EBUSY;
		goto err_lock;
		} else {
		pr_debug("Opening debugger reader.\n");
		acpi_aml_active_reader = file;
		}
		} else {
		/*
		* No writer is allowed unless the debugger thread is
		* ready.
		*/
		if (!(acpi_aml_io.flags & ACPI_AML_OPENED)) {
		ret = -ENODEV;
		goto err_lock;
		}
		}
		if (acpi_aml_active_reader == file) {
		pr_debug("Opening debugger interface.\n");
		mutex_unlock(&acpi_aml_io.lock);

		pr_debug("Initializing debugger thread.\n");
		status = acpi_initialize_debugger();
		if (ACPI_FAILURE(status)) {
		pr_err("Failed to initialize debugger.\n");
		ret = -EINVAL;
		goto err_exit;
		}
		pr_debug("Debugger thread initialized.\n");

		mutex_lock(&acpi_aml_io.lock);
		acpi_aml_io.flags \|= ACPI_AML_OPENED;
		acpi_aml_io.out_crc.head = acpi_aml_io.out_crc.tail = 0;
		acpi_aml_io.in_crc.head = acpi_aml_io.in_crc.tail = 0;
		pr_debug("Debugger interface opened.\n");
		}
		acpi_aml_io.users++;
		err_lock:
		if (IS_ERR_VALUE(ret)) {
		if (acpi_aml_active_reader == file)
		acpi_aml_active_reader = NULL;
		}
		mutex_unlock(&acpi_aml_io.lock);
		err_exit:
		return ret;
		}

		static int acpi_aml_release(struct inode inode, struct file file)
		{
		mutex_lock(&acpi_aml_io.lock);
		acpi_aml_io.users--;
		if (file == acpi_aml_active_reader) {
		pr_debug("Closing debugger reader.\n");
		acpi_aml_active_reader = NULL;

		pr_debug("Closing debugger interface.\n");
		acpi_aml_io.flags \|= ACPI_AML_CLOSED;

		/*
		* Wake up all user space/kernel space blocked
		* readers/writers.
		*/
		wake_up_interruptible(&acpi_aml_io.wait);
		mutex_unlock(&acpi_aml_io.lock);
		/*
		* Wait all user space/kernel space readers/writers to
		* stop so that ACPICA command loop of the debugger thread
		* should fail all its command line reads after this point.
		*/
		wait_event(acpi_aml_io.wait, !acpi_aml_busy());

		/*
		* Then we try to terminate the debugger thread if it is
		* not terminated.
		*/
		pr_debug("Terminating debugger thread.\n");
		acpi_terminate_debugger();
		wait_event(acpi_aml_io.wait, !acpi_aml_used());
		pr_debug("Debugger thread terminated.\n");

		mutex_lock(&acpi_aml_io.lock);
		acpi_aml_io.flags &= ~ACPI_AML_OPENED;
		}
		if (acpi_aml_io.users == 0) {
		pr_debug("Debugger interface closed.\n");
		acpi_aml_io.flags &= ~ACPI_AML_CLOSED;
		}
		mutex_unlock(&acpi_aml_io.lock);
		return 0;
		}

		static int acpi_aml_read_user(char __user *buf, int len)
		{
		int ret;
		struct circ_buf *crc = &acpi_aml_io.out_crc;
		int n;
		char *p;

		ret = acpi_aml_lock_read(crc, ACPI_AML_OUT_USER);
		if (IS_ERR_VALUE(ret))
		return ret;
		/* sync head before removing logs */
		smp_rmb();
		p = &crc->buf[crc->tail];
		n = min(len, circ_count_to_end(crc));
		if (copy_to_user(buf, p, n)) {
		ret = -EFAULT;
		goto out;
		}
		/* sync tail after removing logs */
		smp_mb();
		crc->tail = (crc->tail + n) & (ACPI_AML_BUF_SIZE - 1);
		ret = n;
		out:
		acpi_aml_unlock_fifo(ACPI_AML_OUT_USER, !IS_ERR_VALUE(ret));
		return ret;
		}

		static ssize_t acpi_aml_read(struct file file, char __user buf,
		size_t count, loff_t *ppos)
		{
		int ret = 0;
		int size = 0;

		if (!count)
		return 0;
		if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT;

		while (count > 0) {
		again:
		ret = acpi_aml_read_user(buf + size, count);
		if (ret == -EAGAIN) {
		if (file->f_flags & O_NONBLOCK)
		break;
		else {
		ret = wait_event_interruptible(acpi_aml_io.wait,
		acpi_aml_user_readable());
		/*
		* We need to retry when the condition
		* becomes true.
		*/
		if (ret == 0)
		goto again;
		}
		}
		if (IS_ERR_VALUE(ret)) {
		if (!acpi_aml_running())
		ret = 0;
		break;
		}
		if (ret) {
		size += ret;
		count -= ret;
		*ppos += ret;
		break;
		}
		}
		return size > 0 ? size : ret;
		}

		static int acpi_aml_write_user(const char __user *buf, int len)
		{
		int ret;
		struct circ_buf *crc = &acpi_aml_io.in_crc;
		int n;
		char *p;

		ret = acpi_aml_lock_write(crc, ACPI_AML_IN_USER);
		if (IS_ERR_VALUE(ret))
		return ret;
		/* sync tail before inserting cmds */
		smp_mb();
		p = &crc->buf[crc->head];
		n = min(len, circ_space_to_end(crc));
		if (copy_from_user(p, buf, n)) {
		ret = -EFAULT;
		goto out;
		}
		/* sync head after inserting cmds */
		smp_wmb();
		crc->head = (crc->head + n) & (ACPI_AML_BUF_SIZE - 1);
		ret = n;
		out:
		acpi_aml_unlock_fifo(ACPI_AML_IN_USER, !IS_ERR_VALUE(ret));
		return n;
		}

		static ssize_t acpi_aml_write(struct file file, const char __user buf,
		size_t count, loff_t *ppos)
		{
		int ret = 0;
		int size = 0;

		if (!count)
		return 0;
		if (!access_ok(VERIFY_READ, buf, count))
		return -EFAULT;

		while (count > 0) {
		again:
		ret = acpi_aml_write_user(buf + size, count);
		if (ret == -EAGAIN) {
		if (file->f_flags & O_NONBLOCK)
		break;
		else {
		ret = wait_event_interruptible(acpi_aml_io.wait,
		acpi_aml_user_writable());
		/*
		* We need to retry when the condition
		* becomes true.
		*/
		if (ret == 0)
		goto again;
		}
		}
		if (IS_ERR_VALUE(ret)) {
		if (!acpi_aml_running())
		ret = 0;
		break;
		}
		if (ret) {
		size += ret;
		count -= ret;
		*ppos += ret;
		}
		}
		return size > 0 ? size : ret;
		}

		static unsigned int acpi_aml_poll(struct file file, poll_table wait)
		{
		int masks = 0;

		poll_wait(file, &acpi_aml_io.wait, wait);
		if (acpi_aml_user_readable())
		masks \|= POLLIN \| POLLRDNORM;
		if (acpi_aml_user_writable())
		masks \|= POLLOUT \| POLLWRNORM;

		return masks;
		}

		static const struct file_operations acpi_aml_operations = {
		.read = acpi_aml_read,
		.write = acpi_aml_write,
		.poll = acpi_aml_poll,
		.open = acpi_aml_open,
		.release = acpi_aml_release,
		.llseek = generic_file_llseek,
		};

		static const struct acpi_debugger_ops acpi_aml_debugger = {
		.create_thread = acpi_aml_create_thread,
		.read_cmd = acpi_aml_read_cmd,
		.write_log = acpi_aml_write_log,
		.wait_command_ready = acpi_aml_wait_command_ready,
		.notify_command_complete = acpi_aml_notify_command_complete,
		};

		int __init acpi_aml_init(void)
		{
		int ret = 0;

		if (!acpi_debugfs_dir) {
		ret = -ENOENT;
		goto err_exit;
		}

		/* Initialize AML IO interface */
		mutex_init(&acpi_aml_io.lock);
		init_waitqueue_head(&acpi_aml_io.wait);
		acpi_aml_io.out_crc.buf = acpi_aml_io.out_buf;
		acpi_aml_io.in_crc.buf = acpi_aml_io.in_buf;
		acpi_aml_dentry = debugfs_create_file("acpidbg",
		S_IFREG \| S_IRUGO \| S_IWUSR,
		acpi_debugfs_dir, NULL,
		&acpi_aml_operations);
		if (acpi_aml_dentry == NULL) {
		ret = -ENODEV;
		goto err_exit;
		}
		ret = acpi_register_debugger(THIS_MODULE, &acpi_aml_debugger);
		if (ret)
		goto err_fs;
		acpi_aml_initialized = true;

		err_fs:
		if (ret) {
		debugfs_remove(acpi_aml_dentry);
		acpi_aml_dentry = NULL;
		}
		err_exit:
		return ret;
		}

		void __exit acpi_aml_exit(void)
		{
		if (acpi_aml_initialized) {
		acpi_unregister_debugger(&acpi_aml_debugger);
		if (acpi_aml_dentry) {
		debugfs_remove(acpi_aml_dentry);
		acpi_aml_dentry = NULL;
		}
		acpi_aml_initialized = false;
		}
		}

		module_init(acpi_aml_init);
		module_exit(acpi_aml_exit);

		MODULE_AUTHOR("Lv Zheng");
		MODULE_DESCRIPTION("ACPI debugger userspace IO driver");
		MODULE_LICENSE("GPL");

drivers/acpi/acpica/acdebug.h

+25 −11

Original line number	Diff line number	Diff line
		@@ -80,9 +80,15 @@ struct acpi_db_execute_walk {
		/*
		* dbxface - external debugger interfaces
		*/
		acpi_status
		acpi_db_single_step(struct acpi_walk_state *walk_state,
		union acpi_parse_object *op, u32 op_type);
		ACPI_DBR_DEPENDENT_RETURN_OK(acpi_status
		acpi_db_single_step(struct acpi_walk_state
		*walk_state,
		union acpi_parse_object *op,
		u32 op_type))
		ACPI_DBR_DEPENDENT_RETURN_VOID(void
		acpi_db_signal_break_point(struct
		acpi_walk_state
		*walk_state))

		/*
		* dbcmds - debug commands and output routines
		@@ -182,9 +188,13 @@ void acpi_db_display_method_info(union acpi_parse_object *op);

		void acpi_db_decode_and_display_object(char target, char output_type);

		void
		acpi_db_display_result_object(union acpi_operand_object *obj_desc,
		struct acpi_walk_state *walk_state);
		ACPI_DBR_DEPENDENT_RETURN_VOID(void
		acpi_db_display_result_object(union
		acpi_operand_object
		*obj_desc,
		struct
		acpi_walk_state
		*walk_state))

		acpi_status acpi_db_display_all_methods(char *display_count_arg);

		@@ -198,9 +208,13 @@ void acpi_db_display_calling_tree(void);

		void acpi_db_display_object_type(char *object_arg);

		void
		acpi_db_display_argument_object(union acpi_operand_object *obj_desc,
		struct acpi_walk_state *walk_state);
		ACPI_DBR_DEPENDENT_RETURN_VOID(void
		acpi_db_display_argument_object(union
		acpi_operand_object
		*obj_desc,
		struct
		acpi_walk_state
		*walk_state))

		/*
		* dbexec - debugger control method execution
		@@ -257,7 +271,7 @@ acpi_db_command_dispatch(char *input_buffer,

		void ACPI_SYSTEM_XFACE acpi_db_execute_thread(void *context);

		acpi_status acpi_db_user_commands(char prompt, union acpi_parse_object *op);
		acpi_status acpi_db_user_commands(void);

		char acpi_db_get_next_token(char string,
		char *next, acpi_object_type return_type);

drivers/acpi/acpica/acglobal.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -326,7 +326,6 @@ ACPI_GLOBAL(struct acpi_external_file *, acpi_gbl_external_file_list);
		#ifdef ACPI_DEBUGGER

		ACPI_INIT_GLOBAL(u8, acpi_gbl_abort_method, FALSE);
		ACPI_INIT_GLOBAL(u8, acpi_gbl_method_executing, FALSE);
		ACPI_INIT_GLOBAL(acpi_thread_id, acpi_gbl_db_thread_id, ACPI_INVALID_THREAD_ID);

		ACPI_GLOBAL(u8, acpi_gbl_db_opt_no_ini_methods);
		@@ -345,7 +344,6 @@ ACPI_GLOBAL(acpi_object_type, acpi_gbl_db_arg_types[ACPI_DEBUGGER_MAX_ARGS]);

		/* These buffers should all be the same size */

		ACPI_GLOBAL(char, acpi_gbl_db_line_buf[ACPI_DB_LINE_BUFFER_SIZE]);
		ACPI_GLOBAL(char, acpi_gbl_db_parsed_buf[ACPI_DB_LINE_BUFFER_SIZE]);
		ACPI_GLOBAL(char, acpi_gbl_db_scope_buf[ACPI_DB_LINE_BUFFER_SIZE]);
		ACPI_GLOBAL(char, acpi_gbl_db_debug_filename[ACPI_DB_LINE_BUFFER_SIZE]);
		@@ -360,9 +358,6 @@ ACPI_GLOBAL(u16, acpi_gbl_node_type_count_misc);
		ACPI_GLOBAL(u32, acpi_gbl_num_nodes);
		ACPI_GLOBAL(u32, acpi_gbl_num_objects);

		ACPI_GLOBAL(acpi_mutex, acpi_gbl_db_command_ready);
		ACPI_GLOBAL(acpi_mutex, acpi_gbl_db_command_complete);

		#endif /* ACPI_DEBUGGER */

		/*****************************************************************************