[linux-2.6-block.git] / drivers / mailbox / mailbox.c

/*
 * Mailbox: Common code for Mailbox controllers and users
 *
 * Copyright (C) 2013-2014 Linaro Ltd.
 * Author: Jassi Brar <jassisinghbrar@gmail.com>
 *
 * 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 <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/bitops.h>
#include <linux/mailbox_client.h>
#include <linux/mailbox_controller.h>

#include "mailbox.h"

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 -ENOBUFS;
	}

	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 void msg_submit(struct mbox_chan *chan)
{
	unsigned count, idx;
	unsigned long flags;
	void *data;
	int err = -EBUSY;

	spin_lock_irqsave(&chan->lock, flags);

	if (!chan->msg_count || chan->active_req)
		goto exit;

	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];

	if (chan->cl->tx_prepare)
		chan->cl->tx_prepare(chan->cl, data);
	/* Try to submit a message to the MBOX controller */
	err = chan->mbox->ops->send_data(chan, data);
	if (!err) {
		chan->active_req = data;
		chan->msg_count--;
	}
exit:
	spin_unlock_irqrestore(&chan->lock, flags);

	if (!err && (chan->txdone_method & TXDONE_BY_POLL))
		/* kick start the timer immediately to avoid delays */
		hrtimer_start(&chan->mbox->poll_hrt, ktime_set(0, 0),
			      HRTIMER_MODE_REL);
}

static void tx_tick(struct mbox_chan *chan, int 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);

	/* Submit next message */
	msg_submit(chan);

	/* Notify the client */
	if (mssg && chan->cl->tx_done)
		chan->cl->tx_done(chan->cl, mssg, r);

	if (chan->cl->tx_block)
		complete(&chan->tx_complete);
}

static enum hrtimer_restart txdone_hrtimer(struct hrtimer *hrtimer)
{
	struct mbox_controller *mbox =
		container_of(hrtimer, struct mbox_controller, poll_hrt);
	bool txdone, resched = false;
	int i;

	for (i = 0; i < mbox->num_chans; i++) {
		struct mbox_chan *chan = &mbox->chans[i];

		if (chan->active_req && chan->cl) {
			txdone = chan->mbox->ops->last_tx_done(chan);
			if (txdone)
				tx_tick(chan, 0);
			else
				resched = true;
		}
	}

	if (resched) {
		hrtimer_forward_now(hrtimer, ms_to_ktime(mbox->txpoll_period));
		return HRTIMER_RESTART;
	}
	return HRTIMER_NORESTART;
}

/**
 * mbox_chan_received_data - A way for controller driver to push data
 *				received from remote to the upper layer.
 * @chan: Pointer to the mailbox channel on which RX happened.
 * @mssg: Client specific message typecasted as void *
 *
 * After startup and before shutdown any data received on the chan
 * is passed on to the API via atomic mbox_chan_received_data().
 * The controller should ACK the RX only after this call returns.
 */
void mbox_chan_received_data(struct mbox_chan *chan, void *mssg)
{
	/* No buffering the received data */
	if (chan->cl->rx_callback)
		chan->cl->rx_callback(chan->cl, mssg);
}
EXPORT_SYMBOL_GPL(mbox_chan_received_data);

/**
 * mbox_chan_txdone - A way for controller driver to notify the
 *			framework that the last TX has completed.
 * @chan: Pointer to the mailbox chan 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_chan_txdone(struct mbox_chan *chan, int r)
{
	if (unlikely(!(chan->txdone_method & TXDONE_BY_IRQ))) {
		dev_err(chan->mbox->dev,
		       "Controller can't run the TX ticker\n");
		return;
	}

	tx_tick(chan, r);
}
EXPORT_SYMBOL_GPL(mbox_chan_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, int r)
{
	if (unlikely(!(chan->txdone_method & TXDONE_BY_ACK))) {
		dev_err(chan->mbox->dev, "Client can't run the TX ticker\n");
		return;
	}

	tx_tick(chan, r);
}
EXPORT_SYMBOL_GPL(mbox_client_txdone);

/**
 * mbox_client_peek_data - A way for client driver to pull data
 *			received from remote by the controller.
 * @chan: Mailbox channel assigned to this client.
 *
 * A poke to controller driver for any received data.
 * The data is actually passed onto client via the
 * mbox_chan_received_data()
 * The call can be made from atomic context, so the controller's
 * implementation of peek_data() must not sleep.
 *
 * Return: True, if controller has, and is going to push after this,
 *          some data.
 *         False, if controller doesn't have any data to be read.
 */
