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/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>
  31 #include <linux/notifier.h>
  32 #include <linux/pm_qos_params.h>
  33
  34 #include <plat/mailbox.h>
  35
  36 static struct omap_mbox **mboxes;
  37
  38 static int mbox_configured;
  39 static DEFINE_MUTEX(mbox_configured_lock);
  40 struct pm_qos_request_list mbox_qos_request;
  41
  42 #define SET_MPU_CORE_CONSTRAINT 10
  43 #define CLEAR_MPU_CORE_CONSTRAINT -1
  44
  45 static unsigned int mbox_kfifo_size = CONFIG_OMAP_MBOX_KFIFO_SIZE;
  46 module_param(mbox_kfifo_size, uint, S_IRUGO);
  47 MODULE_PARM_DESC(mbox_kfifo_size, "Size of omap's mailbox kfifo (bytes)");
  48
  49 /* Mailbox FIFO handle functions */
  50 static inline mbox_msg_t mbox_fifo_read(struct omap_mbox *mbox)
  51 {
  52         return mbox->ops->fifo_read(mbox);
  53 }
  54 static inline void mbox_fifo_write(struct omap_mbox *mbox, mbox_msg_t msg)
  55 {
  56         mbox->ops->fifo_write(mbox, msg);
  57 }
  58 static inline int mbox_fifo_empty(struct omap_mbox *mbox)
  59 {
  60         return mbox->ops->fifo_empty(mbox);
  61 }
  62 static inline int mbox_fifo_full(struct omap_mbox *mbox)
  63 {
  64         return mbox->ops->fifo_full(mbox);
  65 }
  66
  67 /* Mailbox IRQ handle functions */
  68 static inline void ack_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
  69 {
  70         if (mbox->ops->ack_irq)
  71                 mbox->ops->ack_irq(mbox, irq);
  72 }
  73 static inline int is_mbox_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq)
  74 {
  75         return mbox->ops->is_irq(mbox, irq);
  76 }
  77
  78 /*
  79  * message sender
  80  */
  81 static int __mbox_poll_for_space(struct omap_mbox *mbox)
  82 {
  83         int ret = 0, i = 1000;
  84
  85         while (mbox_fifo_full(mbox)) {
  86                 if (mbox->ops->type == OMAP_MBOX_TYPE2)
  87                         return -1;
  88                 if (--i == 0)
  89                         return -1;
  90                 udelay(1);
  91         }
  92         return ret;
  93 }
  94
  95 int omap_mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg)
  96 {
  97         struct omap_mbox_queue *mq = mbox->txq;
  98         int ret = 0, len;
  99
 100         spin_lock_bh(&mq->lock);
 101
 102         if (kfifo_avail(&mq->fifo) < sizeof(msg)) {
 103                 ret = -ENOMEM;
 104                 goto out;
 105         }
 106
 107         if (kfifo_is_empty(&mq->fifo) && !__mbox_poll_for_space(mbox)) {
 108                 mbox_fifo_write(mbox, msg);
 109                 goto out;
 110         }
 111
 112         len = kfifo_in(&mq->fifo, (unsigned char *)&msg, sizeof(msg));
 113         WARN_ON(len != sizeof(msg));
 114
 115         tasklet_schedule(&mbox->txq->tasklet);
 116
 117 out:
 118         spin_unlock_bh(&mq->lock);
 119         return ret;
 120 }
 121 EXPORT_SYMBOL(omap_mbox_msg_send);
 122
 123 static void mbox_tx_tasklet(unsigned long tx_data)
 124 {
 125         struct omap_mbox *mbox = (struct omap_mbox *)tx_data;
 126         struct omap_mbox_queue *mq = mbox->txq;
 127         mbox_msg_t msg;
 128         int ret;
 129
 130         while (kfifo_len(&mq->fifo)) {
 131                 if (__mbox_poll_for_space(mbox)) {
 132                         omap_mbox_enable_irq(mbox, IRQ_TX);
 133                         break;
 134                 }
 135
 136                 ret = kfifo_out(&mq->fifo, (unsigned char *)&msg,
 137                                                                 sizeof(msg));
 138                 WARN_ON(ret != sizeof(msg));
 139
 140                 mbox_fifo_write(mbox, msg);
 141         }
 142 }
 143
 144 /*
 145  * Message receiver(workqueue)
 146  */
 147 static void mbox_rx_work(struct work_struct *work)
 148 {
 149         struct omap_mbox_queue *mq =
 150                         container_of(work, struct omap_mbox_queue, work);
 151         mbox_msg_t msg;
 152         int len;
 153
 154         while (kfifo_len(&mq->fifo) >= sizeof(msg)) {
 155                 len = kfifo_out(&mq->fifo, (unsigned char *)&msg, sizeof(msg));
 156                 WARN_ON(len != sizeof(msg));
 157
 158                 blocking_notifier_call_chain(&mq->mbox->notifier, len,
 159                                                                 (void *)msg);
 160                 spin_lock_irq(&mq->lock);
 161                 if (mq->full) {
 162                         mq->full = false;
 163                         omap_mbox_enable_irq(mq->mbox, IRQ_RX);
 164                 }
 165                 spin_unlock_irq(&mq->lock);
 166         }
 167 }
 168
 169 /*
 170  * Mailbox interrupt handler
 171  */
 172 static void __mbox_tx_interrupt(struct omap_mbox *mbox)
 173 {
 174         omap_mbox_disable_irq(mbox, IRQ_TX);
 175         ack_mbox_irq(mbox, IRQ_TX);
 176         tasklet_schedule(&mbox->txq->tasklet);
 177 }
 178
 179 static void __mbox_rx_interrupt(struct omap_mbox *mbox)
 180 {
 181         struct omap_mbox_queue *mq = mbox->rxq;
 182         mbox_msg_t msg;
 183         int len;
 184
 185         while (!mbox_fifo_empty(mbox)) {
 186                 if (unlikely(kfifo_avail(&mq->fifo) < sizeof(msg))) {
 187                         omap_mbox_disable_irq(mbox, IRQ_RX);
 188                         mq->full = true;
 189                         goto nomem;
 190                 }
 191
 192                 msg = mbox_fifo_read(mbox);
 193
 194                 len = kfifo_in(&mq->fifo, (unsigned char *)&msg, sizeof(msg));
 195                 WARN_ON(len != sizeof(msg));
 196
 197                 if (mbox->ops->type == OMAP_MBOX_TYPE1)
 198                         break;
 199         }
 200
 201         /* no more messages in the fifo. clear IRQ source. */
 202         ack_mbox_irq(mbox, IRQ_RX);
 203 nomem:
 204         schedule_work(&mbox->rxq->work);
 205 }
 206
 207 static irqreturn_t mbox_interrupt(int irq, void *p)
 208 {
 209         struct omap_mbox *mbox = p;
 210
 211         if (is_mbox_irq(mbox, IRQ_TX))
 212                 __mbox_tx_interrupt(mbox);
 213
 214         if (is_mbox_irq(mbox, IRQ_RX))
 215                 __mbox_rx_interrupt(mbox);
 216
 217         return IRQ_HANDLED;
 218 }
 219
 220 static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
 221                                         void (*work) (struct work_struct *),
 222                                         void (*tasklet)(unsigned long))
 223 {
 224         struct omap_mbox_queue *mq;
 225
 226         mq = kzalloc(sizeof(struct omap_mbox_queue), GFP_KERNEL);
 227         if (!mq)
 228                 return NULL;
 229
 230         spin_lock_init(&mq->lock);
 231
 232         if (kfifo_alloc(&mq->fifo, mbox_kfifo_size, GFP_KERNEL))
 233                 goto error;
 234
 235         if (work)
 236                 INIT_WORK(&mq->work, work);
 237
 238         if (tasklet)
 239                 tasklet_init(&mq->tasklet, tasklet, (unsigned long)mbox);
 240         return mq;
 241 error:
 242         kfree(mq);
 243         return NULL;
 244 }
 245
 246 static void mbox_queue_free(struct omap_mbox_queue *q)
 247 {
 248         kfifo_free(&q->fifo);
 249         kfree(q);
 250 }
 251
 252 static int omap_mbox_startup(struct omap_mbox *mbox)
 253 {
 254         int ret = 0;
 255         struct omap_mbox_queue *mq;
 256
 257         mutex_lock(&mbox_configured_lock);
 258         if (!mbox_configured++) {
 259                 pm_qos_update_request(&mbox_qos_request,
 260                                         SET_MPU_CORE_CONSTRAINT);
 261                 if (likely(mbox->ops->startup)) {
 262                         ret = mbox->ops->startup(mbox);
 263                         if (unlikely(ret))
 264                                 goto fail_startup;
 265                 } else
 266                         goto fail_startup;
 267         }
 268
 269         if (!mbox->use_count++) {
 270                 mq = mbox_queue_alloc(mbox, NULL, mbox_tx_tasklet);
 271                 if (!mq) {
 272                         ret = -ENOMEM;
 273                         goto fail_alloc_txq;
 274                 }
 275                 mbox->txq = mq;
 276
 277                 mq = mbox_queue_alloc(mbox, mbox_rx_work, NULL);
 278                 if (!mq) {
 279                         ret = -ENOMEM;
 280                         goto fail_alloc_rxq;
 281                 }
 282                 mbox->rxq = mq;
 283                 mq->mbox = mbox;
 284                 ret = request_irq(mbox->irq, mbox_interrupt, IRQF_SHARED,
 285                                                         mbox->name, mbox);
 286                 if (unlikely(ret)) {
 287                         pr_err("failed to register mailbox interrupt:%d\n",
 288                                                                         ret);
 289                         goto fail_request_irq;
 290                 }
 291         }
 292         mutex_unlock(&mbox_configured_lock);
 293         return 0;
 294
 295 fail_request_irq:
 296         mbox_queue_free(mbox->rxq);
 297 fail_alloc_rxq:
 298         mbox_queue_free(mbox->txq);
 299 fail_alloc_txq:
 300         if (mbox->ops->shutdown)
 301                 mbox->ops->shutdown(mbox);
 302         mbox->use_count--;
 303 fail_startup:
 304         if (!--mbox_configured)
 305                 pm_qos_update_request(&mbox_qos_request,
 306                                          CLEAR_MPU_CORE_CONSTRAINT);
 307         mutex_unlock(&mbox_configured_lock);
 308         return ret;
 309 }
 310
 311 static void omap_mbox_fini(struct omap_mbox *mbox)
 312 {
 313         mutex_lock(&mbox_configured_lock);
 314
 315         if (!--mbox->use_count) {
 316                 free_irq(mbox->irq, mbox);
 317                 tasklet_kill(&mbox->txq->tasklet);
 318                 flush_work_sync(&mbox->rxq->work);
 319                 mbox_queue_free(mbox->txq);
 320                 mbox_queue_free(mbox->rxq);
 321         }
 322
 323         if (likely(mbox->ops->shutdown)) {
 324                 if (!--mbox_configured) {
 325                         mbox->ops->shutdown(mbox);
 326                         pm_qos_update_request(&mbox_qos_request,
 327                                                 CLEAR_MPU_CORE_CONSTRAINT);
 328                 }
 329         }
 330
 331         mutex_unlock(&mbox_configured_lock);
 332 }
 333
 334 struct omap_mbox *omap_mbox_get(const char *name, struct notifier_block *nb)
 335 {
 336         struct omap_mbox *_mbox, *mbox = NULL;
 337         int i, ret;
 338
 339         if (!mboxes)
 340                 return ERR_PTR(-EINVAL);
 341
 342         for (i = 0; (_mbox = mboxes[i]); i++) {
 343                 if (!strcmp(_mbox->name, name)) {
 344                         mbox = _mbox;
 345                         break;
 346                 }
 347         }
 348
 349         if (!mbox)
 350                 return ERR_PTR(-ENOENT);
 351
 352         ret = omap_mbox_startup(mbox);
 353         if (ret)
 354                 return ERR_PTR(-ENODEV);
 355
 356         if (nb)
 357                 blocking_notifier_chain_register(&mbox->notifier, nb);
 358
 359         return mbox;
 360 }
 361 EXPORT_SYMBOL(omap_mbox_get);
 362
 363 void omap_mbox_put(struct omap_mbox *mbox, struct notifier_block *nb)
 364 {
 365         if (nb)
 366                 blocking_notifier_chain_unregister(&mbox->notifier, nb);
 367         omap_mbox_fini(mbox);
 368 }
 369 EXPORT_SYMBOL(omap_mbox_put);
 370
 371 static struct class omap_mbox_class = { .name = "mbox", };
 372
 373 int omap_mbox_register(struct device *parent, struct omap_mbox **list)
 374 {
 375         int ret;
 376         int i;
 377
 378         mboxes = list;
 379         if (!mboxes)
 380                 return -EINVAL;
 381
 382         for (i = 0; mboxes[i]; i++) {
 383                 struct omap_mbox *mbox = mboxes[i];
 384                 mbox->dev = device_create(&omap_mbox_class,
 385                                 parent, 0, mbox, "%s", mbox->name);
 386                 if (IS_ERR(mbox->dev)) {
 387                         ret = PTR_ERR(mbox->dev);
 388                         goto err_out;
 389                 }
 390
 391                 BLOCKING_INIT_NOTIFIER_HEAD(&mbox->notifier);
 392         }
 393         return 0;
 394
 395 err_out:
 396         while (i--)
 397                 device_unregister(mboxes[i]->dev);
 398         return ret;
 399 }
 400 EXPORT_SYMBOL(omap_mbox_register);
 401
 402 int omap_mbox_unregister(void)
 403 {
 404         int i;
 405
 406         if (!mboxes)
 407                 return -EINVAL;
 408
 409         for (i = 0; mboxes[i]; i++)
 410                 device_unregister(mboxes[i]->dev);
 411
 412         mboxes = NULL;
 413         return 0;
 414 }
 415 EXPORT_SYMBOL(omap_mbox_unregister);
 416
 417 static int __init omap_mbox_init(void)
 418 {
 419         int err;
 420
 421         err = class_register(&omap_mbox_class);
 422         if (err)
 423                 return err;
 424
 425         /* kfifo size sanity check: alignment and minimal size */
 426         mbox_kfifo_size = ALIGN(mbox_kfifo_size, sizeof(mbox_msg_t));
 427         mbox_kfifo_size = max_t(unsigned int, mbox_kfifo_size,
 428                                                         sizeof(mbox_msg_t));
 429
 430         pm_qos_add_request(&mbox_qos_request, PM_QOS_CPU_DMA_LATENCY,
 431                                                 PM_QOS_DEFAULT_VALUE);
 432         return 0;
 433 }
 434 subsys_initcall(omap_mbox_init);
 435
 436 static void __exit omap_mbox_exit(void)
 437 {
 438         class_unregister(&omap_mbox_class);
 439         pm_qos_remove_request(&mbox_qos_request);
 440 }
 441 module_exit(omap_mbox_exit);
 442
 443 MODULE_LICENSE("GPL v2");
 444 MODULE_DESCRIPTION("omap mailbox: interrupt driven messaging");
 445 MODULE_AUTHOR("Toshihiro Kobayashi");
 446 MODULE_AUTHOR("Hiroshi DOYU");