[net-next-2.6.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/completion.h>
#include <linux/spinlock.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 of_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(KERN_INFO "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 of_device *dev,
			const struct of_device_id *match)
{
	struct device_node *np = dev->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 of_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 of_platform_driver pmi_of_platform_driver = {
	.match_table	= pmi_match,
	.probe		= pmi_of_probe,
	.remove		= pmi_of_remove,
	.driver		= {
		.name	= "pmi",
	},
};

static int __init pmi_module_init(void)
{
	return of_register_platform_driver(&pmi_of_platform_driver);
}
module_init(pmi_module_init);

static void __exit pmi_module_exit(void)
{
	of_unregister_platform_driver(&pmi_of_platform_driver);
}
module_exit(pmi_module_exit);

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>
	28	#include <linux/completion.h>
	29	#include <linux/spinlock.h>
	30	#include <linux/workqueue.h>
eb8f2763 JL	31	#include <linux/of_device.h>
eb8f2763 JL	32	#include <linux/of_platform.h>
0e826643	33
0e826643 CK	34	#include <asm/io.h>
0e826643 CK	35	#include <asm/pmi.h>
6bf05fd7	36	#include <asm/prom.h>
0e826643 CK	37
	38	struct pmi_data {
	39	struct list_head handler;
	40	spinlock_t handler_spinlock;
	41	spinlock_t pmi_spinlock;
	42	struct mutex msg_mutex;
	43	pmi_message_t msg;
	44	struct completion *completion;
	45	struct of_device *dev;
	46	int irq;
	47	u8 __iomem *pmi_reg;
	48	struct work_struct work;
	49	};
	50
813f9072	51	static struct pmi_data *data;
0e826643	52
fb247449	53	static irqreturn_t pmi_irq_handler(int irq, void *dev_id)
0e826643	54	{
0e826643 CK	55	u8 type;
	56	int rc;
	57
0e826643 CK	58	spin_lock(&data->pmi_spinlock);
	59
	60	type = ioread8(data->pmi_reg + PMI_READ_TYPE);
	61	pr_debug("pmi: got message of type %d\n", type);
	62
	63	if (type & PMI_ACK && !data->completion) {
	64	printk(KERN_WARNING "pmi: got unexpected ACK message.\n");
	65	rc = -EIO;
	66	goto unlock;
	67	}
	68
	69	if (data->completion && !(type & PMI_ACK)) {
	70	printk(KERN_WARNING "pmi: expected ACK, but got %d\n", type);
	71	rc = -EIO;
	72	goto unlock;
	73	}
	74
	75	data->msg.type = type;
	76	data->msg.data0 = ioread8(data->pmi_reg + PMI_READ_DATA0);
	77	data->msg.data1 = ioread8(data->pmi_reg + PMI_READ_DATA1);
	78	data->msg.data2 = ioread8(data->pmi_reg + PMI_READ_DATA2);
	79	rc = 0;
	80	unlock:
	81	spin_unlock(&data->pmi_spinlock);
	82
	83	if (rc == -EIO) {
	84	rc = IRQ_HANDLED;
	85	goto out;
	86	}
	87
	88	if (data->msg.type & PMI_ACK) {
	89	complete(data->completion);
	90	rc = IRQ_HANDLED;
	91	goto out;
	92	}
	93
	94	schedule_work(&data->work);
	95
	96	rc = IRQ_HANDLED;
	97	out:
	98	return rc;
	99	}
	100
	101
	102	static struct of_device_id pmi_match[] = {
	103	{ .type = "ibm,pmi", .name = "ibm,pmi" },
4a065f94	104	{ .type = "ibm,pmi" },
0e826643 CK	105	{},
	106	};
	107
	108	MODULE_DEVICE_TABLE(of, pmi_match);
	109
	110	static void pmi_notify_handlers(struct work_struct *work)
	111	{
0e826643 CK	112	struct pmi_handler *handler;
0e826643 CK	113
0e826643 CK	114	spin_lock(&data->handler_spinlock);
	115	list_for_each_entry(handler, &data->handler, node) {
	116	pr_debug(KERN_INFO "pmi: notifying handler %p\n", handler);
	117	if (handler->type == data->msg.type)
813f9072	118	handler->handle_pmi_message(data->msg);
0e826643 CK	119	}
	120	spin_unlock(&data->handler_spinlock);
	121	}
	122
	123	static int pmi_of_probe(struct of_device *dev,
	124	const struct of_device_id *match)
	125	{
	126	struct device_node *np = dev->node;
0e826643 CK	127	int rc;
0e826643 CK	128
813f9072 CK	129	if (data) {
	130	printk(KERN_ERR "pmi: driver has already been initialized.\n");
	131	rc = -EBUSY;
	132	goto out;
	133	}
	134
0e826643 CK	135	data = kzalloc(sizeof(struct pmi_data), GFP_KERNEL);
	136	if (!data) {
	137	printk(KERN_ERR "pmi: could not allocate memory.\n");
	138	rc = -ENOMEM;
	139	goto out;
	140	}
	141
6bf05fd7	142	data->pmi_reg = of_iomap(np, 0);
0e826643 CK	143	if (!data->pmi_reg) {
	144	printk(KERN_ERR "pmi: invalid register address.\n");
	145	rc = -EFAULT;
	146	goto error_cleanup_data;
	147	}
	148
	149	INIT_LIST_HEAD(&data->handler);
	150
	151	mutex_init(&data->msg_mutex);
	152	spin_lock_init(&data->pmi_spinlock);
	153	spin_lock_init(&data->handler_spinlock);
	154
	155	INIT_WORK(&data->work, pmi_notify_handlers);
	156
0e826643 CK	157	data->dev = dev;
	158
	159	data->irq = irq_of_parse_and_map(np, 0);
	160	if (data->irq == NO_IRQ) {
	161	printk(KERN_ERR "pmi: invalid interrupt.\n");
	162	rc = -EFAULT;
	163	goto error_cleanup_iomap;
	164	}
	165
813f9072	166	rc = request_irq(data->irq, pmi_irq_handler, 0, "pmi", NULL);
0e826643 CK	167	if (rc) {
	168	printk(KERN_ERR "pmi: can't request IRQ %d: returned %d\n",
	169	data->irq, rc);
	170	goto error_cleanup_iomap;
	171	}
	172
	173	printk(KERN_INFO "pmi: found pmi device at addr %p.\n", data->pmi_reg);
	174
	175	goto out;
	176
	177	error_cleanup_iomap:
	178	iounmap(data->pmi_reg);
	179
	180	error_cleanup_data:
	181	kfree(data);
	182
	183	out:
	184	return rc;
	185	}
	186
	187	static int pmi_of_remove(struct of_device *dev)
	188	{
0e826643 CK	189	struct pmi_handler handler, tmp;
0e826643 CK	190
813f9072	191	free_irq(data->irq, NULL);
0e826643 CK	192	iounmap(data->pmi_reg);
	193
	194	spin_lock(&data->handler_spinlock);
	195
	196	list_for_each_entry_safe(handler, tmp, &data->handler, node)
	197	list_del(&handler->node);
	198
	199	spin_unlock(&data->handler_spinlock);
	200
813f9072 CK	201	kfree(data);
813f9072 CK	202	data = NULL;
0e826643 CK	203
	204	return 0;
	205	}
	206
	207	static struct of_platform_driver pmi_of_platform_driver = {
0e826643 CK	208	.match_table = pmi_match,
0e826643 CK	209	.probe = pmi_of_probe,
84dd4676 SR	210	.remove = pmi_of_remove,
	211	.driver = {
	212	.name = "pmi",
	213	},
0e826643 CK	214	};
	215
	216	static int __init pmi_module_init(void)
	217	{
	218	return of_register_platform_driver(&pmi_of_platform_driver);
	219	}
	220	module_init(pmi_module_init);
	221
	222	static void __exit pmi_module_exit(void)
	223	{
	224	of_unregister_platform_driver(&pmi_of_platform_driver);
	225	}
	226	module_exit(pmi_module_exit);
	227
813f9072	228	int pmi_send_message(pmi_message_t msg)
0e826643	229	{
0e826643 CK	230	unsigned long flags;
	231	DECLARE_COMPLETION_ONSTACK(completion);
	232
813f9072 CK	233	if (!data)
813f9072 CK	234	return -ENODEV;
0e826643 CK	235
	236	mutex_lock(&data->msg_mutex);
	237
	238	data->msg = msg;
	239	pr_debug("pmi_send_message: msg is %08x\n", (u32)&msg);
	240
	241	data->completion = &completion;
	242
	243	spin_lock_irqsave(&data->pmi_spinlock, flags);
	244	iowrite8(msg.data0, data->pmi_reg + PMI_WRITE_DATA0);
	245	iowrite8(msg.data1, data->pmi_reg + PMI_WRITE_DATA1);
	246	iowrite8(msg.data2, data->pmi_reg + PMI_WRITE_DATA2);
	247	iowrite8(msg.type, data->pmi_reg + PMI_WRITE_TYPE);
	248	spin_unlock_irqrestore(&data->pmi_spinlock, flags);
	249
	250	pr_debug("pmi_send_message: wait for completion\n");
	251
	252	wait_for_completion_interruptible_timeout(data->completion,
	253	PMI_TIMEOUT);
	254
	255	data->completion = NULL;
	256
	257	mutex_unlock(&data->msg_mutex);
813f9072 CK	258
813f9072 CK	259	return 0;
0e826643 CK	260	}
	261	EXPORT_SYMBOL_GPL(pmi_send_message);
	262
813f9072	263	int pmi_register_handler(struct pmi_handler *handler)
0e826643	264	{
79baf4a6	265	if (!data)
813f9072	266	return -ENODEV;
79baf4a6	267
0e826643 CK	268	spin_lock(&data->handler_spinlock);
	269	list_add_tail(&handler->node, &data->handler);
	270	spin_unlock(&data->handler_spinlock);
813f9072 CK	271
813f9072 CK	272	return 0;
0e826643 CK	273	}
	274	EXPORT_SYMBOL_GPL(pmi_register_handler);
	275
813f9072	276	void pmi_unregister_handler(struct pmi_handler *handler)
0e826643	277	{
79baf4a6 CK	278	if (!data)
79baf4a6 CK	279	return;
0e826643	280
79baf4a6	281	pr_debug("pmi: unregistering handler %p\n", handler);
0e826643 CK	282
	283	spin_lock(&data->handler_spinlock);
	284	list_del(&handler->node);
	285	spin_unlock(&data->handler_spinlock);
	286	}
	287	EXPORT_SYMBOL_GPL(pmi_unregister_handler);
	288
	289	MODULE_LICENSE("GPL");
	290	MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
	291	MODULE_DESCRIPTION("IBM Platform Management Interrupt driver");