bool mbox_client_peek_data(struct mbox_chan *chan)
{
	if (chan->mbox->ops->peek_data)
		return chan->mbox->ops->peek_data(chan);

	return false;
}
EXPORT_SYMBOL_GPL(mbox_client_peek_data);

/**
 * 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.
 * The pointer to message should be preserved until it is sent
 * over the chan, 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 chan (blocking mode).
 *	Negative value denotes failure.
 */
int mbox_send_message(struct mbox_chan *chan, void *mssg)
{
	int t;

	if (!chan || !chan->cl)
		return -EINVAL;

	t = add_to_rbuf(chan, mssg);
	if (t < 0) {
		dev_err(chan->mbox->dev, "Try increasing MBOX_TX_QUEUE_LEN\n");
		return t;
	}

	msg_submit(chan);

	if (chan->cl->tx_block && chan->active_req) {
		unsigned long wait;
		int ret;

		if (!chan->cl->tx_tout) /* wait forever */
			wait = msecs_to_jiffies(3600000);
		else
			wait = msecs_to_jiffies(chan->cl->tx_tout);

		ret = wait_for_completion_timeout(&chan->tx_complete, wait);
		if (ret == 0) {
			t = -EIO;
			tx_tick(chan, -EIO);
		}
	}

	return t;
}
EXPORT_SYMBOL_GPL(mbox_send_message);

/**
 * mbox_request_channel - Request a mailbox channel.
 * @cl: Identity of the client requesting the channel.
 * @index: Index of mailbox specifier in 'mboxes' property.
 *
 * The Client specifies its requirements and capabilities while asking for
 * a mailbox channel. 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'.
 * The framework holds reference to the client, so the mbox_client
 * structure shouldn't be modified until the mbox_free_channel returns.
 *
 * 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, int index)
{
	struct device *dev = cl->dev;
	struct mbox_controller *mbox;
	struct of_phandle_args spec;
	struct mbox_chan *chan;
	unsigned long flags;
	int ret;

	if (!dev || !dev->of_node) {
		pr_debug("%s: No owner device node\n", __func__);
		return ERR_PTR(-ENODEV);
	}

	mutex_lock(&con_mutex);

	if (of_parse_phandle_with_args(dev->of_node, "mboxes",
				       "#mbox-cells", index, &spec)) {
		dev_dbg(dev, "%s: can't parse \"mboxes\" property\n", __func__);
		mutex_unlock(&con_mutex);
		return ERR_PTR(-ENODEV);
	}

	chan = ERR_PTR(-EPROBE_DEFER);
	list_for_each_entry(mbox, &mbox_cons, node)
		if (mbox->dev->of_node == spec.np) {
			chan = mbox->of_xlate(mbox, &spec);
			break;
		}

	of_node_put(spec.np);

	if (IS_ERR(chan)) {
		mutex_unlock(&con_mutex);
		return chan;
	}

	if (chan->cl || !try_module_get(mbox->dev->driver->owner)) {
		dev_dbg(dev, "%s: mailbox not free\n", __func__);
		mutex_unlock(&con_mutex);
		return ERR_PTR(-EBUSY);
	}

	spin_lock_irqsave(&chan->lock, flags);
	chan->msg_free = 0;
	chan->msg_count = 0;
	chan->active_req = NULL;
	chan->cl = cl;
	init_completion(&chan->tx_complete);

	if (chan->txdone_method	== TXDONE_BY_POLL && cl->knows_txdone)
		chan->txdone_method |= TXDONE_BY_ACK;

	spin_unlock_irqrestore(&chan->lock, flags);

	ret = chan->mbox->ops->startup(chan);
	if (ret) {
		dev_err(dev, "Unable to startup the chan (%d)\n", ret);
		mbox_free_channel(chan);
		chan = ERR_PTR(ret);
	}

	mutex_unlock(&con_mutex);
	return chan;
}
EXPORT_SYMBOL_GPL(mbox_request_channel);

struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl,
					      const char *name)
{
	struct device_node *np = cl->dev->of_node;
	struct property *prop;
	const char *mbox_name;
	int index = 0;

	if (!np) {
		dev_err(cl->dev, "%s() currently only supports DT\n", __func__);
		return ERR_PTR(-EINVAL);
	}

	if (!of_get_property(np, "mbox-names", NULL)) {
		dev_err(cl->dev,
			"%s() requires an \"mbox-names\" property\n", __func__);
		return ERR_PTR(-EINVAL);
	}

	of_property_for_each_string(np, "mbox-names", prop, mbox_name) {
		if (!strncmp(name, mbox_name, strlen(name)))
			break;
		index++;
	}

	return mbox_request_channel(cl, index);
}
EXPORT_SYMBOL_GPL(mbox_request_channel_byname);

/**
 * 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 || !chan->cl)
		return;

	chan->mbox->ops->shutdown(chan);

	/* The queued TX requests are simply aborted, no callbacks are made */
	spin_lock_irqsave(&chan->lock, flags);
	chan->cl = NULL;
	chan->active_req = NULL;
	if (chan->txdone_method == (TXDONE_BY_POLL | TXDONE_BY_ACK))
		chan->txdone_method = TXDONE_BY_POLL;

	module_put(chan->mbox->dev->driver->owner);
	spin_unlock_irqrestore(&chan->lock, flags);
}
EXPORT_SYMBOL_GPL(mbox_free_channel);

