4 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
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.
10 * Author: Christian Krafft <krafft@de.ibm.com>
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)
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.
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.
27 #include <linux/interrupt.h>
28 #include <linux/completion.h>
29 #include <linux/spinlock.h>
30 #include <linux/workqueue.h>
32 #include <asm/of_device.h>
33 #include <asm/of_platform.h>
39 struct list_head handler
;
40 spinlock_t handler_spinlock
;
41 spinlock_t pmi_spinlock
;
42 struct mutex msg_mutex
;
44 struct completion
*completion
;
45 struct of_device
*dev
;
48 struct work_struct work
;
52 static int pmi_irq_handler(int irq
, void *dev_id
)
54 struct pmi_data
*data
;
60 spin_lock(&data
->pmi_spinlock
);
62 type
= ioread8(data
->pmi_reg
+ PMI_READ_TYPE
);
63 pr_debug("pmi: got message of type %d\n", type
);
65 if (type
& PMI_ACK
&& !data
->completion
) {
66 printk(KERN_WARNING
"pmi: got unexpected ACK message.\n");
71 if (data
->completion
&& !(type
& PMI_ACK
)) {
72 printk(KERN_WARNING
"pmi: expected ACK, but got %d\n", type
);
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
);
83 spin_unlock(&data
->pmi_spinlock
);
90 if (data
->msg
.type
& PMI_ACK
) {
91 complete(data
->completion
);
96 schedule_work(&data
->work
);
104 static struct of_device_id pmi_match
[] = {
105 { .type
= "ibm,pmi", .name
= "ibm,pmi" },
106 { .type
= "ibm,pmi" },
110 MODULE_DEVICE_TABLE(of
, pmi_match
);
112 static void pmi_notify_handlers(struct work_struct
*work
)
114 struct pmi_data
*data
;
115 struct pmi_handler
*handler
;
117 data
= container_of(work
, struct pmi_data
, work
);
119 spin_lock(&data
->handler_spinlock
);
120 list_for_each_entry(handler
, &data
->handler
, node
) {
121 pr_debug(KERN_INFO
"pmi: notifying handler %p\n", handler
);
122 if (handler
->type
== data
->msg
.type
)
123 handler
->handle_pmi_message(data
->dev
, data
->msg
);
125 spin_unlock(&data
->handler_spinlock
);
128 static int pmi_of_probe(struct of_device
*dev
,
129 const struct of_device_id
*match
)
131 struct device_node
*np
= dev
->node
;
132 struct pmi_data
*data
;
135 data
= kzalloc(sizeof(struct pmi_data
), GFP_KERNEL
);
137 printk(KERN_ERR
"pmi: could not allocate memory.\n");
142 data
->pmi_reg
= of_iomap(np
, 0);
143 if (!data
->pmi_reg
) {
144 printk(KERN_ERR
"pmi: invalid register address.\n");
146 goto error_cleanup_data
;
149 INIT_LIST_HEAD(&data
->handler
);
151 mutex_init(&data
->msg_mutex
);
152 spin_lock_init(&data
->pmi_spinlock
);
153 spin_lock_init(&data
->handler_spinlock
);
155 INIT_WORK(&data
->work
, pmi_notify_handlers
);
157 dev
->dev
.driver_data
= data
;
160 data
->irq
= irq_of_parse_and_map(np
, 0);
161 if (data
->irq
== NO_IRQ
) {
162 printk(KERN_ERR
"pmi: invalid interrupt.\n");
164 goto error_cleanup_iomap
;
167 rc
= request_irq(data
->irq
, pmi_irq_handler
, 0, "pmi", data
);
169 printk(KERN_ERR
"pmi: can't request IRQ %d: returned %d\n",
171 goto error_cleanup_iomap
;
174 printk(KERN_INFO
"pmi: found pmi device at addr %p.\n", data
->pmi_reg
);
179 iounmap(data
->pmi_reg
);
188 static int pmi_of_remove(struct of_device
*dev
)
190 struct pmi_data
*data
;
191 struct pmi_handler
*handler
, *tmp
;
193 data
= dev
->dev
.driver_data
;
195 free_irq(data
->irq
, data
);
196 iounmap(data
->pmi_reg
);
198 spin_lock(&data
->handler_spinlock
);
200 list_for_each_entry_safe(handler
, tmp
, &data
->handler
, node
)
201 list_del(&handler
->node
);
203 spin_unlock(&data
->handler_spinlock
);
205 kfree(dev
->dev
.driver_data
);
210 static struct of_platform_driver pmi_of_platform_driver
= {
212 .match_table
= pmi_match
,
213 .probe
= pmi_of_probe
,
214 .remove
= pmi_of_remove
217 static int __init
pmi_module_init(void)
219 return of_register_platform_driver(&pmi_of_platform_driver
);
221 module_init(pmi_module_init
);
223 static void __exit
pmi_module_exit(void)
225 of_unregister_platform_driver(&pmi_of_platform_driver
);
227 module_exit(pmi_module_exit
);
229 void pmi_send_message(struct of_device
*device
, pmi_message_t msg
)
231 struct pmi_data
*data
;
233 DECLARE_COMPLETION_ONSTACK(completion
);
235 data
= device
->dev
.driver_data
;
237 mutex_lock(&data
->msg_mutex
);
240 pr_debug("pmi_send_message: msg is %08x\n", *(u32
*)&msg
);
242 data
->completion
= &completion
;
244 spin_lock_irqsave(&data
->pmi_spinlock
, flags
);
245 iowrite8(msg
.data0
, data
->pmi_reg
+ PMI_WRITE_DATA0
);
246 iowrite8(msg
.data1
, data
->pmi_reg
+ PMI_WRITE_DATA1
);
247 iowrite8(msg
.data2
, data
->pmi_reg
+ PMI_WRITE_DATA2
);
248 iowrite8(msg
.type
, data
->pmi_reg
+ PMI_WRITE_TYPE
);
249 spin_unlock_irqrestore(&data
->pmi_spinlock
, flags
);
251 pr_debug("pmi_send_message: wait for completion\n");
253 wait_for_completion_interruptible_timeout(data
->completion
,
256 data
->completion
= NULL
;
258 mutex_unlock(&data
->msg_mutex
);
260 EXPORT_SYMBOL_GPL(pmi_send_message
);
262 void pmi_register_handler(struct of_device
*device
,
263 struct pmi_handler
*handler
)
265 struct pmi_data
*data
;
266 data
= device
->dev
.driver_data
;
271 spin_lock(&data
->handler_spinlock
);
272 list_add_tail(&handler
->node
, &data
->handler
);
273 spin_unlock(&data
->handler_spinlock
);
275 EXPORT_SYMBOL_GPL(pmi_register_handler
);
277 void pmi_unregister_handler(struct of_device
*device
,
278 struct pmi_handler
*handler
)
280 struct pmi_data
*data
;
281 data
= device
->dev
.driver_data
;
286 pr_debug("pmi: unregistering handler %p\n", handler
);
288 spin_lock(&data
->handler_spinlock
);
289 list_del(&handler
->node
);
290 spin_unlock(&data
->handler_spinlock
);
292 EXPORT_SYMBOL_GPL(pmi_unregister_handler
);
294 MODULE_LICENSE("GPL");
295 MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
296 MODULE_DESCRIPTION("IBM Platform Management Interrupt driver");