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