2 * Mailbox: Common code for Mailbox controllers and users
4 * Copyright (C) 2013-2014 Linaro Ltd.
5 * Author: Jassi Brar <jassisinghbrar@gmail.com>
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.
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>
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 */
28 static LIST_HEAD(mbox_cons
);
29 static DEFINE_MUTEX(con_mutex
);
31 static int add_to_rbuf(struct mbox_chan
*chan
, void *mssg
)
36 spin_lock_irqsave(&chan
->lock
, flags
);
38 /* See if there is any space left */
39 if (chan
->msg_count
== MBOX_TX_QUEUE_LEN
) {
40 spin_unlock_irqrestore(&chan
->lock
, flags
);
45 chan
->msg_data
[idx
] = mssg
;
48 if (idx
== MBOX_TX_QUEUE_LEN
- 1)
53 spin_unlock_irqrestore(&chan
->lock
, flags
);
58 static void msg_submit(struct mbox_chan
*chan
)
65 spin_lock_irqsave(&chan
->lock
, flags
);
67 if (!chan
->msg_count
|| chan
->active_req
)
70 count
= chan
->msg_count
;
75 idx
+= MBOX_TX_QUEUE_LEN
- count
;
77 data
= chan
->msg_data
[idx
];
79 /* Try to submit a message to the MBOX controller */
80 err
= chan
->mbox
->ops
->send_data(chan
, data
);
82 chan
->active_req
= data
;
86 spin_unlock_irqrestore(&chan
->lock
, flags
);
89 static void tx_tick(struct mbox_chan
*chan
, int r
)
94 spin_lock_irqsave(&chan
->lock
, flags
);
95 mssg
= chan
->active_req
;
96 chan
->active_req
= NULL
;
97 spin_unlock_irqrestore(&chan
->lock
, flags
);
99 /* Submit next message */
102 /* Notify the client */
103 if (mssg
&& chan
->cl
->tx_done
)
104 chan
->cl
->tx_done(chan
->cl
, mssg
, r
);
106 if (chan
->cl
->tx_block
)
107 complete(&chan
->tx_complete
);
110 static void poll_txdone(unsigned long data
)
112 struct mbox_controller
*mbox
= (struct mbox_controller
*)data
;
113 bool txdone
, resched
= false;
116 for (i
= 0; i
< mbox
->num_chans
; i
++) {
117 struct mbox_chan
*chan
= &mbox
->chans
[i
];
119 if (chan
->active_req
&& chan
->cl
) {
121 txdone
= chan
->mbox
->ops
->last_tx_done(chan
);
128 mod_timer(&mbox
->poll
, jiffies
+
129 msecs_to_jiffies(mbox
->txpoll_period
));
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 *
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.
142 void mbox_chan_received_data(struct mbox_chan
*chan
, void *mssg
)
144 /* No buffering the received data */
145 if (chan
->cl
->rx_callback
)
146 chan
->cl
->rx_callback(chan
->cl
, mssg
);
148 EXPORT_SYMBOL_GPL(mbox_chan_received_data
);
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
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.
160 void mbox_chan_txdone(struct mbox_chan
*chan
, int r
)
162 if (unlikely(!(chan
->txdone_method
& TXDONE_BY_IRQ
))) {
163 dev_err(chan
->mbox
->dev
,
164 "Controller can't run the TX ticker\n");
170 EXPORT_SYMBOL_GPL(mbox_chan_txdone
);
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.
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.
181 void mbox_client_txdone(struct mbox_chan
*chan
, int r
)
183 if (unlikely(!(chan
->txdone_method
& TXDONE_BY_ACK
))) {
184 dev_err(chan
->mbox
->dev
, "Client can't run the TX ticker\n");
190 EXPORT_SYMBOL_GPL(mbox_client_txdone
);
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.
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.
203 * Return: True, if controller has, and is going to push after this,
205 * False, if controller doesn't have any data to be read.
207 bool mbox_client_peek_data(struct mbox_chan
*chan
)
209 if (chan
->mbox
->ops
->peek_data
)
210 return chan
->mbox
->ops
->peek_data(chan
);
214 EXPORT_SYMBOL_GPL(mbox_client_peek_data
);
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.
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
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.
236 * Return: Non-negative integer for successful submission (non-blocking mode)
237 * or transmission over chan (blocking mode).
238 * Negative value denotes failure.
240 int mbox_send_message(struct mbox_chan
*chan
, void *mssg
)
244 if (!chan
|| !chan
->cl
)
247 t
= add_to_rbuf(chan
, mssg
);
249 dev_err(chan
->mbox
->dev
, "Try increasing MBOX_TX_QUEUE_LEN\n");
255 if (chan
->txdone_method
== TXDONE_BY_POLL
)
256 poll_txdone((unsigned long)chan
->mbox
);
258 if (chan
->cl
->tx_block
&& chan
->active_req
) {
262 if (!chan
->cl
->tx_tout
) /* wait forever */
263 wait
= msecs_to_jiffies(3600000);
265 wait
= msecs_to_jiffies(chan
->cl
->tx_tout
);
267 ret
= wait_for_completion_timeout(&chan
->tx_complete
, wait
);
276 EXPORT_SYMBOL_GPL(mbox_send_message
);
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.
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.
292 * Return: Pointer to the channel assigned to the client if successful.
293 * ERR_PTR for request failure.
295 struct mbox_chan
*mbox_request_channel(struct mbox_client
*cl
, int index
)
297 struct device
*dev
= cl
->dev
;
298 struct mbox_controller
*mbox
;
299 struct of_phandle_args spec
;
300 struct mbox_chan
*chan
;
304 if (!dev
|| !dev
->of_node
) {
305 pr_debug("%s: No owner device node\n", __func__
);
306 return ERR_PTR(-ENODEV
);
309 mutex_lock(&con_mutex
);
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
);
319 list_for_each_entry(mbox
, &mbox_cons
, node
)
320 if (mbox
->dev
->of_node
== spec
.np
) {
321 chan
= mbox
->of_xlate(mbox
, &spec
);
325 of_node_put(spec
.np
);
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
);
333 spin_lock_irqsave(&chan
->lock
, flags
);
336 chan
->active_req
= NULL
;
338 init_completion(&chan
->tx_complete
);
340 if (chan
->txdone_method
== TXDONE_BY_POLL
&& cl
->knows_txdone
)
341 chan
->txdone_method
|= TXDONE_BY_ACK
;
343 spin_unlock_irqrestore(&chan
->lock
, flags
);
345 ret
= chan
->mbox
->ops
->startup(chan
);
347 dev_err(dev
, "Unable to startup the chan (%d)\n", ret
);
348 mbox_free_channel(chan
);
352 mutex_unlock(&con_mutex
);
355 EXPORT_SYMBOL_GPL(mbox_request_channel
);
358 * mbox_free_channel - The client relinquishes control of a mailbox
359 * channel by this call.
360 * @chan: The mailbox channel to be freed.
362 void mbox_free_channel(struct mbox_chan
*chan
)
366 if (!chan
|| !chan
->cl
)
369 chan
->mbox
->ops
->shutdown(chan
);
371 /* The queued TX requests are simply aborted, no callbacks are made */
372 spin_lock_irqsave(&chan
->lock
, flags
);
374 chan
->active_req
= NULL
;
375 if (chan
->txdone_method
== (TXDONE_BY_POLL
| TXDONE_BY_ACK
))
376 chan
->txdone_method
= TXDONE_BY_POLL
;
378 module_put(chan
->mbox
->dev
->driver
->owner
);
379 spin_unlock_irqrestore(&chan
->lock
, flags
);
381 EXPORT_SYMBOL_GPL(mbox_free_channel
);
383 static struct mbox_chan
*
384 of_mbox_index_xlate(struct mbox_controller
*mbox
,
385 const struct of_phandle_args
*sp
)
387 int ind
= sp
->args
[0];
389 if (ind
>= mbox
->num_chans
)
392 return &mbox
->chans
[ind
];
396 * mbox_controller_register - Register the mailbox controller
397 * @mbox: Pointer to the mailbox controller.
399 * The controller driver registers its communication channels
401 int mbox_controller_register(struct mbox_controller
*mbox
)
406 if (!mbox
|| !mbox
->dev
|| !mbox
->ops
|| !mbox
->num_chans
)
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
;
416 if (txdone
== TXDONE_BY_POLL
) {
417 mbox
->poll
.function
= &poll_txdone
;
418 mbox
->poll
.data
= (unsigned long)mbox
;
419 init_timer(&mbox
->poll
);
422 for (i
= 0; i
< mbox
->num_chans
; i
++) {
423 struct mbox_chan
*chan
= &mbox
->chans
[i
];
427 chan
->txdone_method
= txdone
;
428 spin_lock_init(&chan
->lock
);
432 mbox
->of_xlate
= of_mbox_index_xlate
;
434 mutex_lock(&con_mutex
);
435 list_add_tail(&mbox
->node
, &mbox_cons
);
436 mutex_unlock(&con_mutex
);
440 EXPORT_SYMBOL_GPL(mbox_controller_register
);
443 * mbox_controller_unregister - Unregister the mailbox controller
444 * @mbox: Pointer to the mailbox controller.
446 void mbox_controller_unregister(struct mbox_controller
*mbox
)
453 mutex_lock(&con_mutex
);
455 list_del(&mbox
->node
);
457 for (i
= 0; i
< mbox
->num_chans
; i
++)
458 mbox_free_channel(&mbox
->chans
[i
]);
460 if (mbox
->txdone_poll
)
461 del_timer_sync(&mbox
->poll
);
463 mutex_unlock(&con_mutex
);
465 EXPORT_SYMBOL_GPL(mbox_controller_unregister
);