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 <plat/mailbox.h>
  30
  31 static struct workqueue_struct *mboxd;
  32 static struct omap_mbox *mboxes;
  33 static DEFINE_RWLOCK(mboxes_lock);
  34
  35 static int mbox_configured;
  36
  37 /* Mailbox FIFO handle functions */
  38 static inline mbox_msg_t mbox_fifo_read(struct omap_mbox *mbox)
  39 {
  40         return mbox->ops->fifo_read(mbox);
  41 }
  42 static inline void mbox_fifo_write(struct omap_mbox *mbox, mbox_msg_t msg)
  43 {
  44         mbox->ops->fifo_write(mbox, msg);
  45 }
  46 static inline int mbox_fifo_empty(struct omap_mbox *mbox)
  47 {
  48         return mbox->ops->fifo_empty(mbox);
  49 }
  50 static inline int mbox_fifo_full(struct omap_mbox *mbox)
  51 {
  52         return mbox->ops->fifo_full(mbox);
  53 }
  54
  55 /* Mailbox IRQ handle functions */
  56 static inline void ack_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
  57 {
  58         if (mbox->ops->ack_irq)
  59                 mbox->ops->ack_irq(mbox, irq);
  60 }
  61 static inline int is_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
  62 {
  63         return mbox->ops->is_irq(mbox, irq);
  64 }
  65
  66 /*
  67  * message sender
  68  */
  69 static int __mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg)
  70 {
  71         int ret = 0, i = 1000;
  72
  73         while (mbox_fifo_full(mbox)) {
  74                 if (mbox->ops->type == OMAP_MBOX_TYPE2)
  75                         return -1;
  76                 if (--i == 0)
  77                         return -1;
  78                 udelay(1);
  79         }
  80         mbox_fifo_write(mbox, msg);
  81         return ret;
  82 }
  83
  84
  85 int omap_mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg)
  86 {
  87
  88         struct request *rq;
  89         struct request_queue *q = mbox->txq->queue;
  90
  91         rq = blk_get_request(q, WRITE, GFP_ATOMIC);
  92         if (unlikely(!rq))
  93                 return -ENOMEM;
  94
  95         blk_insert_request(q, rq, 0, (void *) msg);
  96         tasklet_schedule(&mbox->txq->tasklet);
  97
  98         return 0;
  99 }
 100 EXPORT_SYMBOL(omap_mbox_msg_send);
 101
 102 static void mbox_tx_tasklet(unsigned long tx_data)
 103 {
 104         int ret;
 105         struct request *rq;
 106         struct omap_mbox *mbox = (struct omap_mbox *)tx_data;
 107         struct request_queue *q = mbox->txq->queue;
 108
 109         while (1) {
 110
 111                 rq = blk_fetch_request(q);
 112
 113                 if (!rq)
 114                         break;
 115
 116                 ret = __mbox_msg_send(mbox, (mbox_msg_t)rq->special);
 117                 if (ret) {
 118                         omap_mbox_enable_irq(mbox, IRQ_TX);
 119                         blk_requeue_request(q, rq);
 120                         return;
 121                 }
 122                 blk_end_request_all(rq, 0);
 123         }
 124 }
 125
 126 /*
 127  * Message receiver(workqueue)
 128  */
 129 static void mbox_rx_work(struct work_struct *work)
 130 {
 131         struct omap_mbox_queue *mq =
 132                         container_of(work, struct omap_mbox_queue, work);
 133         struct omap_mbox *mbox = mq->queue->queuedata;
 134         struct request_queue *q = mbox->rxq->queue;
 135         struct request *rq;
 136         mbox_msg_t msg;
 137         unsigned long flags;
 138
 139         while (1) {
 140                 spin_lock_irqsave(q->queue_lock, flags);
 141                 rq = blk_fetch_request(q);
 142                 spin_unlock_irqrestore(q->queue_lock, flags);
 143                 if (!rq)
 144                         break;
 145
 146                 msg = (mbox_msg_t)rq->special;
 147                 blk_end_request_all(rq, 0);
 148                 mbox->rxq->callback((void *)msg);
 149         }
 150 }
 151
 152 /*
 153  * Mailbox interrupt handler
 154  */
 155 static void mbox_txq_fn(struct request_queue *q)
 156 {
 157 }
 158
 159 static void mbox_rxq_fn(struct request_queue *q)
 160 {
 161 }
 162
 163 static void __mbox_tx_interrupt(struct omap_mbox *mbox)
 164 {
 165         omap_mbox_disable_irq(mbox, IRQ_TX);
 166         ack_mbox_irq(mbox, IRQ_TX);
 167         tasklet_schedule(&mbox->txq->tasklet);
 168 }
 169
 170 static void __mbox_rx_interrupt(struct omap_mbox *mbox)
 171 {
 172         struct request *rq;
 173         mbox_msg_t msg;
 174         struct request_queue *q = mbox->rxq->queue;
 175
 176         while (!mbox_fifo_empty(mbox)) {
 177                 rq = blk_get_request(q, WRITE, GFP_ATOMIC);
 178                 if (unlikely(!rq))
 179                         goto nomem;
 180
 181                 msg = mbox_fifo_read(mbox);
 182
 183
 184                 blk_insert_request(q, rq, 0, (void *)msg);
 185                 if (mbox->ops->type == OMAP_MBOX_TYPE1)
 186                         break;
 187         }
 188
 189         /* no more messages in the fifo. clear IRQ source. */
 190         ack_mbox_irq(mbox, IRQ_RX);
 191 nomem:
 192         queue_work(mboxd, &mbox->rxq->work);
 193 }
 194
 195 static irqreturn_t mbox_interrupt(int irq, void *p)
 196 {
 197         struct omap_mbox *mbox = p;
 198
 199         if (is_mbox_irq(mbox, IRQ_TX))
 200                 __mbox_tx_interrupt(mbox);
 201
 202         if (is_mbox_irq(mbox, IRQ_RX))
 203                 __mbox_rx_interrupt(mbox);
 204
 205         return IRQ_HANDLED;
 206 }
 207
 208 static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
 209                                         request_fn_proc *proc,
 210                                         void (*work) (struct work_struct *),
 211                                         void (*tasklet)(unsigned long))
 212 {
 213         struct request_queue *q;
 214         struct omap_mbox_queue *mq;
 215
 216         mq = kzalloc(sizeof(struct omap_mbox_queue), GFP_KERNEL);
 217         if (!mq)
 218                 return NULL;
 219
 220         spin_lock_init(&mq->lock);
 221
 222         q = blk_init_queue(proc, &mq->lock);
 223         if (!q)
 224                 goto error;
 225         q->queuedata = mbox;
 226         mq->queue = q;
 227
 228         if (work)
 229                 INIT_WORK(&mq->work, work);
 230
 231         if (tasklet)
 232                 tasklet_init(&mq->tasklet, tasklet, (unsigned long)mbox);
 233         return mq;
 234 error:
 235         kfree(mq);
 236         return NULL;
 237 }
 238
 239 static void mbox_queue_free(struct omap_mbox_queue *q)
 240 {
 241         blk_cleanup_queue(q->queue);
 242         kfree(q);
 243 }
 244
 245 static int omap_mbox_startup(struct omap_mbox *mbox)
 246 {
 247         int ret = 0;
 248         struct omap_mbox_queue *mq;
 249
 250         if (likely(mbox->ops->startup)) {
 251                 write_lock(&mboxes_lock);
 252                 if (!mbox_configured)
 253                         ret = mbox->ops->startup(mbox);
 254
 255                 if (unlikely(ret)) {
 256                         write_unlock(&mboxes_lock);
 257                         return ret;
 258                 }
 259                 mbox_configured++;
 260                 write_unlock(&mboxes_lock);
 261         }
 262
 263         ret = request_irq(mbox->irq, mbox_interrupt, IRQF_SHARED,
 264                                 mbox->name, mbox);
 265         if (unlikely(ret)) {
 266                 printk(KERN_ERR
 267                         "failed to register mailbox interrupt:%d\n", ret);
 268                 goto fail_request_irq;
 269         }
 270
 271         mq = mbox_queue_alloc(mbox, mbox_txq_fn, NULL, mbox_tx_tasklet);
 272         if (!mq) {
 273                 ret = -ENOMEM;
 274                 goto fail_alloc_txq;
 275         }
 276         mbox->txq = mq;
 277
 278         mq = mbox_queue_alloc(mbox, mbox_rxq_fn, mbox_rx_work, NULL);
 279         if (!mq) {
 280                 ret = -ENOMEM;
 281                 goto fail_alloc_rxq;
 282         }
 283         mbox->rxq = mq;
 284
 285         return 0;
 286
 287  fail_alloc_rxq:
 288         mbox_queue_free(mbox->txq);
 289  fail_alloc_txq:
 290         free_irq(mbox->irq, mbox);
 291  fail_request_irq:
 292         if (unlikely(mbox->ops->shutdown))
 293                 mbox->ops->shutdown(mbox);
 294
 295         return ret;
 296 }
 297
 298 static void omap_mbox_fini(struct omap_mbox *mbox)
 299 {
 300         mbox_queue_free(mbox->txq);
 301         mbox_queue_free(mbox->rxq);
 302
 303         free_irq(mbox->irq, mbox);
 304
 305         if (unlikely(mbox->ops->shutdown)) {
 306                 write_lock(&mboxes_lock);
 307                 if (mbox_configured > 0)
 308                         mbox_configured--;
 309                 if (!mbox_configured)
 310                         mbox->ops->shutdown(mbox);
 311                 write_unlock(&mboxes_lock);
 312         }
 313 }
 314
 315 static struct omap_mbox **find_mboxes(const char *name)
 316 {
 317         struct omap_mbox **p;
 318
 319         for (p = &mboxes; *p; p = &(*p)->next) {
 320                 if (strcmp((*p)->name, name) == 0)
 321                         break;
 322         }
 323
 324         return p;
 325 }
 326
 327 struct omap_mbox *omap_mbox_get(const char *name)
 328 {
 329         struct omap_mbox *mbox;
 330         int ret;
 331
 332         read_lock(&mboxes_lock);
 333         mbox = *(find_mboxes(name));
 334         if (mbox == NULL) {
 335                 read_unlock(&mboxes_lock);
 336                 return ERR_PTR(-ENOENT);
 337         }
 338
 339         read_unlock(&mboxes_lock);
 340
 341         ret = omap_mbox_startup(mbox);
 342         if (ret)
 343                 return ERR_PTR(-ENODEV);
 344
 345         return mbox;
 346 }
 347 EXPORT_SYMBOL(omap_mbox_get);
 348
 349 void omap_mbox_put(struct omap_mbox *mbox)
 350 {
 351         omap_mbox_fini(mbox);
 352 }
 353 EXPORT_SYMBOL(omap_mbox_put);
 354
 355 int omap_mbox_register(struct device *parent, struct omap_mbox *mbox)
 356 {
 357         int ret = 0;
 358         struct omap_mbox **tmp;
 359
 360         if (!mbox)
 361                 return -EINVAL;
 362         if (mbox->next)
 363                 return -EBUSY;
 364
 365         write_lock(&mboxes_lock);
 366         tmp = find_mboxes(mbox->name);
 367         if (*tmp) {
 368                 ret = -EBUSY;
 369                 write_unlock(&mboxes_lock);
 370                 goto err_find;
 371         }
 372         *tmp = mbox;
 373         write_unlock(&mboxes_lock);
 374
 375         return 0;
 376
 377 err_find:
 378         return ret;
 379 }
 380 EXPORT_SYMBOL(omap_mbox_register);
 381
 382 int omap_mbox_unregister(struct omap_mbox *mbox)
 383 {
 384         struct omap_mbox **tmp;
 385
 386         write_lock(&mboxes_lock);
 387         tmp = &mboxes;
 388         while (*tmp) {
 389                 if (mbox == *tmp) {
 390                         *tmp = mbox->next;
 391                         mbox->next = NULL;
 392                         write_unlock(&mboxes_lock);
 393                         return 0;
 394                 }
 395                 tmp = &(*tmp)->next;
 396         }
 397         write_unlock(&mboxes_lock);
 398
 399         return -EINVAL;
 400 }
 401 EXPORT_SYMBOL(omap_mbox_unregister);
 402
 403 static int __init omap_mbox_init(void)
 404 {
 405         mboxd = create_workqueue("mboxd");
 406         if (!mboxd)
 407                 return -ENOMEM;
 408
 409         return 0;
 410 }
 411 module_init(omap_mbox_init);
 412
 413 static void __exit omap_mbox_exit(void)
 414 {
 415         destroy_workqueue(mboxd);
 416 }
 417 module_exit(omap_mbox_exit);
 418
 419 MODULE_LICENSE("GPL v2");
 420 MODULE_DESCRIPTION("omap mailbox: interrupt driven messaging");
 421 MODULE_AUTHOR("Toshihiro Kobayashi and Hiroshi DOYU");