/* * Mailbox: Common code for Mailbox controllers and users * * Copyright (C) 2014 Linaro Ltd. * Author: Jassi Brar * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include #include #include #include #include #include #include #include #include #include /* * The length of circular buffer for queuing messages from a client. * 'msg_count' tracks the number of buffered messages while 'msg_free' * is the index where the next message would be buffered. * We shouldn't need it too big because every transferr is interrupt * triggered and if we have lots of data to transfer, the interrupt * latencies are going to be the bottleneck, not the buffer length. * Besides, mbox_send_message could be called from atomic context and * the client could also queue another message from the notifier 'tx_done' * of the last transfer done. * REVIST: If too many platforms see the "Try increasing MBOX_TX_QUEUE_LEN" * print, it needs to be taken from config option or somesuch. */ #define TXDONE_BY_IRQ (1 << 0) /* controller has remote RTR irq */ #define TXDONE_BY_POLL (1 << 1) /* controller can read status of last TX */ #define TXDONE_BY_ACK (1 << 2) /* S/W ACK recevied by Client ticks the TX */ static LIST_HEAD(mbox_cons); static DEFINE_MUTEX(con_mutex); static int _add_to_rbuf(struct mbox_chan *chan, void *mssg) { int idx; unsigned long flags; spin_lock_irqsave(&chan->lock, flags); /* See if there is any space left */ if (chan->msg_count == MBOX_TX_QUEUE_LEN) { spin_unlock_irqrestore(&chan->lock, flags); return -ENOMEM; } idx = chan->msg_free; chan->msg_data[idx] = mssg; chan->msg_count++; if (idx == MBOX_TX_QUEUE_LEN - 1) chan->msg_free = 0; else chan->msg_free++; spin_unlock_irqrestore(&chan->lock, flags); return idx; } static int _msg_submit(struct mbox_chan *chan) { struct mbox_link *link = chan->link; unsigned count, idx; unsigned long flags; void *data; int err; spin_lock_irqsave(&chan->lock, flags); if (!chan->msg_count || chan->active_req) { spin_unlock_irqrestore(&chan->lock, flags); return -ENOENT; } count = chan->msg_count; idx = chan->msg_free; if (idx >= count) idx -= count; else idx += MBOX_TX_QUEUE_LEN - count; data = chan->msg_data[idx]; /* Try to submit a message to the MBOX controller */ err = chan->link_ops->send_data(link, data); if (!err) { chan->active_req = data; chan->msg_count--; } else { pr_err("mailbox: cm3 send fail\n"); spin_unlock_irqrestore(&chan->lock, flags); return -EIO; } spin_unlock_irqrestore(&chan->lock, flags); return 0; } static void tx_tick(struct mbox_chan *chan, enum mbox_result r) { unsigned long flags; void *mssg; spin_lock_irqsave(&chan->lock, flags); mssg = chan->active_req; chan->active_req = NULL; spin_unlock_irqrestore(&chan->lock, flags); /* Notify the client */ if (chan->cl->tx_block) complete(&chan->tx_complete); else if (mssg && chan->cl->tx_done) chan->cl->tx_done(chan->cl, mssg, r); } static int poll_txdone(unsigned long data) { struct mbox_con *con = (struct mbox_con *)data; int txdone; struct mbox_chan *chan; int ret = 0; list_for_each_entry(chan, &con->channels, node) { if (chan->active_req && chan->cl) { txdone = chan->link_ops->last_tx_done(chan->link); if (!txdone) { tx_tick(chan, MBOX_OK); ret = 0; } else if (txdone == -EIO) { tx_tick(chan, MBOX_ERR); ret = -EIO; } } } return ret; } /** * mbox_link_received_data - A way for controller driver to push data * received from remote to the upper layer. * @link: Pointer to the mailbox link on which RX happened. * @data: Client specific message typecasted as void * * * After startup and before shutdown any data received on the link * is passed on to the API via atomic mbox_link_received_data(). * The controller should ACK the RX only after this call returns. */ void mbox_link_received_data(struct mbox_link *link, void *mssg) { struct mbox_chan *chan = (struct mbox_chan *)link->api_priv; /* No buffering the received data */ if (chan->cl->rx_callback) chan->cl->rx_callback(chan->cl, mssg); } EXPORT_SYMBOL_GPL(mbox_link_received_data); /** * mbox_link_txdone - A way for controller driver to notify the * framework that the last TX has completed. * @link: Pointer to the mailbox link on which TX happened. * @r: Status of last TX - OK or ERROR * * The controller that has IRQ for TX ACK calls this atomic API * to tick the TX state machine. It works only if txdone_irq * is set by the controller. */ void mbox_link_txdone(struct mbox_link *link, enum mbox_result r) { struct mbox_chan *chan = (struct mbox_chan *)link->api_priv; if (unlikely(!(chan->txdone_method & TXDONE_BY_IRQ))) { pr_err("Controller can't run the TX ticker\n"); return; } tx_tick(chan, r); } EXPORT_SYMBOL_GPL(mbox_link_txdone); /** * mbox_client_txdone - The way for a client to run the TX state machine. * @chan: Mailbox channel assigned to this client. * @r: Success status of last transmission. * * The client/protocol had received some 'ACK' packet and it notifies * the API that the last packet was sent successfully. This only works * if the controller can't sense TX-Done. */ void mbox_client_txdone(struct mbox_chan *chan, enum mbox_result r) { if (unlikely(!(chan->txdone_method & TXDONE_BY_ACK))) { pr_err("Client can't run the TX ticker\n"); return; } tx_tick(chan, r); } EXPORT_SYMBOL_GPL(mbox_client_txdone); /** * mbox_send_message - For client to submit a message to be * sent to the remote. * @chan: Mailbox channel assigned to this client. * @mssg: Client specific message typecasted. * * For client to submit data to the controller destined for a remote * processor. If the client had set 'tx_block', the call will return * either when the remote receives the data or when 'tx_tout' millisecs * run out. * In non-blocking mode, the requests are buffered by the API and a * non-negative token is returned for each queued request. If the request * is not queued, a negative token is returned. Upon failure or successful * TX, the API calls 'tx_done' from atomic context, from which the client * could submit yet another request. * In blocking mode, 'tx_done' is not called, effectively making the * queue length 1. * The pointer to message should be preserved until it is sent * over the link, i.e, tx_done() is made. * This function could be called from atomic context as it simply * queues the data and returns a token against the request. * * Return: Non-negative integer for successful submission (non-blocking mode) * or transmission over link (blocking mode). * Negative value denotes failure. */ int mbox_send_message(struct mbox_chan *chan, void *mssg) { int t, ret; if (!chan || !chan->cl) return -EINVAL; if (chan->cl->tx_block) init_completion(&chan->tx_complete); t = _add_to_rbuf(chan, mssg); if (t < 0) { pr_err("Try increasing MBOX_TX_QUEUE_LEN\n"); return t; } ret = _msg_submit(chan); if (ret) { return -EIO; } if (chan->txdone_method == TXDONE_BY_POLL) { t = poll_txdone((unsigned long)chan->con); if (t < 0) pr_err("Do not check polling data \n"); } if (chan->cl->tx_block && chan->active_req) { int ret; ret = wait_for_completion_timeout(&chan->tx_complete, chan->cl->tx_tout); if (ret == 0) { t = -EIO; tx_tick(chan, MBOX_ERR); } } return t; } EXPORT_SYMBOL_GPL(mbox_send_message); /** * mbox_request_channel - Request a mailbox channel. * @cl: Identity of the client requesting the channel. * * The Client specifies its requirements and capabilities while asking for * a mailbox channel by name. It can't be called from atomic context. * The channel is exclusively allocated and can't be used by another * client before the owner calls mbox_free_channel. * After assignment, any packet received on this channel will be * handed over to the client via the 'rx_callback'. * * Return: Pointer to the channel assigned to the client if successful. * ERR_PTR for request failure. */ struct mbox_chan *mbox_request_channel(struct mbox_client *cl) { struct mbox_chan *chan; struct mbox_con *con; unsigned long flags; char *con_name; int len, ret; con_name = cl->chan_name; len = strcspn(cl->chan_name, ":"); ret = 0; mutex_lock(&con_mutex); list_for_each_entry(con, &mbox_cons, node) if (!strncmp(con->name, con_name, len)) { ret = 1; break; } mutex_unlock(&con_mutex); if (!ret) { pr_info("Channel(%s) not found!\n", cl->chan_name); return ERR_PTR(-ENODEV); } ret = 0; list_for_each_entry(chan, &con->channels, node) { if (!strcmp(con_name + len + 1, chan->name)) { spin_lock_irqsave(&chan->lock, flags); chan->msg_free = 0; chan->msg_count = 0; chan->active_req = NULL; chan->cl = cl; if (!cl->tx_tout) /* wait for ever */ cl->tx_tout = msecs_to_jiffies(3600000); else cl->tx_tout = msecs_to_jiffies(cl->tx_tout); if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone) chan->txdone_method |= TXDONE_BY_ACK; spin_unlock_irqrestore(&chan->lock, flags); ret = 1; break; } } if (!ret) { pr_err("Unable to assign mailbox(%s)\n", cl->chan_name); return ERR_PTR(-EBUSY); } ret = chan->link_ops->startup(chan->link, cl->link_data); if (ret) { pr_err("Unable to startup the link\n"); mbox_free_channel(chan); return ERR_PTR(ret); } return chan; } EXPORT_SYMBOL_GPL(mbox_request_channel); /** * mbox_free_channel - The client relinquishes control of a mailbox * channel by this call. * @chan: The mailbox channel to be freed. */ void mbox_free_channel(struct mbox_chan *chan) { unsigned long flags; if (!chan) return; chan->link_ops->shutdown(chan->link); /* The queued TX requests are simply aborted, no callbacks are made */ spin_lock_irqsave(&chan->lock, flags); chan->active_req = NULL; if (chan->txdone_method == (TXDONE_BY_POLL | TXDONE_BY_ACK)) chan->txdone_method = TXDONE_BY_POLL; spin_unlock_irqrestore(&chan->lock, flags); blocking_notifier_call_chain(&chan->avail, 0, NULL); } EXPORT_SYMBOL_GPL(mbox_free_channel); static struct mbox_chan *name_to_chan(const char *name) { struct mbox_chan *chan = NULL; struct mbox_con *con; int len, found = 0; len = strcspn(name, ":"); mutex_lock(&con_mutex); list_for_each_entry(con, &mbox_cons, node) { if (!strncmp(con->name, name, len)) { list_for_each_entry(chan, &con->channels, node) { if (!strcmp(name + len + 1, chan->name)) { found = 1; goto done; } } } } done: mutex_unlock(&con_mutex); if (!found) return NULL; return chan; } /** * mbox_notify_chan_register - The client may ask the framework to be * notified when a particular channel becomes available * to be acquired again. * @name: Name of the mailbox channel the client is interested in. * @nb: Pointer to the notifier. */ int mbox_notify_chan_register(const char *name, struct notifier_block *nb) { struct mbox_chan *chan = name_to_chan(name); if (chan && nb) return blocking_notifier_chain_register(&chan->avail, nb); return -EINVAL; } EXPORT_SYMBOL_GPL(mbox_notify_chan_register); /** * mbox_notify_chan_unregister - The client is no more interested in channel. * * @name: Name of the mailbox channel the client was interested in. * @nb: Pointer to the notifier. */ void mbox_notify_chan_unregister(const char *name, struct notifier_block *nb) { struct mbox_chan *chan = name_to_chan(name); if (chan && nb) blocking_notifier_chain_unregister(&chan->avail, nb); } EXPORT_SYMBOL_GPL(mbox_notify_chan_unregister); /** * mbox_controller_register - Register the mailbox controller * @mbox_con: Pointer to the mailbox controller. * * The controller driver registers its communication links to the * global pool managed by the common framework. */ int mbox_controller_register(struct mbox_controller *mbox) { int i, num_links, txdone; struct mbox_chan *chan; struct mbox_con *con; /* Sanity check */ if (!mbox || !mbox->ops) return -EINVAL; for (i = 0; mbox->links[i]; i++) ; if (!i) return -EINVAL; num_links = i; mutex_lock(&con_mutex); /* Check if already populated */ list_for_each_entry(con, &mbox_cons, node) if (!strcmp(mbox->controller_name, con->name)) { mutex_unlock(&con_mutex); return -EINVAL; } con = kzalloc(sizeof(struct mbox_con), GFP_KERNEL); if (!con) { mutex_unlock(&con_mutex); return -ENOMEM; } chan = kzalloc(sizeof(struct mbox_chan) * num_links, GFP_KERNEL); if (!chan) { kfree(con); mutex_unlock(&con_mutex); return -ENOMEM; } con->dev = mbox->dev; INIT_LIST_HEAD(&con->channels); snprintf(con->name, 16, "%s", mbox->controller_name); if (mbox->txdone_irq) txdone = TXDONE_BY_IRQ; else if (mbox->txdone_poll) txdone = TXDONE_BY_POLL; else /* It has to be ACK then */ txdone = TXDONE_BY_ACK; if (txdone == TXDONE_BY_POLL) { con->period = mbox->txpoll_period; con->poll.data = (unsigned long)con; } for (i = 0; i < num_links; i++) { chan[i].con = con; chan[i].cl = NULL; chan[i].link_ops = mbox->ops; chan[i].link = mbox->links[i]; chan[i].txdone_method = txdone; chan[i].link->api_priv = &chan[i]; spin_lock_init(&chan[i].lock); BLOCKING_INIT_NOTIFIER_HEAD(&chan[i].avail); list_add_tail(&chan[i].node, &con->channels); snprintf(chan[i].name, 16, "%s", mbox->links[i]->link_name); } list_add_tail(&con->node, &mbox_cons); mutex_unlock(&con_mutex); return 0; } EXPORT_SYMBOL_GPL(mbox_controller_register); /** * mbox_controller_unregister - UnRegister the mailbox controller * @mbox_con: Pointer to the mailbox controller. * * Purge the mailbox links from the global pool maintained by the framework. */ void mbox_controller_unregister(struct mbox_controller *mbox) { struct mbox_con *t, *con = NULL; struct mbox_chan *chan; mutex_lock(&con_mutex); list_for_each_entry(t, &mbox_cons, node) if (!strcmp(mbox->controller_name, t->name)) { con = t; break; } if (con) list_del(&con->node); mutex_unlock(&con_mutex); if (!con) return; list_for_each_entry(chan, &con->channels, node) mbox_free_channel(chan); kfree(con); } EXPORT_SYMBOL_GPL(mbox_controller_unregister);