[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / powerpc / sysdev / pmi.c

/*
 * pmi driver
 *
 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
 *
 * PMI (Platform Management Interrupt) is a way to communicate
 * with the BMC (Baseboard Management Controller) via interrupts.
 * Unlike IPMI it is bidirectional and has a low latency.
 *
 * Author: Christian Krafft <krafft@de.ibm.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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/completion.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/workqueue.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>

#include <asm/io.h>
#include <asm/pmi.h>
#include <asm/prom.h>

struct pmi_data {
	struct list_head	handler;
	spinlock_t		handler_spinlock;
	spinlock_t		pmi_spinlock;
	struct mutex		msg_mutex;
	pmi_message_t		msg;
	struct completion	*completion;
	struct platform_device	*dev;
	int			irq;
	u8 __iomem		*pmi_reg;
	struct work_struct	work;
};

static struct pmi_data *data;

static irqreturn_t pmi_irq_handler(int irq, void *dev_id)
{
	u8 type;
	int rc;

	spin_lock(&data->pmi_spinlock);

	type = ioread8(data->pmi_reg + PMI_READ_TYPE);
	pr_debug("pmi: got message of type %d\n", type);

	if (type & PMI_ACK && !data->completion) {
		printk(KERN_WARNING "pmi: got unexpected ACK message.\n");
		rc = -EIO;
		goto unlock;
	}

	if (data->completion && !(type & PMI_ACK)) {
		printk(KERN_WARNING "pmi: expected ACK, but got %d\n", type);
		rc = -EIO;
		goto unlock;
	}

	data->msg.type = type;
	data->msg.data0 = ioread8(data->pmi_reg + PMI_READ_DATA0);
	data->msg.data1 = ioread8(data->pmi_reg + PMI_READ_DATA1);
	data->msg.data2 = ioread8(data->pmi_reg + PMI_READ_DATA2);
	rc = 0;
unlock:
	spin_unlock(&data->pmi_spinlock);

	if (rc == -EIO) {
		rc = IRQ_HANDLED;
		goto out;
	}

	if (data->msg.type & PMI_ACK) {
		complete(data->completion);
		rc = IRQ_HANDLED;
		goto out;
	}

	schedule_work(&data->work);

	rc = IRQ_HANDLED;
out:
	return rc;
}


static struct of_device_id pmi_match[] = {
	{ .type = "ibm,pmi", .name = "ibm,pmi" },
	{ .type = "ibm,pmi" },
	{},
};

MODULE_DEVICE_TABLE(of, pmi_match);

static void pmi_notify_handlers(struct work_struct *work)
{
	struct pmi_handler *handler;

	spin_lock(&data->handler_spinlock);
	list_for_each_entry(handler, &data->handler, node) {
		pr_debug("pmi: notifying handler %p\n", handler);
		if (handler->type == data->msg.type)
			handler->handle_pmi_message(data->msg);
	}
	spin_unlock(&data->handler_spinlock);
}

static int pmi_of_probe(struct platform_device *dev)
{
	struct device_node *np = dev->dev.of_node;
	int rc;

	if (data) {
		printk(KERN_ERR "pmi: driver has already been initialized.\n");
		rc = -EBUSY;
		goto out;
	}

	data = kzalloc(sizeof(struct pmi_data), GFP_KERNEL);
	if (!data) {
		printk(KERN_ERR "pmi: could not allocate memory.\n");
		rc = -ENOMEM;
		goto out;
	}

	data->pmi_reg = of_iomap(np, 0);
	if (!data->pmi_reg) {
		printk(KERN_ERR "pmi: invalid register address.\n");
		rc = -EFAULT;
		goto error_cleanup_data;
	}

	INIT_LIST_HEAD(&data->handler);

	mutex_init(&data->msg_mutex);
	spin_lock_init(&data->pmi_spinlock);
	spin_lock_init(&data->handler_spinlock);

	INIT_WORK(&data->work, pmi_notify_handlers);

	data->dev = dev;

	data->irq = irq_of_parse_and_map(np, 0);
	if (data->irq == NO_IRQ) {
		printk(KERN_ERR "pmi: invalid interrupt.\n");
		rc = -EFAULT;
		goto error_cleanup_iomap;
	}

	rc = request_irq(data->irq, pmi_irq_handler, 0, "pmi", NULL);
	if (rc) {
		printk(KERN_ERR "pmi: can't request IRQ %d: returned %d\n",
				data->irq, rc);
		goto error_cleanup_iomap;
	}

	printk(KERN_INFO "pmi: found pmi device at addr %p.\n", data->pmi_reg);

	goto out;

error_cleanup_iomap:
	iounmap(data->pmi_reg);

error_cleanup_data:
	kfree(data);

out:
	return rc;
}

static int pmi_of_remove(struct platform_device *dev)
{
	struct pmi_handler *handler, *tmp;

	free_irq(data->irq, NULL);
	iounmap(data->pmi_reg);

	spin_lock(&data->handler_spinlock);

	list_for_each_entry_safe(handler, tmp, &data->handler, node)
		list_del(&handler->node);

	spin_unlock(&data->handler_spinlock);

	kfree(data);
	data = NULL;

	return 0;
}

static struct platform_driver pmi_of_platform_driver = {
	.probe		= pmi_of_probe,
	.remove		= pmi_of_remove,
	.driver = {
		.name = "pmi",
		.owner = THIS_MODULE,
		.of_match_table = pmi_match,
	},
};
module_platform_driver(pmi_of_platform_driver);

int pmi_send_message(pmi_message_t msg)
{
	unsigned long flags;
	DECLARE_COMPLETION_ONSTACK(completion);

	if (!data)
		return -ENODEV;

	mutex_lock(&data->msg_mutex);

	data->msg = msg;
	pr_debug("pmi_send_message: msg is %08x\n", *(u32*)&msg);

	data->completion = &completion;

	spin_lock_irqsave(&data->pmi_spinlock, flags);
	iowrite8(msg.data0, data->pmi_reg + PMI_WRITE_DATA0);
	iowrite8(msg.data1, data->pmi_reg + PMI_WRITE_DATA1);
	iowrite8(msg.data2, data->pmi_reg + PMI_WRITE_DATA2);
	iowrite8(msg.type, data->pmi_reg + PMI_WRITE_TYPE);
	spin_unlock_irqrestore(&data->pmi_spinlock, flags);

	pr_debug("pmi_send_message: wait for completion\n");

	wait_for_completion_interruptible_timeout(data->completion,
						  PMI_TIMEOUT);

	data->completion = NULL;

	mutex_unlock(&data->msg_mutex);

	return 0;
}
EXPORT_SYMBOL_GPL(pmi_send_message);

int pmi_register_handler(struct pmi_handler *handler)
{
	if (!data)
		return -ENODEV;

	spin_lock(&data->handler_spinlock);
	list_add_tail(&handler->node, &data->handler);
	spin_unlock(&data->handler_spinlock);

	return 0;
}
EXPORT_SYMBOL_GPL(pmi_register_handler);

void pmi_unregister_handler(struct pmi_handler *handler)
{
	if (!data)
		return;

	pr_debug("pmi: unregistering handler %p\n", handler);

	spin_lock(&data->handler_spinlock);
	list_del(&handler->node);
	spin_unlock(&data->handler_spinlock);
}
EXPORT_SYMBOL_GPL(pmi_unregister_handler);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
MODULE_DESCRIPTION("IBM Platform Management Interrupt driver");
Commit	Line	Data
0e826643 CK	1	/*
	2	* pmi driver
	3	*
	4	* (C) Copyright IBM Deutschland Entwicklung GmbH 2005
	5	*
	6	* PMI (Platform Management Interrupt) is a way to communicate
	7	* with the BMC (Baseboard Management Controller) via interrupts.
	8	* Unlike IPMI it is bidirectional and has a low latency.
	9	*
	10	* Author: Christian Krafft <krafft@de.ibm.com>
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2, or (at your option)
	15	* any later version.
	16	*
	17	* This program is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with this program; if not, write to the Free Software
	24	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	25	*/
	26
	27	#include <linux/interrupt.h>
5a0e3ad6	28	#include <linux/slab.h>
0e826643 CK	29	#include <linux/completion.h>
0e826643 CK	30	#include <linux/spinlock.h>
7dfe293c	31	#include <linux/module.h>
0e826643	32	#include <linux/workqueue.h>
eb8f2763 JL	33	#include <linux/of_device.h>
eb8f2763 JL	34	#include <linux/of_platform.h>
0e826643	35
0e826643 CK	36	#include <asm/io.h>
0e826643 CK	37	#include <asm/pmi.h>
6bf05fd7	38	#include <asm/prom.h>
0e826643 CK	39
	40	struct pmi_data {
	41	struct list_head handler;
	42	spinlock_t handler_spinlock;
	43	spinlock_t pmi_spinlock;
	44	struct mutex msg_mutex;
	45	pmi_message_t msg;
	46	struct completion *completion;
a454dc50	47	struct platform_device *dev;
0e826643 CK	48	int irq;
	49	u8 __iomem *pmi_reg;
	50	struct work_struct work;
	51	};
	52
813f9072	53	static struct pmi_data *data;
0e826643	54
fb247449	55	static irqreturn_t pmi_irq_handler(int irq, void *dev_id)
0e826643	56	{
0e826643 CK	57	u8 type;
	58	int rc;
	59
0e826643 CK	60	spin_lock(&data->pmi_spinlock);
	61
	62	type = ioread8(data->pmi_reg + PMI_READ_TYPE);
	63	pr_debug("pmi: got message of type %d\n", type);
	64
	65	if (type & PMI_ACK && !data->completion) {
	66	printk(KERN_WARNING "pmi: got unexpected ACK message.\n");
	67	rc = -EIO;
	68	goto unlock;
	69	}
	70
	71	if (data->completion && !(type & PMI_ACK)) {
	72	printk(KERN_WARNING "pmi: expected ACK, but got %d\n", type);
	73	rc = -EIO;
	74	goto unlock;
	75	}
	76
	77	data->msg.type = type;
	78	data->msg.data0 = ioread8(data->pmi_reg + PMI_READ_DATA0);
	79	data->msg.data1 = ioread8(data->pmi_reg + PMI_READ_DATA1);
	80	data->msg.data2 = ioread8(data->pmi_reg + PMI_READ_DATA2);
	81	rc = 0;
	82	unlock:
	83	spin_unlock(&data->pmi_spinlock);
	84
	85	if (rc == -EIO) {
	86	rc = IRQ_HANDLED;
	87	goto out;
	88	}
	89
	90	if (data->msg.type & PMI_ACK) {
	91	complete(data->completion);
	92	rc = IRQ_HANDLED;
	93	goto out;
	94	}
	95
	96	schedule_work(&data->work);
	97
	98	rc = IRQ_HANDLED;
	99	out:
	100	return rc;
	101	}
	102
	103
	104	static struct of_device_id pmi_match[] = {
	105	{ .type = "ibm,pmi", .name = "ibm,pmi" },
4a065f94	106	{ .type = "ibm,pmi" },
0e826643 CK	107	{},
	108	};
	109
	110	MODULE_DEVICE_TABLE(of, pmi_match);
	111
	112	static void pmi_notify_handlers(struct work_struct *work)
	113	{
0e826643 CK	114	struct pmi_handler *handler;
0e826643 CK	115
0e826643 CK	116	spin_lock(&data->handler_spinlock);
0e826643 CK	117	list_for_each_entry(handler, &data->handler, node) {
689fd14a	118	pr_debug("pmi: notifying handler %p\n", handler);
0e826643	119	if (handler->type == data->msg.type)
813f9072	120	handler->handle_pmi_message(data->msg);
0e826643 CK	121	}
	122	spin_unlock(&data->handler_spinlock);
	123	}
	124
00006124	125	static int pmi_of_probe(struct platform_device *dev)
0e826643	126	{
61c7a080	127	struct device_node *np = dev->dev.of_node;
0e826643 CK	128	int rc;
0e826643 CK	129
813f9072 CK	130	if (data) {
	131	printk(KERN_ERR "pmi: driver has already been initialized.\n");
	132	rc = -EBUSY;
	133	goto out;
	134	}
	135
0e826643 CK	136	data = kzalloc(sizeof(struct pmi_data), GFP_KERNEL);
	137	if (!data) {
	138	printk(KERN_ERR "pmi: could not allocate memory.\n");
	139	rc = -ENOMEM;
	140	goto out;
	141	}
	142
6bf05fd7	143	data->pmi_reg = of_iomap(np, 0);
0e826643 CK	144	if (!data->pmi_reg) {
	145	printk(KERN_ERR "pmi: invalid register address.\n");
	146	rc = -EFAULT;
	147	goto error_cleanup_data;
	148	}
	149
	150	INIT_LIST_HEAD(&data->handler);
	151
	152	mutex_init(&data->msg_mutex);
	153	spin_lock_init(&data->pmi_spinlock);
	154	spin_lock_init(&data->handler_spinlock);
	155
	156	INIT_WORK(&data->work, pmi_notify_handlers);
	157
0e826643 CK	158	data->dev = dev;
	159
	160	data->irq = irq_of_parse_and_map(np, 0);
	161	if (data->irq == NO_IRQ) {
	162	printk(KERN_ERR "pmi: invalid interrupt.\n");
	163	rc = -EFAULT;
	164	goto error_cleanup_iomap;
	165	}
	166
813f9072	167	rc = request_irq(data->irq, pmi_irq_handler, 0, "pmi", NULL);
0e826643 CK	168	if (rc) {
	169	printk(KERN_ERR "pmi: can't request IRQ %d: returned %d\n",
	170	data->irq, rc);
	171	goto error_cleanup_iomap;
	172	}
	173
	174	printk(KERN_INFO "pmi: found pmi device at addr %p.\n", data->pmi_reg);
	175
	176	goto out;
	177
	178	error_cleanup_iomap:
	179	iounmap(data->pmi_reg);
	180
	181	error_cleanup_data:
	182	kfree(data);
	183
	184	out:
	185	return rc;
	186	}
	187
a454dc50	188	static int pmi_of_remove(struct platform_device *dev)
0e826643	189	{
0e826643 CK	190	struct pmi_handler handler, tmp;
0e826643 CK	191
813f9072	192	free_irq(data->irq, NULL);
0e826643 CK	193	iounmap(data->pmi_reg);
	194
	195	spin_lock(&data->handler_spinlock);
	196
	197	list_for_each_entry_safe(handler, tmp, &data->handler, node)
	198	list_del(&handler->node);
	199
	200	spin_unlock(&data->handler_spinlock);
	201
813f9072 CK	202	kfree(data);
813f9072 CK	203	data = NULL;
0e826643 CK	204
	205	return 0;
	206	}
	207
00006124	208	static struct platform_driver pmi_of_platform_driver = {
0e826643	209	.probe = pmi_of_probe,
84dd4676	210	.remove = pmi_of_remove,
4018294b GL	211	.driver = {
	212	.name = "pmi",
	213	.owner = THIS_MODULE,
	214	.of_match_table = pmi_match,
84dd4676	215	},
0e826643	216	};
40c935ae	217	module_platform_driver(pmi_of_platform_driver);
0e826643	218
813f9072	219	int pmi_send_message(pmi_message_t msg)
0e826643	220	{
0e826643 CK	221	unsigned long flags;
	222	DECLARE_COMPLETION_ONSTACK(completion);
	223
813f9072 CK	224	if (!data)
813f9072 CK	225	return -ENODEV;
0e826643 CK	226
	227	mutex_lock(&data->msg_mutex);
	228
	229	data->msg = msg;
	230	pr_debug("pmi_send_message: msg is %08x\n", (u32)&msg);
	231
	232	data->completion = &completion;
	233
	234	spin_lock_irqsave(&data->pmi_spinlock, flags);
	235	iowrite8(msg.data0, data->pmi_reg + PMI_WRITE_DATA0);
	236	iowrite8(msg.data1, data->pmi_reg + PMI_WRITE_DATA1);
	237	iowrite8(msg.data2, data->pmi_reg + PMI_WRITE_DATA2);
	238	iowrite8(msg.type, data->pmi_reg + PMI_WRITE_TYPE);
	239	spin_unlock_irqrestore(&data->pmi_spinlock, flags);
	240
	241	pr_debug("pmi_send_message: wait for completion\n");
	242
	243	wait_for_completion_interruptible_timeout(data->completion,
	244	PMI_TIMEOUT);
	245
	246	data->completion = NULL;
	247
	248	mutex_unlock(&data->msg_mutex);
813f9072 CK	249
813f9072 CK	250	return 0;
0e826643 CK	251	}
	252	EXPORT_SYMBOL_GPL(pmi_send_message);
	253
813f9072	254	int pmi_register_handler(struct pmi_handler *handler)
0e826643	255	{
79baf4a6	256	if (!data)
813f9072	257	return -ENODEV;
79baf4a6	258
0e826643 CK	259	spin_lock(&data->handler_spinlock);
	260	list_add_tail(&handler->node, &data->handler);
	261	spin_unlock(&data->handler_spinlock);
813f9072 CK	262
813f9072 CK	263	return 0;
0e826643 CK	264	}
	265	EXPORT_SYMBOL_GPL(pmi_register_handler);
	266
813f9072	267	void pmi_unregister_handler(struct pmi_handler *handler)
0e826643	268	{
79baf4a6 CK	269	if (!data)
79baf4a6 CK	270	return;
0e826643	271
79baf4a6	272	pr_debug("pmi: unregistering handler %p\n", handler);
0e826643 CK	273
	274	spin_lock(&data->handler_spinlock);
	275	list_del(&handler->node);
	276	spin_unlock(&data->handler_spinlock);
	277	}
	278	EXPORT_SYMBOL_GPL(pmi_unregister_handler);
	279
	280	MODULE_LICENSE("GPL");
	281	MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
	282	MODULE_DESCRIPTION("IBM Platform Management Interrupt driver");