static struct mbox_chan *
of_mbox_index_xlate(struct mbox_controller *mbox,
		    const struct of_phandle_args *sp)
{
	int ind = sp->args[0];

	if (ind >= mbox->num_chans)
		return ERR_PTR(-EINVAL);

	return &mbox->chans[ind];
}

/**
 * mbox_controller_register - Register the mailbox controller
 * @mbox:	Pointer to the mailbox controller.
 *
 * The controller driver registers its communication channels
 */
int mbox_controller_register(struct mbox_controller *mbox)
{
	int i, txdone;

	/* Sanity check */
	if (!mbox || !mbox->dev || !mbox->ops || !mbox->num_chans)
		return -EINVAL;

	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) {
		hrtimer_init(&mbox->poll_hrt, CLOCK_MONOTONIC,
			     HRTIMER_MODE_REL);
		mbox->poll_hrt.function = txdone_hrtimer;
	}

	for (i = 0; i < mbox->num_chans; i++) {
		struct mbox_chan *chan = &mbox->chans[i];

		chan->cl = NULL;
		chan->mbox = mbox;
		chan->txdone_method = txdone;
		spin_lock_init(&chan->lock);
	}

	if (!mbox->of_xlate)
		mbox->of_xlate = of_mbox_index_xlate;

	mutex_lock(&con_mutex);
	list_add_tail(&mbox->node, &mbox_cons);
	mutex_unlock(&con_mutex);

	return 0;
}
EXPORT_SYMBOL_GPL(mbox_controller_register);

/**
 * mbox_controller_unregister - Unregister the mailbox controller
 * @mbox:	Pointer to the mailbox controller.
 */
void mbox_controller_unregister(struct mbox_controller *mbox)
{
	int i;

	if (!mbox)
		return;

	mutex_lock(&con_mutex);

	list_del(&mbox->node);

	for (i = 0; i < mbox->num_chans; i++)
		mbox_free_channel(&mbox->chans[i]);

	if (mbox->txdone_poll)
		hrtimer_cancel(&mbox->poll_hrt);

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