Merge branch 'fix/asoc' into for-linus
[linux-2.6] / arch / arm / plat-omap / mailbox.c
1 /*
2  * OMAP mailbox driver
3  *
4  * Copyright (C) 2006-2009 Nokia Corporation. All rights reserved.
5  *
6  * Contact: Hiroshi DOYU <Hiroshi.DOYU@nokia.com>
7  *
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.
11  *
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.
16  *
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
20  * 02110-1301 USA
21  *
22  */
23
24 #include <linux/module.h>
25 #include <linux/interrupt.h>
26 #include <linux/device.h>
27 #include <linux/delay.h>
28
29 #include <mach/mailbox.h>
30
31 static int enable_seq_bit;
32 module_param(enable_seq_bit, bool, 0);
33 MODULE_PARM_DESC(enable_seq_bit, "Enable sequence bit checking.");
34
35 static struct omap_mbox *mboxes;
36 static DEFINE_RWLOCK(mboxes_lock);
37
38 /*
39  * Mailbox sequence bit API
40  */
41
42 /* seq_rcv should be initialized with any value other than
43  * 0 and 1 << 31, to allow either value for the first
44  * message.  */
45 static inline void mbox_seq_init(struct omap_mbox *mbox)
46 {
47         if (!enable_seq_bit)
48                 return;
49
50         /* any value other than 0 and 1 << 31 */
51         mbox->seq_rcv = 0xffffffff;
52 }
53
54 static inline void mbox_seq_toggle(struct omap_mbox *mbox, mbox_msg_t * msg)
55 {
56         if (!enable_seq_bit)
57                 return;
58
59         /* add seq_snd to msg */
60         *msg = (*msg & 0x7fffffff) | mbox->seq_snd;
61         /* flip seq_snd */
62         mbox->seq_snd ^= 1 << 31;
63 }
64
65 static inline int mbox_seq_test(struct omap_mbox *mbox, mbox_msg_t msg)
66 {
67         mbox_msg_t seq;
68
69         if (!enable_seq_bit)
70                 return 0;
71
72         seq = msg & (1 << 31);
73         if (seq == mbox->seq_rcv)
74                 return -1;
75         mbox->seq_rcv = seq;
76         return 0;
77 }
78
79 /* Mailbox FIFO handle functions */
80 static inline mbox_msg_t mbox_fifo_read(struct omap_mbox *mbox)
81 {
82         return mbox->ops->fifo_read(mbox);
83 }
84 static inline void mbox_fifo_write(struct omap_mbox *mbox, mbox_msg_t msg)
85 {
86         mbox->ops->fifo_write(mbox, msg);
87 }
88 static inline int mbox_fifo_empty(struct omap_mbox *mbox)
89 {
90         return mbox->ops->fifo_empty(mbox);
91 }
92 static inline int mbox_fifo_full(struct omap_mbox *mbox)
93 {
94         return mbox->ops->fifo_full(mbox);
95 }
96
97 /* Mailbox IRQ handle functions */
98 static inline void enable_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
99 {
100         mbox->ops->enable_irq(mbox, irq);
101 }
102 static inline void disable_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
103 {
104         mbox->ops->disable_irq(mbox, irq);
105 }
106 static inline void ack_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
107 {
108         if (mbox->ops->ack_irq)
109                 mbox->ops->ack_irq(mbox, irq);
110 }
111 static inline int is_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
112 {
113         return mbox->ops->is_irq(mbox, irq);
114 }
115
116 /* Mailbox Sequence Bit function */
117 void omap_mbox_init_seq(struct omap_mbox *mbox)
118 {
119         mbox_seq_init(mbox);
120 }
121 EXPORT_SYMBOL(omap_mbox_init_seq);
122
123 /*
124  * message sender
125  */
126 static int __mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg, void *arg)
127 {
128         int ret = 0, i = 1000;
129
130         while (mbox_fifo_full(mbox)) {
131                 if (mbox->ops->type == OMAP_MBOX_TYPE2)
132                         return -1;
133                 if (--i == 0)
134                         return -1;
135                 udelay(1);
136         }
137
138         if (arg && mbox->txq->callback) {
139                 ret = mbox->txq->callback(arg);
140                 if (ret)
141                         goto out;
142         }
143
144         mbox_seq_toggle(mbox, &msg);
145         mbox_fifo_write(mbox, msg);
146  out:
147         return ret;
148 }
149
150 int omap_mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg, void* arg)
151 {
152         struct request *rq;
153         struct request_queue *q = mbox->txq->queue;
154         int ret = 0;
155
156         rq = blk_get_request(q, WRITE, GFP_ATOMIC);
157         if (unlikely(!rq)) {
158                 ret = -ENOMEM;
159                 goto fail;
160         }
161
162         rq->data = (void *)msg;
163         blk_insert_request(q, rq, 0, arg);
164
165         schedule_work(&mbox->txq->work);
166  fail:
167         return ret;
168 }
169 EXPORT_SYMBOL(omap_mbox_msg_send);
170
171 static void mbox_tx_work(struct work_struct *work)
172 {
173         int ret;
174         struct request *rq;
175         struct omap_mbox_queue *mq = container_of(work,
176                                 struct omap_mbox_queue, work);
177         struct omap_mbox *mbox = mq->queue->queuedata;
178         struct request_queue *q = mbox->txq->queue;
179
180         while (1) {
181                 spin_lock(q->queue_lock);
182                 rq = elv_next_request(q);
183                 spin_unlock(q->queue_lock);
184
185                 if (!rq)
186                         break;
187
188                 ret = __mbox_msg_send(mbox, (mbox_msg_t) rq->data, rq->special);
189                 if (ret) {
190                         enable_mbox_irq(mbox, IRQ_TX);
191                         return;
192                 }
193
194                 spin_lock(q->queue_lock);
195                 if (__blk_end_request(rq, 0, 0))
196                         BUG();
197                 spin_unlock(q->queue_lock);
198         }
199 }
200
201 /*
202  * Message receiver(workqueue)
203  */
204 static void mbox_rx_work(struct work_struct *work)
205 {
206         struct omap_mbox_queue *mq =
207                         container_of(work, struct omap_mbox_queue, work);
208         struct omap_mbox *mbox = mq->queue->queuedata;
209         struct request_queue *q = mbox->rxq->queue;
210         struct request *rq;
211         mbox_msg_t msg;
212         unsigned long flags;
213
214         if (mbox->rxq->callback == NULL) {
215                 sysfs_notify(&mbox->dev->kobj, NULL, "mbox");
216                 return;
217         }
218
219         while (1) {
220                 spin_lock_irqsave(q->queue_lock, flags);
221                 rq = elv_next_request(q);
222                 spin_unlock_irqrestore(q->queue_lock, flags);
223                 if (!rq)
224                         break;
225
226                 msg = (mbox_msg_t) rq->data;
227
228                 if (blk_end_request(rq, 0, 0))
229                         BUG();
230
231                 mbox->rxq->callback((void *)msg);
232         }
233 }
234
235 /*
236  * Mailbox interrupt handler
237  */
238 static void mbox_txq_fn(struct request_queue * q)
239 {
240 }
241
242 static void mbox_rxq_fn(struct request_queue * q)
243 {
244 }
245
246 static void __mbox_tx_interrupt(struct omap_mbox *mbox)
247 {
248         disable_mbox_irq(mbox, IRQ_TX);
249         ack_mbox_irq(mbox, IRQ_TX);
250         schedule_work(&mbox->txq->work);
251 }
252
253 static void __mbox_rx_interrupt(struct omap_mbox *mbox)
254 {
255         struct request *rq;
256         mbox_msg_t msg;
257         struct request_queue *q = mbox->rxq->queue;
258
259         disable_mbox_irq(mbox, IRQ_RX);
260
261         while (!mbox_fifo_empty(mbox)) {
262                 rq = blk_get_request(q, WRITE, GFP_ATOMIC);
263                 if (unlikely(!rq))
264                         goto nomem;
265
266                 msg = mbox_fifo_read(mbox);
267                 rq->data = (void *)msg;
268
269                 if (unlikely(mbox_seq_test(mbox, msg))) {
270                         pr_info("mbox: Illegal seq bit!(%08x)\n", msg);
271                         if (mbox->err_notify)
272                                 mbox->err_notify();
273                 }
274
275                 blk_insert_request(q, rq, 0, NULL);
276                 if (mbox->ops->type == OMAP_MBOX_TYPE1)
277                         break;
278         }
279
280         /* no more messages in the fifo. clear IRQ source. */
281         ack_mbox_irq(mbox, IRQ_RX);
282         enable_mbox_irq(mbox, IRQ_RX);
283 nomem:
284         schedule_work(&mbox->rxq->work);
285 }
286
287 static irqreturn_t mbox_interrupt(int irq, void *p)
288 {
289         struct omap_mbox *mbox = p;
290
291         if (is_mbox_irq(mbox, IRQ_TX))
292                 __mbox_tx_interrupt(mbox);
293
294         if (is_mbox_irq(mbox, IRQ_RX))
295                 __mbox_rx_interrupt(mbox);
296
297         return IRQ_HANDLED;
298 }
299
300 /*
301  * sysfs files
302  */
303 static ssize_t
304 omap_mbox_write(struct device *dev, struct device_attribute *attr,
305                 const char * buf, size_t count)
306 {
307         int ret;
308         mbox_msg_t *p = (mbox_msg_t *)buf;
309         struct omap_mbox *mbox = dev_get_drvdata(dev);
310
311         for (; count >= sizeof(mbox_msg_t); count -= sizeof(mbox_msg_t)) {
312                 ret = omap_mbox_msg_send(mbox, be32_to_cpu(*p), NULL);
313                 if (ret)
314                         return -EAGAIN;
315                 p++;
316         }
317
318         return (size_t)((char *)p - buf);
319 }
320
321 static ssize_t
322 omap_mbox_read(struct device *dev, struct device_attribute *attr, char *buf)
323 {
324         unsigned long flags;
325         struct request *rq;
326         mbox_msg_t *p = (mbox_msg_t *) buf;
327         struct omap_mbox *mbox = dev_get_drvdata(dev);
328         struct request_queue *q = mbox->rxq->queue;
329
330         while (1) {
331                 spin_lock_irqsave(q->queue_lock, flags);
332                 rq = elv_next_request(q);
333                 spin_unlock_irqrestore(q->queue_lock, flags);
334
335                 if (!rq)
336                         break;
337
338                 *p = (mbox_msg_t) rq->data;
339
340                 if (blk_end_request(rq, 0, 0))
341                         BUG();
342
343                 if (unlikely(mbox_seq_test(mbox, *p))) {
344                         pr_info("mbox: Illegal seq bit!(%08x) ignored\n", *p);
345                         continue;
346                 }
347                 p++;
348         }
349
350         pr_debug("%02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);
351
352         return (size_t) ((char *)p - buf);
353 }
354
355 static DEVICE_ATTR(mbox, S_IRUGO | S_IWUSR, omap_mbox_read, omap_mbox_write);
356
357 static ssize_t mbox_show(struct class *class, char *buf)
358 {
359         return sprintf(buf, "mbox");
360 }
361
362 static CLASS_ATTR(mbox, S_IRUGO, mbox_show, NULL);
363
364 static struct class omap_mbox_class = {
365         .name = "omap-mailbox",
366 };
367
368 static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
369                                         request_fn_proc * proc,
370                                         void (*work) (struct work_struct *))
371 {
372         struct request_queue *q;
373         struct omap_mbox_queue *mq;
374
375         mq = kzalloc(sizeof(struct omap_mbox_queue), GFP_KERNEL);
376         if (!mq)
377                 return NULL;
378
379         spin_lock_init(&mq->lock);
380
381         q = blk_init_queue(proc, &mq->lock);
382         if (!q)
383                 goto error;
384         q->queuedata = mbox;
385         mq->queue = q;
386
387         INIT_WORK(&mq->work, work);
388
389         return mq;
390 error:
391         kfree(mq);
392         return NULL;
393 }
394
395 static void mbox_queue_free(struct omap_mbox_queue *q)
396 {
397         blk_cleanup_queue(q->queue);
398         kfree(q);
399 }
400
401 static int omap_mbox_init(struct omap_mbox *mbox)
402 {
403         int ret;
404         struct omap_mbox_queue *mq;
405
406         if (likely(mbox->ops->startup)) {
407                 ret = mbox->ops->startup(mbox);
408                 if (unlikely(ret))
409                         return ret;
410         }
411
412         ret = request_irq(mbox->irq, mbox_interrupt, IRQF_DISABLED,
413                                 mbox->name, mbox);
414         if (unlikely(ret)) {
415                 printk(KERN_ERR
416                         "failed to register mailbox interrupt:%d\n", ret);
417                 goto fail_request_irq;
418         }
419
420         mq = mbox_queue_alloc(mbox, mbox_txq_fn, mbox_tx_work);
421         if (!mq) {
422                 ret = -ENOMEM;
423                 goto fail_alloc_txq;
424         }
425         mbox->txq = mq;
426
427         mq = mbox_queue_alloc(mbox, mbox_rxq_fn, mbox_rx_work);
428         if (!mq) {
429                 ret = -ENOMEM;
430                 goto fail_alloc_rxq;
431         }
432         mbox->rxq = mq;
433
434         return 0;
435
436  fail_alloc_rxq:
437         mbox_queue_free(mbox->txq);
438  fail_alloc_txq:
439         free_irq(mbox->irq, mbox);
440  fail_request_irq:
441         if (unlikely(mbox->ops->shutdown))
442                 mbox->ops->shutdown(mbox);
443
444         return ret;
445 }
446
447 static void omap_mbox_fini(struct omap_mbox *mbox)
448 {
449         mbox_queue_free(mbox->txq);
450         mbox_queue_free(mbox->rxq);
451
452         free_irq(mbox->irq, mbox);
453
454         if (unlikely(mbox->ops->shutdown))
455                 mbox->ops->shutdown(mbox);
456 }
457
458 static struct omap_mbox **find_mboxes(const char *name)
459 {
460         struct omap_mbox **p;
461
462         for (p = &mboxes; *p; p = &(*p)->next) {
463                 if (strcmp((*p)->name, name) == 0)
464                         break;
465         }
466
467         return p;
468 }
469
470 struct omap_mbox *omap_mbox_get(const char *name)
471 {
472         struct omap_mbox *mbox;
473         int ret;
474
475         read_lock(&mboxes_lock);
476         mbox = *(find_mboxes(name));
477         if (mbox == NULL) {
478                 read_unlock(&mboxes_lock);
479                 return ERR_PTR(-ENOENT);
480         }
481
482         read_unlock(&mboxes_lock);
483
484         ret = omap_mbox_init(mbox);
485         if (ret)
486                 return ERR_PTR(-ENODEV);
487
488         return mbox;
489 }
490 EXPORT_SYMBOL(omap_mbox_get);
491
492 void omap_mbox_put(struct omap_mbox *mbox)
493 {
494         omap_mbox_fini(mbox);
495 }
496 EXPORT_SYMBOL(omap_mbox_put);
497
498 int omap_mbox_register(struct device *parent, struct omap_mbox *mbox)
499 {
500         int ret = 0;
501         struct omap_mbox **tmp;
502
503         if (!mbox)
504                 return -EINVAL;
505         if (mbox->next)
506                 return -EBUSY;
507
508         mbox->dev = device_create(&omap_mbox_class,
509                                   parent, 0, mbox, "%s", mbox->name);
510         if (IS_ERR(mbox->dev))
511                 return PTR_ERR(mbox->dev);
512
513         ret = device_create_file(mbox->dev, &dev_attr_mbox);
514         if (ret)
515                 goto err_sysfs;
516
517         write_lock(&mboxes_lock);
518         tmp = find_mboxes(mbox->name);
519         if (*tmp) {
520                 ret = -EBUSY;
521                 write_unlock(&mboxes_lock);
522                 goto err_find;
523         }
524         *tmp = mbox;
525         write_unlock(&mboxes_lock);
526
527         return 0;
528
529 err_find:
530         device_remove_file(mbox->dev, &dev_attr_mbox);
531 err_sysfs:
532         device_unregister(mbox->dev);
533         return ret;
534 }
535 EXPORT_SYMBOL(omap_mbox_register);
536
537 int omap_mbox_unregister(struct omap_mbox *mbox)
538 {
539         struct omap_mbox **tmp;
540
541         write_lock(&mboxes_lock);
542         tmp = &mboxes;
543         while (*tmp) {
544                 if (mbox == *tmp) {
545                         *tmp = mbox->next;
546                         mbox->next = NULL;
547                         write_unlock(&mboxes_lock);
548                         device_remove_file(mbox->dev, &dev_attr_mbox);
549                         device_unregister(mbox->dev);
550                         return 0;
551                 }
552                 tmp = &(*tmp)->next;
553         }
554         write_unlock(&mboxes_lock);
555
556         return -EINVAL;
557 }
558 EXPORT_SYMBOL(omap_mbox_unregister);
559
560 static int __init omap_mbox_class_init(void)
561 {
562         int ret = class_register(&omap_mbox_class);
563         if (!ret)
564                 ret = class_create_file(&omap_mbox_class, &class_attr_mbox);
565
566         return ret;
567 }
568
569 static void __exit omap_mbox_class_exit(void)
570 {
571         class_remove_file(&omap_mbox_class, &class_attr_mbox);
572         class_unregister(&omap_mbox_class);
573 }
574
575 subsys_initcall(omap_mbox_class_init);
576 module_exit(omap_mbox_class_exit);
577
578 MODULE_LICENSE("GPL v2");
579 MODULE_DESCRIPTION("omap mailbox: interrupt driven messaging");
580 MODULE_AUTHOR("Toshihiro Kobayashi and Hiroshi DOYU");