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
 26static LIST_HEAD(mbox_cons);
 27static DEFINE_MUTEX(con_mutex);
 28
 29static 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
 56static void msg_submit(struct mbox_chan *chan)
 57{
 58	unsigned count, idx;
 59	unsigned long flags;
 60	void *data;
 61	int err = -EBUSY;
 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
 77	if (chan->cl->tx_prepare)
 78		chan->cl->tx_prepare(chan->cl, data);
 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	}
 85exit:
 86	spin_unlock_irqrestore(&chan->lock, flags);
 87
 88	if (!err && (chan->txdone_method & TXDONE_BY_POLL))
 89		/* kick start the timer immediately to avoid delays */
 90		hrtimer_start(&chan->mbox->poll_hrt, ktime_set(0, 0),
 91			      HRTIMER_MODE_REL);
 92}
 93
 94static 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
115static enum hrtimer_restart txdone_hrtimer(struct hrtimer *hrtimer)
116{
117	struct mbox_controller *mbox =
118		container_of(hrtimer, struct mbox_controller, poll_hrt);
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) {
126			txdone = chan->mbox->ops->last_tx_done(chan);
127			if (txdone)
128				tx_tick(chan, 0);
129			else
130				resched = true;
131		}
132	}
133
134	if (resched) {
135		hrtimer_forward_now(hrtimer, ms_to_ktime(mbox->txpoll_period));
136		return HRTIMER_RESTART;
137	}
138	return HRTIMER_NORESTART;
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 */
151void 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}
157EXPORT_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 */
169void 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}
179EXPORT_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 */
190void 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}
199EXPORT_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 */
216bool 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}
223EXPORT_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 */
249int 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
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}
282EXPORT_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 */
301struct 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
324	chan = ERR_PTR(-EPROBE_DEFER);
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
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)) {
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}
366EXPORT_SYMBOL_GPL(mbox_request_channel);
367
368struct 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__);
378		return ERR_PTR(-EINVAL);
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__);
384		return ERR_PTR(-EINVAL);
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}
395EXPORT_SYMBOL_GPL(mbox_request_channel_byname);
396
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 */
402void 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}
421EXPORT_SYMBOL_GPL(mbox_free_channel);
422
423static struct mbox_chan *
424of_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)
430		return ERR_PTR(-EINVAL);
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 */
441int 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) {
457		hrtimer_init(&mbox->poll_hrt, CLOCK_MONOTONIC,
458			     HRTIMER_MODE_REL);
459		mbox->poll_hrt.function = txdone_hrtimer;
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}
480EXPORT_SYMBOL_GPL(mbox_controller_register);
481
482/**
483 * mbox_controller_unregister - Unregister the mailbox controller
484 * @mbox:	Pointer to the mailbox controller.
485 */
486void 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)
501		hrtimer_cancel(&mbox->poll_hrt);
502
503	mutex_unlock(&con_mutex);
504}
505EXPORT_SYMBOL_GPL(mbox_controller_unregister);