4 * Copyright (C) 2006-2009 Nokia Corporation. All rights reserved.
6 * Contact: Hiroshi DOYU <Hiroshi.DOYU@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/interrupt.h>
25 #include <linux/spinlock.h>
26 #include <linux/mutex.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/kfifo.h>
30 #include <linux/err.h>
32 #include <plat/mailbox.h>
34 static struct workqueue_struct
*mboxd
;
35 static struct omap_mbox
**mboxes
;
38 static int mbox_configured
;
39 static DEFINE_MUTEX(mbox_configured_lock
);
41 static unsigned int mbox_kfifo_size
= CONFIG_OMAP_MBOX_KFIFO_SIZE
;
42 module_param(mbox_kfifo_size
, uint
, S_IRUGO
);
43 MODULE_PARM_DESC(mbox_kfifo_size
, "Size of omap's mailbox kfifo (bytes)");
45 /* Mailbox FIFO handle functions */
46 static inline mbox_msg_t
mbox_fifo_read(struct omap_mbox
*mbox
)
48 return mbox
->ops
->fifo_read(mbox
);
50 static inline void mbox_fifo_write(struct omap_mbox
*mbox
, mbox_msg_t msg
)
52 mbox
->ops
->fifo_write(mbox
, msg
);
54 static inline int mbox_fifo_empty(struct omap_mbox
*mbox
)
56 return mbox
->ops
->fifo_empty(mbox
);
58 static inline int mbox_fifo_full(struct omap_mbox
*mbox
)
60 return mbox
->ops
->fifo_full(mbox
);
63 /* Mailbox IRQ handle functions */
64 static inline void ack_mbox_irq(struct omap_mbox
*mbox
, omap_mbox_irq_t irq
)
66 if (mbox
->ops
->ack_irq
)
67 mbox
->ops
->ack_irq(mbox
, irq
);
69 static inline int is_mbox_irq(struct omap_mbox
*mbox
, omap_mbox_irq_t irq
)
71 return mbox
->ops
->is_irq(mbox
, irq
);
77 static int __mbox_poll_for_space(struct omap_mbox
*mbox
)
79 int ret
= 0, i
= 1000;
81 while (mbox_fifo_full(mbox
)) {
82 if (mbox
->ops
->type
== OMAP_MBOX_TYPE2
)
91 int omap_mbox_msg_send(struct omap_mbox
*mbox
, mbox_msg_t msg
)
93 struct omap_mbox_queue
*mq
= mbox
->txq
;
98 if (kfifo_avail(&mq
->fifo
) < sizeof(msg
)) {
103 len
= kfifo_in(&mq
->fifo
, (unsigned char *)&msg
, sizeof(msg
));
104 WARN_ON(len
!= sizeof(msg
));
106 tasklet_schedule(&mbox
->txq
->tasklet
);
109 spin_unlock(&mq
->lock
);
112 EXPORT_SYMBOL(omap_mbox_msg_send
);
114 static void mbox_tx_tasklet(unsigned long tx_data
)
116 struct omap_mbox
*mbox
= (struct omap_mbox
*)tx_data
;
117 struct omap_mbox_queue
*mq
= mbox
->txq
;
121 while (kfifo_len(&mq
->fifo
)) {
122 if (__mbox_poll_for_space(mbox
)) {
123 omap_mbox_enable_irq(mbox
, IRQ_TX
);
127 ret
= kfifo_out(&mq
->fifo
, (unsigned char *)&msg
,
129 WARN_ON(ret
!= sizeof(msg
));
131 mbox_fifo_write(mbox
, msg
);
136 * Message receiver(workqueue)
138 static void mbox_rx_work(struct work_struct
*work
)
140 struct omap_mbox_queue
*mq
=
141 container_of(work
, struct omap_mbox_queue
, work
);
145 while (kfifo_len(&mq
->fifo
) >= sizeof(msg
)) {
146 len
= kfifo_out(&mq
->fifo
, (unsigned char *)&msg
, sizeof(msg
));
147 WARN_ON(len
!= sizeof(msg
));
150 mq
->callback((void *)msg
);
155 * Mailbox interrupt handler
157 static void __mbox_tx_interrupt(struct omap_mbox
*mbox
)
159 omap_mbox_disable_irq(mbox
, IRQ_TX
);
160 ack_mbox_irq(mbox
, IRQ_TX
);
161 tasklet_schedule(&mbox
->txq
->tasklet
);
164 static void __mbox_rx_interrupt(struct omap_mbox
*mbox
)
166 struct omap_mbox_queue
*mq
= mbox
->rxq
;
170 while (!mbox_fifo_empty(mbox
)) {
171 if (unlikely(kfifo_avail(&mq
->fifo
) < sizeof(msg
))) {
172 omap_mbox_disable_irq(mbox
, IRQ_RX
);
177 msg
= mbox_fifo_read(mbox
);
179 len
= kfifo_in(&mq
->fifo
, (unsigned char *)&msg
, sizeof(msg
));
180 WARN_ON(len
!= sizeof(msg
));
182 if (mbox
->ops
->type
== OMAP_MBOX_TYPE1
)
186 /* no more messages in the fifo. clear IRQ source. */
187 ack_mbox_irq(mbox
, IRQ_RX
);
189 queue_work(mboxd
, &mbox
->rxq
->work
);
192 static irqreturn_t
mbox_interrupt(int irq
, void *p
)
194 struct omap_mbox
*mbox
= p
;
196 if (is_mbox_irq(mbox
, IRQ_TX
))
197 __mbox_tx_interrupt(mbox
);
199 if (is_mbox_irq(mbox
, IRQ_RX
))
200 __mbox_rx_interrupt(mbox
);
205 static struct omap_mbox_queue
*mbox_queue_alloc(struct omap_mbox
*mbox
,
206 void (*work
) (struct work_struct
*),
207 void (*tasklet
)(unsigned long))
209 struct omap_mbox_queue
*mq
;
211 mq
= kzalloc(sizeof(struct omap_mbox_queue
), GFP_KERNEL
);
215 spin_lock_init(&mq
->lock
);
217 if (kfifo_alloc(&mq
->fifo
, mbox_kfifo_size
, GFP_KERNEL
))
221 INIT_WORK(&mq
->work
, work
);
224 tasklet_init(&mq
->tasklet
, tasklet
, (unsigned long)mbox
);
231 static void mbox_queue_free(struct omap_mbox_queue
*q
)
233 kfifo_free(&q
->fifo
);
237 static int omap_mbox_startup(struct omap_mbox
*mbox
)
240 struct omap_mbox_queue
*mq
;
242 if (mbox
->ops
->startup
) {
243 mutex_lock(&mbox_configured_lock
);
244 if (!mbox_configured
)
245 ret
= mbox
->ops
->startup(mbox
);
248 mutex_unlock(&mbox_configured_lock
);
252 mutex_unlock(&mbox_configured_lock
);
255 ret
= request_irq(mbox
->irq
, mbox_interrupt
, IRQF_SHARED
,
259 "failed to register mailbox interrupt:%d\n", ret
);
260 goto fail_request_irq
;
263 mq
= mbox_queue_alloc(mbox
, NULL
, mbox_tx_tasklet
);
270 mq
= mbox_queue_alloc(mbox
, mbox_rx_work
, NULL
);
280 mbox_queue_free(mbox
->txq
);
282 free_irq(mbox
->irq
, mbox
);
284 if (mbox
->ops
->shutdown
)
285 mbox
->ops
->shutdown(mbox
);
290 static void omap_mbox_fini(struct omap_mbox
*mbox
)
292 free_irq(mbox
->irq
, mbox
);
293 tasklet_kill(&mbox
->txq
->tasklet
);
294 flush_work(&mbox
->rxq
->work
);
295 mbox_queue_free(mbox
->txq
);
296 mbox_queue_free(mbox
->rxq
);
298 if (mbox
->ops
->shutdown
) {
299 mutex_lock(&mbox_configured_lock
);
300 if (mbox_configured
> 0)
302 if (!mbox_configured
)
303 mbox
->ops
->shutdown(mbox
);
304 mutex_unlock(&mbox_configured_lock
);
308 struct omap_mbox
*omap_mbox_get(const char *name
)
310 struct omap_mbox
*mbox
;
314 return ERR_PTR(-EINVAL
);
316 for (mbox
= *mboxes
; mbox
; mbox
++)
317 if (!strcmp(mbox
->name
, name
))
321 return ERR_PTR(-ENOENT
);
323 ret
= omap_mbox_startup(mbox
);
325 return ERR_PTR(-ENODEV
);
329 EXPORT_SYMBOL(omap_mbox_get
);
331 void omap_mbox_put(struct omap_mbox
*mbox
)
333 omap_mbox_fini(mbox
);
335 EXPORT_SYMBOL(omap_mbox_put
);
337 static struct class omap_mbox_class
= { .name
= "mbox", };
339 int omap_mbox_register(struct device
*parent
, struct omap_mbox
**list
)
348 for (i
= 0; mboxes
[i
]; i
++) {
349 struct omap_mbox
*mbox
= mboxes
[i
];
350 mbox
->dev
= device_create(&omap_mbox_class
,
351 parent
, 0, mbox
, "%s", mbox
->name
);
352 if (IS_ERR(mbox
->dev
)) {
353 ret
= PTR_ERR(mbox
->dev
);
361 device_unregister(mboxes
[i
]->dev
);
364 EXPORT_SYMBOL(omap_mbox_register
);
366 int omap_mbox_unregister(void)
373 for (i
= 0; mboxes
[i
]; i
++)
374 device_unregister(mboxes
[i
]->dev
);
378 EXPORT_SYMBOL(omap_mbox_unregister
);
380 static int __init
omap_mbox_init(void)
384 err
= class_register(&omap_mbox_class
);
388 mboxd
= create_workqueue("mboxd");
392 /* kfifo size sanity check: alignment and minimal size */
393 mbox_kfifo_size
= ALIGN(mbox_kfifo_size
, sizeof(mbox_msg_t
));
394 mbox_kfifo_size
= max_t(unsigned int, mbox_kfifo_size
, sizeof(mbox_msg_t
));
398 subsys_initcall(omap_mbox_init
);
400 static void __exit
omap_mbox_exit(void)
402 destroy_workqueue(mboxd
);
403 class_unregister(&omap_mbox_class
);
405 module_exit(omap_mbox_exit
);
407 MODULE_LICENSE("GPL v2");
408 MODULE_DESCRIPTION("omap mailbox: interrupt driven messaging");
409 MODULE_AUTHOR("Toshihiro Kobayashi");
410 MODULE_AUTHOR("Hiroshi DOYU");