kernel/drivers/mailbox/mailbox.c

   1 /*
   2  * Mailbox: Common code for Mailbox controllers and users
   3  *
   4  * Copyright (C) 2013-2014 Linaro Ltd.
   5  * Author: Jassi Brar <jassisinghbrar@gmail.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/interrupt.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/mutex.h>
  15 #include <linux/delay.h>
  16 #include <linux/slab.h>
  17 #include <linux/err.h>
  18 #include <linux/module.h>
  19 #include <linux/device.h>
  20 #include <linux/bitops.h>
  21 #include <linux/mailbox_client.h>
  22 #include <linux/mailbox_controller.h>
  23
  24 #include "mailbox.h"
  25
  26 static LIST_HEAD(mbox_cons);
  27 static DEFINE_MUTEX(con_mutex);
  28
  29 static void poll_txdone(unsigned long data);
  30
  31 static int add_to_rbuf(struct mbox_chan *chan, void *mssg)
  32 {
  33         int idx;
  34         unsigned long flags;
  35
  36         spin_lock_irqsave(&chan->lock, flags);
  37
  38         /* See if there is any space left */
  39         if (chan->msg_count == MBOX_TX_QUEUE_LEN) {
  40                 spin_unlock_irqrestore(&chan->lock, flags);
  41                 return -ENOBUFS;
  42         }
  43
  44         idx = chan->msg_free;
  45         chan->msg_data[idx] = mssg;
  46         chan->msg_count++;
  47
  48         if (idx == MBOX_TX_QUEUE_LEN - 1)
  49                 chan->msg_free = 0;
  50         else
  51                 chan->msg_free++;
  52
  53         spin_unlock_irqrestore(&chan->lock, flags);
  54
  55         return idx;
  56 }
  57
  58 static void msg_submit(struct mbox_chan *chan)
  59 {
  60         unsigned count, idx;
  61         unsigned long flags;
  62         void *data;
  63         int err = -EBUSY;
  64
  65         spin_lock_irqsave(&chan->lock, flags);
  66
  67         if (!chan->msg_count || chan->active_req)
  68                 goto exit;
  69
  70         count = chan->msg_count;
  71         idx = chan->msg_free;
  72         if (idx >= count)
  73                 idx -= count;
  74         else
  75                 idx += MBOX_TX_QUEUE_LEN - count;
  76
  77         data = chan->msg_data[idx];
  78
  79         if (chan->cl->tx_prepare)
  80                 chan->cl->tx_prepare(chan->cl, data);
  81         /* Try to submit a message to the MBOX controller */
  82         err = chan->mbox->ops->send_data(chan, data);
  83         if (!err) {
  84                 chan->active_req = data;
  85                 chan->msg_count--;
  86         }
  87 exit:
  88         spin_unlock_irqrestore(&chan->lock, flags);
  89
  90         if (!err && (chan->txdone_method & TXDONE_BY_POLL))
  91                 poll_txdone((unsigned long)chan->mbox);
  92 }
  93
  94 static void tx_tick(struct mbox_chan *chan, int r)
  95 {
  96         unsigned long flags;
  97         void *mssg;
  98
  99         spin_lock_irqsave(&chan->lock, flags);
 100         mssg = chan->active_req;
 101         chan->active_req = NULL;
 102         spin_unlock_irqrestore(&chan->lock, flags);
 103
 104         /* Submit next message */
 105         msg_submit(chan);
 106
 107         /* Notify the client */
 108         if (mssg && chan->cl->tx_done)
 109                 chan->cl->tx_done(chan->cl, mssg, r);
 110
 111         if (chan->cl->tx_block)
 112                 complete(&chan->tx_complete);
 113 }
 114
 115 static void poll_txdone(unsigned long data)
 116 {
 117         struct mbox_controller *mbox = (struct mbox_controller *)data;
 118         bool txdone, resched = false;
 119         int i;
 120
 121         for (i = 0; i < mbox->num_chans; i++) {
 122                 struct mbox_chan *chan = &mbox->chans[i];
 123
 124                 if (chan->active_req && chan->cl) {
 125                         txdone = chan->mbox->ops->last_tx_done(chan);
 126                         if (txdone)
 127                                 tx_tick(chan, 0);
 128                         else
 129                                 resched = true;
 130                 }
 131         }
 132
 133         if (resched)
 134                 mod_timer(&mbox->poll, jiffies +
 135                                 msecs_to_jiffies(mbox->txpoll_period));
 136 }
 137
 138 /**
 139  * mbox_chan_received_data - A way for controller driver to push data
 140  *                              received from remote to the upper layer.
 141  * @chan: Pointer to the mailbox channel on which RX happened.
 142  * @mssg: Client specific message typecasted as void *
 143  *
 144  * After startup and before shutdown any data received on the chan
 145  * is passed on to the API via atomic mbox_chan_received_data().
 146  * The controller should ACK the RX only after this call returns.
 147  */
 148 void mbox_chan_received_data(struct mbox_chan *chan, void *mssg)
 149 {
 150         /* No buffering the received data */
 151         if (chan->cl->rx_callback)
 152                 chan->cl->rx_callback(chan->cl, mssg);
 153 }
 154 EXPORT_SYMBOL_GPL(mbox_chan_received_data);
 155
 156 /**
 157  * mbox_chan_txdone - A way for controller driver to notify the
 158  *                      framework that the last TX has completed.
 159  * @chan: Pointer to the mailbox chan on which TX happened.
 160  * @r: Status of last TX - OK or ERROR
 161  *
 162  * The controller that has IRQ for TX ACK calls this atomic API
 163  * to tick the TX state machine. It works only if txdone_irq
 164  * is set by the controller.
 165  */
 166 void mbox_chan_txdone(struct mbox_chan *chan, int r)
 167 {
 168         if (unlikely(!(chan->txdone_method & TXDONE_BY_IRQ))) {
 169                 dev_err(chan->mbox->dev,
 170                        "Controller can't run the TX ticker\n");
 171                 return;
 172         }
 173
 174         tx_tick(chan, r);
 175 }
 176 EXPORT_SYMBOL_GPL(mbox_chan_txdone);
 177
 178 /**
 179  * mbox_client_txdone - The way for a client to run the TX state machine.
 180  * @chan: Mailbox channel assigned to this client.
 181  * @r: Success status of last transmission.
 182  *
 183  * The client/protocol had received some 'ACK' packet and it notifies
 184  * the API that the last packet was sent successfully. This only works
 185  * if the controller can't sense TX-Done.
 186  */
 187 void mbox_client_txdone(struct mbox_chan *chan, int r)
 188 {
 189         if (unlikely(!(chan->txdone_method & TXDONE_BY_ACK))) {
 190                 dev_err(chan->mbox->dev, "Client can't run the TX ticker\n");
 191                 return;
 192         }
 193
 194         tx_tick(chan, r);
 195 }
 196 EXPORT_SYMBOL_GPL(mbox_client_txdone);
 197
 198 /**
 199  * mbox_client_peek_data - A way for client driver to pull data
 200  *                      received from remote by the controller.
 201  * @chan: Mailbox channel assigned to this client.
 202  *
 203  * A poke to controller driver for any received data.
 204  * The data is actually passed onto client via the
 205  * mbox_chan_received_data()
 206  * The call can be made from atomic context, so the controller's
 207  * implementation of peek_data() must not sleep.
 208  *
 209  * Return: True, if controller has, and is going to push after this,
 210  *          some data.
 211  *         False, if controller doesn't have any data to be read.
 212  */
 213 bool mbox_client_peek_data(struct mbox_chan *chan)
 214 {
 215         if (chan->mbox->ops->peek_data)
 216                 return chan->mbox->ops->peek_data(chan);
 217
 218         return false;
 219 }
 220 EXPORT_SYMBOL_GPL(mbox_client_peek_data);
 221
 222 /**
 223  * mbox_send_message -  For client to submit a message to be
 224  *                              sent to the remote.
 225  * @chan: Mailbox channel assigned to this client.
 226  * @mssg: Client specific message typecasted.
 227  *
 228  * For client to submit data to the controller destined for a remote
 229  * processor. If the client had set 'tx_block', the call will return
 230  * either when the remote receives the data or when 'tx_tout' millisecs
 231  * run out.
 232  *  In non-blocking mode, the requests are buffered by the API and a
 233  * non-negative token is returned for each queued request. If the request
 234  * is not queued, a negative token is returned. Upon failure or successful
 235  * TX, the API calls 'tx_done' from atomic context, from which the client
 236  * could submit yet another request.
 237  * The pointer to message should be preserved until it is sent
 238  * over the chan, i.e, tx_done() is made.
 239  * This function could be called from atomic context as it simply
 240  * queues the data and returns a token against the request.
 241  *
 242  * Return: Non-negative integer for successful submission (non-blocking mode)
 243  *      or transmission over chan (blocking mode).
 244  *      Negative value denotes failure.
 245  */
 246 int mbox_send_message(struct mbox_chan *chan, void *mssg)
 247 {
 248         int t;
 249
 250         if (!chan || !chan->cl)
 251                 return -EINVAL;
 252
 253         t = add_to_rbuf(chan, mssg);
 254         if (t < 0) {
 255                 dev_err(chan->mbox->dev, "Try increasing MBOX_TX_QUEUE_LEN\n");
 256                 return t;
 257         }
 258
 259         msg_submit(chan);
 260
 261         if (chan->cl->tx_block && chan->active_req) {
 262                 unsigned long wait;
 263                 int ret;
 264
 265                 if (!chan->cl->tx_tout) /* wait forever */
 266                         wait = msecs_to_jiffies(3600000);
 267                 else
 268                         wait = msecs_to_jiffies(chan->cl->tx_tout);
 269
 270                 ret = wait_for_completion_timeout(&chan->tx_complete, wait);
 271                 if (ret == 0) {
 272                         t = -EIO;
 273                         tx_tick(chan, -EIO);
 274                 }
 275         }
 276
 277         return t;
 278 }
 279 EXPORT_SYMBOL_GPL(mbox_send_message);
 280
 281 /**
 282  * mbox_request_channel - Request a mailbox channel.
 283  * @cl: Identity of the client requesting the channel.
 284  * @index: Index of mailbox specifier in 'mboxes' property.
 285  *
 286  * The Client specifies its requirements and capabilities while asking for
 287  * a mailbox channel. It can't be called from atomic context.
 288  * The channel is exclusively allocated and can't be used by another
 289  * client before the owner calls mbox_free_channel.
 290  * After assignment, any packet received on this channel will be
 291  * handed over to the client via the 'rx_callback'.
 292  * The framework holds reference to the client, so the mbox_client
 293  * structure shouldn't be modified until the mbox_free_channel returns.
 294  *
 295  * Return: Pointer to the channel assigned to the client if successful.
 296  *              ERR_PTR for request failure.
 297  */
 298 struct mbox_chan *mbox_request_channel(struct mbox_client *cl, int index)
 299 {
 300         struct device *dev = cl->dev;
 301         struct mbox_controller *mbox;
 302         struct of_phandle_args spec;
 303         struct mbox_chan *chan;
 304         unsigned long flags;
 305         int ret;
 306
 307         if (!dev || !dev->of_node) {
 308                 pr_debug("%s: No owner device node\n", __func__);
 309                 return ERR_PTR(-ENODEV);
 310         }
 311
 312         mutex_lock(&con_mutex);
 313
 314         if (of_parse_phandle_with_args(dev->of_node, "mboxes",
 315                                        "#mbox-cells", index, &spec)) {
 316                 dev_dbg(dev, "%s: can't parse \"mboxes\" property\n", __func__);
 317                 mutex_unlock(&con_mutex);
 318                 return ERR_PTR(-ENODEV);
 319         }
 320
 321         chan = NULL;
 322         list_for_each_entry(mbox, &mbox_cons, node)
 323                 if (mbox->dev->of_node == spec.np) {
 324                         chan = mbox->of_xlate(mbox, &spec);
 325                         break;
 326                 }
 327
 328         of_node_put(spec.np);
 329
 330         if (!chan || chan->cl || !try_module_get(mbox->dev->driver->owner)) {
 331                 dev_dbg(dev, "%s: mailbox not free\n", __func__);
 332                 mutex_unlock(&con_mutex);
 333                 return ERR_PTR(-EBUSY);
 334         }
 335
 336         spin_lock_irqsave(&chan->lock, flags);
 337         chan->msg_free = 0;
 338         chan->msg_count = 0;
 339         chan->active_req = NULL;
 340         chan->cl = cl;
 341         init_completion(&chan->tx_complete);
 342
 343         if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone)
 344                 chan->txdone_method |= TXDONE_BY_ACK;
 345
 346         spin_unlock_irqrestore(&chan->lock, flags);
 347
 348         ret = chan->mbox->ops->startup(chan);
 349         if (ret) {
 350                 dev_err(dev, "Unable to startup the chan (%d)\n", ret);
 351                 mbox_free_channel(chan);
 352                 chan = ERR_PTR(ret);
 353         }
 354
 355         mutex_unlock(&con_mutex);
 356         return chan;
 357 }
 358 EXPORT_SYMBOL_GPL(mbox_request_channel);
 359
 360 /**
 361  * mbox_free_channel - The client relinquishes control of a mailbox
 362  *                      channel by this call.
 363  * @chan: The mailbox channel to be freed.
 364  */
 365 void mbox_free_channel(struct mbox_chan *chan)
 366 {
 367         unsigned long flags;
 368
 369         if (!chan || !chan->cl)
 370                 return;
 371
 372         chan->mbox->ops->shutdown(chan);
 373
 374         /* The queued TX requests are simply aborted, no callbacks are made */
 375         spin_lock_irqsave(&chan->lock, flags);
 376         chan->cl = NULL;
 377         chan->active_req = NULL;
 378         if (chan->txdone_method == (TXDONE_BY_POLL | TXDONE_BY_ACK))
 379                 chan->txdone_method = TXDONE_BY_POLL;
 380
 381         module_put(chan->mbox->dev->driver->owner);
 382         spin_unlock_irqrestore(&chan->lock, flags);
 383 }
 384 EXPORT_SYMBOL_GPL(mbox_free_channel);
 385
 386 static struct mbox_chan *
 387 of_mbox_index_xlate(struct mbox_controller *mbox,
 388                     const struct of_phandle_args *sp)
 389 {
 390         int ind = sp->args[0];
 391
 392         if (ind >= mbox->num_chans)
 393                 return NULL;
 394
 395         return &mbox->chans[ind];
 396 }
 397
 398 /**
 399  * mbox_controller_register - Register the mailbox controller
 400  * @mbox:       Pointer to the mailbox controller.
 401  *
 402  * The controller driver registers its communication channels
 403  */
 404 int mbox_controller_register(struct mbox_controller *mbox)
 405 {
 406         int i, txdone;
 407
 408         /* Sanity check */
 409         if (!mbox || !mbox->dev || !mbox->ops || !mbox->num_chans)
 410                 return -EINVAL;
 411
 412         if (mbox->txdone_irq)
 413                 txdone = TXDONE_BY_IRQ;
 414         else if (mbox->txdone_poll)
 415                 txdone = TXDONE_BY_POLL;
 416         else /* It has to be ACK then */
 417                 txdone = TXDONE_BY_ACK;
 418
 419         if (txdone == TXDONE_BY_POLL) {
 420                 mbox->poll.function = &poll_txdone;
 421                 mbox->poll.data = (unsigned long)mbox;
 422                 init_timer(&mbox->poll);
 423         }
 424
 425         for (i = 0; i < mbox->num_chans; i++) {
 426                 struct mbox_chan *chan = &mbox->chans[i];
 427
 428                 chan->cl = NULL;
 429                 chan->mbox = mbox;
 430                 chan->txdone_method = txdone;
 431                 spin_lock_init(&chan->lock);
 432         }
 433
 434         if (!mbox->of_xlate)
 435                 mbox->of_xlate = of_mbox_index_xlate;
 436
 437         mutex_lock(&con_mutex);
 438         list_add_tail(&mbox->node, &mbox_cons);
 439         mutex_unlock(&con_mutex);
 440
 441         return 0;
 442 }
 443 EXPORT_SYMBOL_GPL(mbox_controller_register);
 444
 445 /**
 446  * mbox_controller_unregister - Unregister the mailbox controller
 447  * @mbox:       Pointer to the mailbox controller.
 448  */
 449 void mbox_controller_unregister(struct mbox_controller *mbox)
 450 {
 451         int i;
 452
 453         if (!mbox)
 454                 return;
 455
 456         mutex_lock(&con_mutex);
 457
 458         list_del(&mbox->node);
 459
 460         for (i = 0; i < mbox->num_chans; i++)
 461                 mbox_free_channel(&mbox->chans[i]);
 462
 463         if (mbox->txdone_poll)
 464                 del_timer_sync(&mbox->poll);
 465
 466         mutex_unlock(&con_mutex);
 467 }
 468 EXPORT_SYMBOL_GPL(mbox_controller_unregister);