Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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 | |
Ashwin Chaugule | 86c22f8 | 2014-11-12 19:59:38 -0500 | [diff] [blame] | 24 | #include "mailbox.h" |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 25 | |
| 26 | static LIST_HEAD(mbox_cons); |
| 27 | static DEFINE_MUTEX(con_mutex); |
| 28 | |
Andrew Bresticker | 52a4930 | 2014-10-30 13:01:07 -0700 | [diff] [blame] | 29 | static void poll_txdone(unsigned long data); |
| 30 | |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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; |
Andrew Bresticker | 52a4930 | 2014-10-30 13:01:07 -0700 | [diff] [blame] | 63 | int err = -EBUSY; |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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 | |
Sudeep Holla | 97b0c7b | 2014-11-11 18:33:01 +0000 | [diff] [blame] | 79 | if (chan->cl->tx_prepare) |
| 80 | chan->cl->tx_prepare(chan->cl, data); |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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); |
Andrew Bresticker | 52a4930 | 2014-10-30 13:01:07 -0700 | [diff] [blame] | 89 | |
Jassi Brar | 01340df | 2014-12-12 15:22:49 +0530 | [diff] [blame] | 90 | if (!err && (chan->txdone_method & TXDONE_BY_POLL)) |
Andrew Bresticker | 52a4930 | 2014-10-30 13:01:07 -0700 | [diff] [blame] | 91 | poll_txdone((unsigned long)chan->mbox); |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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) { |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 125 | txdone = chan->mbox->ops->last_tx_done(chan); |
| 126 | if (txdone) |
| 127 | tx_tick(chan, 0); |
Andrew Bresticker | 52a4930 | 2014-10-30 13:01:07 -0700 | [diff] [blame] | 128 | else |
| 129 | resched = true; |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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 | |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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 | |
Benson Leung | 2d805fc | 2015-05-04 10:36:36 -0700 | [diff] [blame] | 321 | chan = ERR_PTR(-EPROBE_DEFER); |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 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 | |
Benson Leung | 2d805fc | 2015-05-04 10:36:36 -0700 | [diff] [blame] | 330 | if (IS_ERR(chan)) { |
| 331 | mutex_unlock(&con_mutex); |
| 332 | return chan; |
| 333 | } |
| 334 | |
| 335 | if (chan->cl || !try_module_get(mbox->dev->driver->owner)) { |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 336 | dev_dbg(dev, "%s: mailbox not free\n", __func__); |
| 337 | mutex_unlock(&con_mutex); |
| 338 | return ERR_PTR(-EBUSY); |
| 339 | } |
| 340 | |
| 341 | spin_lock_irqsave(&chan->lock, flags); |
| 342 | chan->msg_free = 0; |
| 343 | chan->msg_count = 0; |
| 344 | chan->active_req = NULL; |
| 345 | chan->cl = cl; |
| 346 | init_completion(&chan->tx_complete); |
| 347 | |
| 348 | if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone) |
| 349 | chan->txdone_method |= TXDONE_BY_ACK; |
| 350 | |
| 351 | spin_unlock_irqrestore(&chan->lock, flags); |
| 352 | |
| 353 | ret = chan->mbox->ops->startup(chan); |
| 354 | if (ret) { |
| 355 | dev_err(dev, "Unable to startup the chan (%d)\n", ret); |
| 356 | mbox_free_channel(chan); |
| 357 | chan = ERR_PTR(ret); |
| 358 | } |
| 359 | |
| 360 | mutex_unlock(&con_mutex); |
| 361 | return chan; |
| 362 | } |
| 363 | EXPORT_SYMBOL_GPL(mbox_request_channel); |
| 364 | |
Lee Jones | dfabde2 | 2015-05-11 17:08:50 +0100 | [diff] [blame] | 365 | struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl, |
| 366 | const char *name) |
| 367 | { |
| 368 | struct device_node *np = cl->dev->of_node; |
| 369 | struct property *prop; |
| 370 | const char *mbox_name; |
| 371 | int index = 0; |
| 372 | |
| 373 | if (!np) { |
| 374 | dev_err(cl->dev, "%s() currently only supports DT\n", __func__); |
| 375 | return ERR_PTR(-ENOSYS); |
| 376 | } |
| 377 | |
| 378 | if (!of_get_property(np, "mbox-names", NULL)) { |
| 379 | dev_err(cl->dev, |
| 380 | "%s() requires an \"mbox-names\" property\n", __func__); |
| 381 | return ERR_PTR(-ENOSYS); |
| 382 | } |
| 383 | |
| 384 | of_property_for_each_string(np, "mbox-names", prop, mbox_name) { |
| 385 | if (!strncmp(name, mbox_name, strlen(name))) |
| 386 | break; |
| 387 | index++; |
| 388 | } |
| 389 | |
| 390 | return mbox_request_channel(cl, index); |
| 391 | } |
| 392 | EXPORT_SYMBOL_GPL(mbox_request_channel_byname); |
| 393 | |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 394 | /** |
| 395 | * mbox_free_channel - The client relinquishes control of a mailbox |
| 396 | * channel by this call. |
| 397 | * @chan: The mailbox channel to be freed. |
| 398 | */ |
| 399 | void mbox_free_channel(struct mbox_chan *chan) |
| 400 | { |
| 401 | unsigned long flags; |
| 402 | |
| 403 | if (!chan || !chan->cl) |
| 404 | return; |
| 405 | |
| 406 | chan->mbox->ops->shutdown(chan); |
| 407 | |
| 408 | /* The queued TX requests are simply aborted, no callbacks are made */ |
| 409 | spin_lock_irqsave(&chan->lock, flags); |
| 410 | chan->cl = NULL; |
| 411 | chan->active_req = NULL; |
| 412 | if (chan->txdone_method == (TXDONE_BY_POLL | TXDONE_BY_ACK)) |
| 413 | chan->txdone_method = TXDONE_BY_POLL; |
| 414 | |
| 415 | module_put(chan->mbox->dev->driver->owner); |
| 416 | spin_unlock_irqrestore(&chan->lock, flags); |
| 417 | } |
| 418 | EXPORT_SYMBOL_GPL(mbox_free_channel); |
| 419 | |
| 420 | static struct mbox_chan * |
| 421 | of_mbox_index_xlate(struct mbox_controller *mbox, |
| 422 | const struct of_phandle_args *sp) |
| 423 | { |
| 424 | int ind = sp->args[0]; |
| 425 | |
| 426 | if (ind >= mbox->num_chans) |
Benson Leung | 2d805fc | 2015-05-04 10:36:36 -0700 | [diff] [blame] | 427 | return ERR_PTR(-EINVAL); |
Jassi Brar | 2b6d83e | 2014-06-12 22:31:19 +0530 | [diff] [blame] | 428 | |
| 429 | return &mbox->chans[ind]; |
| 430 | } |
| 431 | |
| 432 | /** |
| 433 | * mbox_controller_register - Register the mailbox controller |
| 434 | * @mbox: Pointer to the mailbox controller. |
| 435 | * |
| 436 | * The controller driver registers its communication channels |
| 437 | */ |
| 438 | int mbox_controller_register(struct mbox_controller *mbox) |
| 439 | { |
| 440 | int i, txdone; |
| 441 | |
| 442 | /* Sanity check */ |
| 443 | if (!mbox || !mbox->dev || !mbox->ops || !mbox->num_chans) |
| 444 | return -EINVAL; |
| 445 | |
| 446 | if (mbox->txdone_irq) |
| 447 | txdone = TXDONE_BY_IRQ; |
| 448 | else if (mbox->txdone_poll) |
| 449 | txdone = TXDONE_BY_POLL; |
| 450 | else /* It has to be ACK then */ |
| 451 | txdone = TXDONE_BY_ACK; |
| 452 | |
| 453 | if (txdone == TXDONE_BY_POLL) { |
| 454 | mbox->poll.function = &poll_txdone; |
| 455 | mbox->poll.data = (unsigned long)mbox; |
| 456 | init_timer(&mbox->poll); |
| 457 | } |
| 458 | |
| 459 | for (i = 0; i < mbox->num_chans; i++) { |
| 460 | struct mbox_chan *chan = &mbox->chans[i]; |
| 461 | |
| 462 | chan->cl = NULL; |
| 463 | chan->mbox = mbox; |
| 464 | chan->txdone_method = txdone; |
| 465 | spin_lock_init(&chan->lock); |
| 466 | } |
| 467 | |
| 468 | if (!mbox->of_xlate) |
| 469 | mbox->of_xlate = of_mbox_index_xlate; |
| 470 | |
| 471 | mutex_lock(&con_mutex); |
| 472 | list_add_tail(&mbox->node, &mbox_cons); |
| 473 | mutex_unlock(&con_mutex); |
| 474 | |
| 475 | return 0; |
| 476 | } |
| 477 | EXPORT_SYMBOL_GPL(mbox_controller_register); |
| 478 | |
| 479 | /** |
| 480 | * mbox_controller_unregister - Unregister the mailbox controller |
| 481 | * @mbox: Pointer to the mailbox controller. |
| 482 | */ |
| 483 | void mbox_controller_unregister(struct mbox_controller *mbox) |
| 484 | { |
| 485 | int i; |
| 486 | |
| 487 | if (!mbox) |
| 488 | return; |
| 489 | |
| 490 | mutex_lock(&con_mutex); |
| 491 | |
| 492 | list_del(&mbox->node); |
| 493 | |
| 494 | for (i = 0; i < mbox->num_chans; i++) |
| 495 | mbox_free_channel(&mbox->chans[i]); |
| 496 | |
| 497 | if (mbox->txdone_poll) |
| 498 | del_timer_sync(&mbox->poll); |
| 499 | |
| 500 | mutex_unlock(&con_mutex); |
| 501 | } |
| 502 | EXPORT_SYMBOL_GPL(mbox_controller_unregister); |