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