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