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 struct omap_msg_tx_data {
 151         mbox_msg_t      msg;
 152         void            *arg;
 153 };
 154
 155 static void omap_msg_tx_end_io(struct request *rq, int error)
 156 {
 157         kfree(rq->special);
 158         __blk_put_request(rq->q, rq);
 159 }
 160
 161 int omap_mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg, void* arg)
 162 {
 163         struct omap_msg_tx_data *tx_data;
 164         struct request *rq;
 165         struct request_queue *q = mbox->txq->queue;
 166
 167         tx_data = kmalloc(sizeof(*tx_data), GFP_ATOMIC);
 168         if (unlikely(!tx_data))
 169                 return -ENOMEM;
 170
 171         rq = blk_get_request(q, WRITE, GFP_ATOMIC);
 172         if (unlikely(!rq)) {
 173                 kfree(tx_data);
 174                 return -ENOMEM;
 175         }
 176
 177         tx_data->msg = msg;
 178         tx_data->arg = arg;
 179         rq->end_io = omap_msg_tx_end_io;
 180         blk_insert_request(q, rq, 0, tx_data);
 181
 182         schedule_work(&mbox->txq->work);
 183         return 0;
 184 }
 185 EXPORT_SYMBOL(omap_mbox_msg_send);
 186
 187 static void mbox_tx_work(struct work_struct *work)
 188 {
 189         int ret;
 190         struct request *rq;
 191         struct omap_mbox_queue *mq = container_of(work,
 192                                 struct omap_mbox_queue, work);
 193         struct omap_mbox *mbox = mq->queue->queuedata;
 194         struct request_queue *q = mbox->txq->queue;
 195
 196         while (1) {
 197                 struct omap_msg_tx_data *tx_data;
 198
 199                 spin_lock(q->queue_lock);
 200                 rq = blk_fetch_request(q);
 201                 spin_unlock(q->queue_lock);
 202
 203                 if (!rq)
 204                         break;
 205
 206                 tx_data = rq->special;
 207
 208                 ret = __mbox_msg_send(mbox, tx_data->msg, tx_data->arg);
 209                 if (ret) {
 210                         enable_mbox_irq(mbox, IRQ_TX);
 211                         spin_lock(q->queue_lock);
 212                         blk_requeue_request(q, rq);
 213                         spin_unlock(q->queue_lock);
 214                         return;
 215                 }
 216
 217                 spin_lock(q->queue_lock);
 218                 __blk_end_request_all(rq, 0);
 219                 spin_unlock(q->queue_lock);
 220         }
 221 }
 222
 223 /*
 224  * Message receiver(workqueue)
 225  */
 226 static void mbox_rx_work(struct work_struct *work)
 227 {
 228         struct omap_mbox_queue *mq =
 229                         container_of(work, struct omap_mbox_queue, work);
 230         struct omap_mbox *mbox = mq->queue->queuedata;
 231         struct request_queue *q = mbox->rxq->queue;
 232         struct request *rq;
 233         mbox_msg_t msg;
 234         unsigned long flags;
 235
 236         if (mbox->rxq->callback == NULL) {
 237                 sysfs_notify(&mbox->dev->kobj, NULL, "mbox");
 238                 return;
 239         }
 240
 241         while (1) {
 242                 spin_lock_irqsave(q->queue_lock, flags);
 243                 rq = blk_fetch_request(q);
 244                 spin_unlock_irqrestore(q->queue_lock, flags);
 245                 if (!rq)
 246                         break;
 247
 248                 msg = (mbox_msg_t)rq->special;
 249                 blk_end_request_all(rq, 0);
 250                 mbox->rxq->callback((void *)msg);
 251         }
 252 }
 253
 254 /*
 255  * Mailbox interrupt handler
 256  */
 257 static void mbox_txq_fn(struct request_queue * q)
 258 {
 259 }
 260
 261 static void mbox_rxq_fn(struct request_queue * q)
 262 {
 263 }
 264
 265 static void __mbox_tx_interrupt(struct omap_mbox *mbox)
 266 {
 267         disable_mbox_irq(mbox, IRQ_TX);
 268         ack_mbox_irq(mbox, IRQ_TX);
 269         schedule_work(&mbox->txq->work);
 270 }
 271
 272 static void __mbox_rx_interrupt(struct omap_mbox *mbox)
 273 {
 274         struct request *rq;
 275         mbox_msg_t msg;
 276         struct request_queue *q = mbox->rxq->queue;
 277
 278         disable_mbox_irq(mbox, IRQ_RX);
 279
 280         while (!mbox_fifo_empty(mbox)) {
 281                 rq = blk_get_request(q, WRITE, GFP_ATOMIC);
 282                 if (unlikely(!rq))
 283                         goto nomem;
 284
 285                 msg = mbox_fifo_read(mbox);
 286
 287                 if (unlikely(mbox_seq_test(mbox, msg))) {
 288                         pr_info("mbox: Illegal seq bit!(%08x)\n", msg);
 289                         if (mbox->err_notify)
 290                                 mbox->err_notify();
 291                 }
 292
 293                 blk_insert_request(q, rq, 0, (void *)msg);
 294                 if (mbox->ops->type == OMAP_MBOX_TYPE1)
 295                         break;
 296         }
 297
 298         /* no more messages in the fifo. clear IRQ source. */
 299         ack_mbox_irq(mbox, IRQ_RX);
 300         enable_mbox_irq(mbox, IRQ_RX);
 301 nomem:
 302         schedule_work(&mbox->rxq->work);
 303 }
 304
 305 static irqreturn_t mbox_interrupt(int irq, void *p)
 306 {
 307         struct omap_mbox *mbox = p;
 308
 309         if (is_mbox_irq(mbox, IRQ_TX))
 310                 __mbox_tx_interrupt(mbox);
 311
 312         if (is_mbox_irq(mbox, IRQ_RX))
 313                 __mbox_rx_interrupt(mbox);
 314
 315         return IRQ_HANDLED;
 316 }
 317
 318 /*
 319  * sysfs files
 320  */
 321 static ssize_t
 322 omap_mbox_write(struct device *dev, struct device_attribute *attr,
 323                 const char * buf, size_t count)
 324 {
 325         int ret;
 326         mbox_msg_t *p = (mbox_msg_t *)buf;
 327         struct omap_mbox *mbox = dev_get_drvdata(dev);
 328
 329         for (; count >= sizeof(mbox_msg_t); count -= sizeof(mbox_msg_t)) {
 330                 ret = omap_mbox_msg_send(mbox, be32_to_cpu(*p), NULL);
 331                 if (ret)
 332                         return -EAGAIN;
 333                 p++;
 334         }
 335
 336         return (size_t)((char *)p - buf);
 337 }
 338
 339 static ssize_t
 340 omap_mbox_read(struct device *dev, struct device_attribute *attr, char *buf)
 341 {
 342         unsigned long flags;
 343         struct request *rq;
 344         mbox_msg_t *p = (mbox_msg_t *) buf;
 345         struct omap_mbox *mbox = dev_get_drvdata(dev);
 346         struct request_queue *q = mbox->rxq->queue;
 347
 348         while (1) {
 349                 spin_lock_irqsave(q->queue_lock, flags);
 350                 rq = blk_fetch_request(q);
 351                 spin_unlock_irqrestore(q->queue_lock, flags);
 352
 353                 if (!rq)
 354                         break;
 355
 356                 *p = (mbox_msg_t)rq->special;
 357
 358                 blk_end_request_all(rq, 0);
 359
 360                 if (unlikely(mbox_seq_test(mbox, *p))) {
 361                         pr_info("mbox: Illegal seq bit!(%08x) ignored\n", *p);
 362                         continue;
 363                 }
 364                 p++;
 365         }
 366
 367         pr_debug("%02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);
 368
 369         return (size_t) ((char *)p - buf);
 370 }
 371
 372 static DEVICE_ATTR(mbox, S_IRUGO | S_IWUSR, omap_mbox_read, omap_mbox_write);
 373
 374 static ssize_t mbox_show(struct class *class, char *buf)
 375 {
 376         return sprintf(buf, "mbox");
 377 }
 378
 379 static CLASS_ATTR(mbox, S_IRUGO, mbox_show, NULL);
 380
 381 static struct class omap_mbox_class = {
 382         .name = "omap-mailbox",
 383 };
 384
 385 static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
 386                                         request_fn_proc * proc,
 387                                         void (*work) (struct work_struct *))
 388 {
 389         struct request_queue *q;
 390         struct omap_mbox_queue *mq;
 391
 392         mq = kzalloc(sizeof(struct omap_mbox_queue), GFP_KERNEL);
 393         if (!mq)
 394                 return NULL;
 395
 396         spin_lock_init(&mq->lock);
 397
 398         q = blk_init_queue(proc, &mq->lock);
 399         if (!q)
 400                 goto error;
 401         q->queuedata = mbox;
 402         mq->queue = q;
 403
 404         INIT_WORK(&mq->work, work);
 405
 406         return mq;
 407 error:
 408         kfree(mq);
 409         return NULL;
 410 }
 411
 412 static void mbox_queue_free(struct omap_mbox_queue *q)
 413 {
 414         blk_cleanup_queue(q->queue);
 415         kfree(q);
 416 }
 417
 418 static int omap_mbox_init(struct omap_mbox *mbox)
 419 {
 420         int ret;
 421         struct omap_mbox_queue *mq;
 422
 423         if (likely(mbox->ops->startup)) {
 424                 ret = mbox->ops->startup(mbox);
 425                 if (unlikely(ret))
 426                         return ret;
 427         }
 428
 429         ret = request_irq(mbox->irq, mbox_interrupt, IRQF_DISABLED,
 430                                 mbox->name, mbox);
 431         if (unlikely(ret)) {
 432                 printk(KERN_ERR
 433                         "failed to register mailbox interrupt:%d\n", ret);
 434                 goto fail_request_irq;
 435         }
 436
 437         mq = mbox_queue_alloc(mbox, mbox_txq_fn, mbox_tx_work);
 438         if (!mq) {
 439                 ret = -ENOMEM;
 440                 goto fail_alloc_txq;
 441         }
 442         mbox->txq = mq;
 443
 444         mq = mbox_queue_alloc(mbox, mbox_rxq_fn, mbox_rx_work);
 445         if (!mq) {
 446                 ret = -ENOMEM;
 447                 goto fail_alloc_rxq;
 448         }
 449         mbox->rxq = mq;
 450
 451         return 0;
 452
 453  fail_alloc_rxq:
 454         mbox_queue_free(mbox->txq);
 455  fail_alloc_txq:
 456         free_irq(mbox->irq, mbox);
 457  fail_request_irq:
 458         if (unlikely(mbox->ops->shutdown))
 459                 mbox->ops->shutdown(mbox);
 460
 461         return ret;
 462 }
 463
 464 static void omap_mbox_fini(struct omap_mbox *mbox)
 465 {
 466         mbox_queue_free(mbox->txq);
 467         mbox_queue_free(mbox->rxq);
 468
 469         free_irq(mbox->irq, mbox);
 470
 471         if (unlikely(mbox->ops->shutdown))
 472                 mbox->ops->shutdown(mbox);
 473 }
 474
 475 static struct omap_mbox **find_mboxes(const char *name)
 476 {
 477         struct omap_mbox **p;
 478
 479         for (p = &mboxes; *p; p = &(*p)->next) {
 480                 if (strcmp((*p)->name, name) == 0)
 481                         break;
 482         }
 483
 484         return p;
 485 }
 486
 487 struct omap_mbox *omap_mbox_get(const char *name)
 488 {
 489         struct omap_mbox *mbox;
 490         int ret;
 491
 492         read_lock(&mboxes_lock);
 493         mbox = *(find_mboxes(name));
 494         if (mbox == NULL) {
 495                 read_unlock(&mboxes_lock);
 496                 return ERR_PTR(-ENOENT);
 497         }
 498
 499         read_unlock(&mboxes_lock);
 500
 501         ret = omap_mbox_init(mbox);
 502         if (ret)
 503                 return ERR_PTR(-ENODEV);
 504
 505         return mbox;
 506 }
 507 EXPORT_SYMBOL(omap_mbox_get);
 508
 509 void omap_mbox_put(struct omap_mbox *mbox)
 510 {
 511         omap_mbox_fini(mbox);
 512 }
 513 EXPORT_SYMBOL(omap_mbox_put);
 514
 515 int omap_mbox_register(struct device *parent, struct omap_mbox *mbox)
 516 {
 517         int ret = 0;
 518         struct omap_mbox **tmp;
 519
 520         if (!mbox)
 521                 return -EINVAL;
 522         if (mbox->next)
 523                 return -EBUSY;
 524
 525         mbox->dev = device_create(&omap_mbox_class,
 526                                   parent, 0, mbox, "%s", mbox->name);
 527         if (IS_ERR(mbox->dev))
 528                 return PTR_ERR(mbox->dev);
 529
 530         ret = device_create_file(mbox->dev, &dev_attr_mbox);
 531         if (ret)
 532                 goto err_sysfs;
 533
 534         write_lock(&mboxes_lock);
 535         tmp = find_mboxes(mbox->name);
 536         if (*tmp) {
 537                 ret = -EBUSY;
 538                 write_unlock(&mboxes_lock);
 539                 goto err_find;
 540         }
 541         *tmp = mbox;
 542         write_unlock(&mboxes_lock);
 543
 544         return 0;
 545
 546 err_find:
 547         device_remove_file(mbox->dev, &dev_attr_mbox);
 548 err_sysfs:
 549         device_unregister(mbox->dev);
 550         return ret;
 551 }
 552 EXPORT_SYMBOL(omap_mbox_register);
 553
 554 int omap_mbox_unregister(struct omap_mbox *mbox)
 555 {
 556         struct omap_mbox **tmp;
 557
 558         write_lock(&mboxes_lock);
 559         tmp = &mboxes;
 560         while (*tmp) {
 561                 if (mbox == *tmp) {
 562                         *tmp = mbox->next;
 563                         mbox->next = NULL;
 564                         write_unlock(&mboxes_lock);
 565                         device_remove_file(mbox->dev, &dev_attr_mbox);
 566                         device_unregister(mbox->dev);
 567                         return 0;
 568                 }
 569                 tmp = &(*tmp)->next;
 570         }
 571         write_unlock(&mboxes_lock);
 572
 573         return -EINVAL;
 574 }
 575 EXPORT_SYMBOL(omap_mbox_unregister);
 576
 577 static int __init omap_mbox_class_init(void)
 578 {
 579         int ret = class_register(&omap_mbox_class);
 580         if (!ret)
 581                 ret = class_create_file(&omap_mbox_class, &class_attr_mbox);
 582
 583         return ret;
 584 }
 585
 586 static void __exit omap_mbox_class_exit(void)
 587 {
 588         class_remove_file(&omap_mbox_class, &class_attr_mbox);
 589         class_unregister(&omap_mbox_class);
 590 }
 591
 592 subsys_initcall(omap_mbox_class_init);
 593 module_exit(omap_mbox_class_exit);
 594
 595 MODULE_LICENSE("GPL v2");
 596 MODULE_DESCRIPTION("omap mailbox: interrupt driven messaging");
 597 MODULE_AUTHOR("Toshihiro Kobayashi and Hiroshi DOYU");