Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
2b6d83e2 JB |
2 | /* |
3 | * Mailbox: Common code for Mailbox controllers and users | |
4 | * | |
5 | * Copyright (C) 2013-2014 Linaro Ltd. | |
6 | * Author: Jassi Brar <jassisinghbrar@gmail.com> | |
2b6d83e2 JB |
7 | */ |
8 | ||
9 | #include <linux/interrupt.h> | |
10 | #include <linux/spinlock.h> | |
11 | #include <linux/mutex.h> | |
12 | #include <linux/delay.h> | |
13 | #include <linux/slab.h> | |
14 | #include <linux/err.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/device.h> | |
17 | #include <linux/bitops.h> | |
18 | #include <linux/mailbox_client.h> | |
19 | #include <linux/mailbox_controller.h> | |
20 | ||
86c22f8c | 21 | #include "mailbox.h" |
2b6d83e2 JB |
22 | |
23 | static LIST_HEAD(mbox_cons); | |
24 | static DEFINE_MUTEX(con_mutex); | |
25 | ||
26 | static int add_to_rbuf(struct mbox_chan *chan, void *mssg) | |
27 | { | |
28 | int idx; | |
29 | unsigned long flags; | |
30 | ||
31 | spin_lock_irqsave(&chan->lock, flags); | |
32 | ||
33 | /* See if there is any space left */ | |
34 | if (chan->msg_count == MBOX_TX_QUEUE_LEN) { | |
35 | spin_unlock_irqrestore(&chan->lock, flags); | |
36 | return -ENOBUFS; | |
37 | } | |
38 | ||
39 | idx = chan->msg_free; | |
40 | chan->msg_data[idx] = mssg; | |
41 | chan->msg_count++; | |
42 | ||
43 | if (idx == MBOX_TX_QUEUE_LEN - 1) | |
44 | chan->msg_free = 0; | |
45 | else | |
46 | chan->msg_free++; | |
47 | ||
48 | spin_unlock_irqrestore(&chan->lock, flags); | |
49 | ||
50 | return idx; | |
51 | } | |
52 | ||
53 | static void msg_submit(struct mbox_chan *chan) | |
54 | { | |
55 | unsigned count, idx; | |
56 | unsigned long flags; | |
57 | void *data; | |
52a49306 | 58 | int err = -EBUSY; |
2b6d83e2 JB |
59 | |
60 | spin_lock_irqsave(&chan->lock, flags); | |
61 | ||
62 | if (!chan->msg_count || chan->active_req) | |
63 | goto exit; | |
64 | ||
65 | count = chan->msg_count; | |
66 | idx = chan->msg_free; | |
67 | if (idx >= count) | |
68 | idx -= count; | |
69 | else | |
70 | idx += MBOX_TX_QUEUE_LEN - count; | |
71 | ||
72 | data = chan->msg_data[idx]; | |
73 | ||
97b0c7bd SH |
74 | if (chan->cl->tx_prepare) |
75 | chan->cl->tx_prepare(chan->cl, data); | |
2b6d83e2 JB |
76 | /* Try to submit a message to the MBOX controller */ |
77 | err = chan->mbox->ops->send_data(chan, data); | |
78 | if (!err) { | |
79 | chan->active_req = data; | |
80 | chan->msg_count--; | |
81 | } | |
82 | exit: | |
83 | spin_unlock_irqrestore(&chan->lock, flags); | |
52a49306 | 84 | |
c7dacf5b | 85 | if (!err && (chan->txdone_method & TXDONE_BY_POLL)) { |
bca1a100 BA |
86 | /* kick start the timer immediately to avoid delays */ |
87 | spin_lock_irqsave(&chan->mbox->poll_hrt_lock, flags); | |
88 | hrtimer_start(&chan->mbox->poll_hrt, 0, HRTIMER_MODE_REL); | |
89 | spin_unlock_irqrestore(&chan->mbox->poll_hrt_lock, flags); | |
c7dacf5b | 90 | } |
2b6d83e2 JB |
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 | ||
cb710ab1 SH |
106 | if (!mssg) |
107 | return; | |
108 | ||
2b6d83e2 | 109 | /* Notify the client */ |
cb710ab1 | 110 | if (chan->cl->tx_done) |
2b6d83e2 JB |
111 | chan->cl->tx_done(chan->cl, mssg, r); |
112 | ||
cc6eeaa3 | 113 | if (r != -ETIME && chan->cl->tx_block) |
2b6d83e2 JB |
114 | complete(&chan->tx_complete); |
115 | } | |
116 | ||
0cc67945 | 117 | static enum hrtimer_restart txdone_hrtimer(struct hrtimer *hrtimer) |
2b6d83e2 | 118 | { |
0cc67945 SH |
119 | struct mbox_controller *mbox = |
120 | container_of(hrtimer, struct mbox_controller, poll_hrt); | |
2b6d83e2 JB |
121 | bool txdone, resched = false; |
122 | int i; | |
bca1a100 | 123 | unsigned long flags; |
2b6d83e2 JB |
124 | |
125 | for (i = 0; i < mbox->num_chans; i++) { | |
126 | struct mbox_chan *chan = &mbox->chans[i]; | |
127 | ||
128 | if (chan->active_req && chan->cl) { | |
2b6d83e2 JB |
129 | txdone = chan->mbox->ops->last_tx_done(chan); |
130 | if (txdone) | |
131 | tx_tick(chan, 0); | |
bca1a100 BA |
132 | else |
133 | resched = true; | |
2b6d83e2 JB |
134 | } |
135 | } | |
136 | ||
0cc67945 | 137 | if (resched) { |
bca1a100 BA |
138 | spin_lock_irqsave(&mbox->poll_hrt_lock, flags); |
139 | if (!hrtimer_is_queued(hrtimer)) | |
140 | hrtimer_forward_now(hrtimer, ms_to_ktime(mbox->txpoll_period)); | |
141 | spin_unlock_irqrestore(&mbox->poll_hrt_lock, flags); | |
142 | ||
0cc67945 SH |
143 | return HRTIMER_RESTART; |
144 | } | |
145 | return HRTIMER_NORESTART; | |
2b6d83e2 JB |
146 | } |
147 | ||
148 | /** | |
149 | * mbox_chan_received_data - A way for controller driver to push data | |
150 | * received from remote to the upper layer. | |
151 | * @chan: Pointer to the mailbox channel on which RX happened. | |
152 | * @mssg: Client specific message typecasted as void * | |
153 | * | |
154 | * After startup and before shutdown any data received on the chan | |
155 | * is passed on to the API via atomic mbox_chan_received_data(). | |
156 | * The controller should ACK the RX only after this call returns. | |
157 | */ | |
158 | void mbox_chan_received_data(struct mbox_chan *chan, void *mssg) | |
159 | { | |
160 | /* No buffering the received data */ | |
161 | if (chan->cl->rx_callback) | |
162 | chan->cl->rx_callback(chan->cl, mssg); | |
163 | } | |
164 | EXPORT_SYMBOL_GPL(mbox_chan_received_data); | |
165 | ||
166 | /** | |
167 | * mbox_chan_txdone - A way for controller driver to notify the | |
168 | * framework that the last TX has completed. | |
169 | * @chan: Pointer to the mailbox chan on which TX happened. | |
170 | * @r: Status of last TX - OK or ERROR | |
171 | * | |
172 | * The controller that has IRQ for TX ACK calls this atomic API | |
173 | * to tick the TX state machine. It works only if txdone_irq | |
174 | * is set by the controller. | |
175 | */ | |
176 | void mbox_chan_txdone(struct mbox_chan *chan, int r) | |
177 | { | |
178 | if (unlikely(!(chan->txdone_method & TXDONE_BY_IRQ))) { | |
179 | dev_err(chan->mbox->dev, | |
180 | "Controller can't run the TX ticker\n"); | |
181 | return; | |
182 | } | |
183 | ||
184 | tx_tick(chan, r); | |
185 | } | |
186 | EXPORT_SYMBOL_GPL(mbox_chan_txdone); | |
187 | ||
188 | /** | |
189 | * mbox_client_txdone - The way for a client to run the TX state machine. | |
190 | * @chan: Mailbox channel assigned to this client. | |
191 | * @r: Success status of last transmission. | |
192 | * | |
193 | * The client/protocol had received some 'ACK' packet and it notifies | |
194 | * the API that the last packet was sent successfully. This only works | |
195 | * if the controller can't sense TX-Done. | |
196 | */ | |
197 | void mbox_client_txdone(struct mbox_chan *chan, int r) | |
198 | { | |
199 | if (unlikely(!(chan->txdone_method & TXDONE_BY_ACK))) { | |
200 | dev_err(chan->mbox->dev, "Client can't run the TX ticker\n"); | |
201 | return; | |
202 | } | |
203 | ||
204 | tx_tick(chan, r); | |
205 | } | |
206 | EXPORT_SYMBOL_GPL(mbox_client_txdone); | |
207 | ||
208 | /** | |
209 | * mbox_client_peek_data - A way for client driver to pull data | |
210 | * received from remote by the controller. | |
211 | * @chan: Mailbox channel assigned to this client. | |
212 | * | |
213 | * A poke to controller driver for any received data. | |
214 | * The data is actually passed onto client via the | |
215 | * mbox_chan_received_data() | |
216 | * The call can be made from atomic context, so the controller's | |
217 | * implementation of peek_data() must not sleep. | |
218 | * | |
219 | * Return: True, if controller has, and is going to push after this, | |
220 | * some data. | |
221 | * False, if controller doesn't have any data to be read. | |
222 | */ | |
223 | bool mbox_client_peek_data(struct mbox_chan *chan) | |
224 | { | |
225 | if (chan->mbox->ops->peek_data) | |
226 | return chan->mbox->ops->peek_data(chan); | |
227 | ||
228 | return false; | |
229 | } | |
230 | EXPORT_SYMBOL_GPL(mbox_client_peek_data); | |
231 | ||
232 | /** | |
233 | * mbox_send_message - For client to submit a message to be | |
234 | * sent to the remote. | |
235 | * @chan: Mailbox channel assigned to this client. | |
236 | * @mssg: Client specific message typecasted. | |
237 | * | |
238 | * For client to submit data to the controller destined for a remote | |
239 | * processor. If the client had set 'tx_block', the call will return | |
240 | * either when the remote receives the data or when 'tx_tout' millisecs | |
241 | * run out. | |
242 | * In non-blocking mode, the requests are buffered by the API and a | |
243 | * non-negative token is returned for each queued request. If the request | |
244 | * is not queued, a negative token is returned. Upon failure or successful | |
245 | * TX, the API calls 'tx_done' from atomic context, from which the client | |
246 | * could submit yet another request. | |
247 | * The pointer to message should be preserved until it is sent | |
248 | * over the chan, i.e, tx_done() is made. | |
249 | * This function could be called from atomic context as it simply | |
250 | * queues the data and returns a token against the request. | |
251 | * | |
252 | * Return: Non-negative integer for successful submission (non-blocking mode) | |
253 | * or transmission over chan (blocking mode). | |
254 | * Negative value denotes failure. | |
255 | */ | |
256 | int mbox_send_message(struct mbox_chan *chan, void *mssg) | |
257 | { | |
258 | int t; | |
259 | ||
260 | if (!chan || !chan->cl) | |
261 | return -EINVAL; | |
262 | ||
263 | t = add_to_rbuf(chan, mssg); | |
264 | if (t < 0) { | |
265 | dev_err(chan->mbox->dev, "Try increasing MBOX_TX_QUEUE_LEN\n"); | |
266 | return t; | |
267 | } | |
268 | ||
269 | msg_submit(chan); | |
270 | ||
c61b781e | 271 | if (chan->cl->tx_block) { |
2b6d83e2 JB |
272 | unsigned long wait; |
273 | int ret; | |
274 | ||
275 | if (!chan->cl->tx_tout) /* wait forever */ | |
276 | wait = msecs_to_jiffies(3600000); | |
277 | else | |
278 | wait = msecs_to_jiffies(chan->cl->tx_tout); | |
279 | ||
280 | ret = wait_for_completion_timeout(&chan->tx_complete, wait); | |
281 | if (ret == 0) { | |
cc6eeaa3 SH |
282 | t = -ETIME; |
283 | tx_tick(chan, t); | |
2b6d83e2 JB |
284 | } |
285 | } | |
286 | ||
287 | return t; | |
288 | } | |
289 | EXPORT_SYMBOL_GPL(mbox_send_message); | |
290 | ||
a8803d74 TR |
291 | /** |
292 | * mbox_flush - flush a mailbox channel | |
293 | * @chan: mailbox channel to flush | |
294 | * @timeout: time, in milliseconds, to allow the flush operation to succeed | |
295 | * | |
296 | * Mailbox controllers that need to work in atomic context can implement the | |
297 | * ->flush() callback to busy loop until a transmission has been completed. | |
298 | * The implementation must call mbox_chan_txdone() upon success. Clients can | |
299 | * call the mbox_flush() function at any time after mbox_send_message() to | |
300 | * flush the transmission. After the function returns success, the mailbox | |
301 | * transmission is guaranteed to have completed. | |
302 | * | |
303 | * Returns: 0 on success or a negative error code on failure. | |
304 | */ | |
305 | int mbox_flush(struct mbox_chan *chan, unsigned long timeout) | |
306 | { | |
307 | int ret; | |
308 | ||
309 | if (!chan->mbox->ops->flush) | |
310 | return -ENOTSUPP; | |
311 | ||
312 | ret = chan->mbox->ops->flush(chan, timeout); | |
313 | if (ret < 0) | |
314 | tx_tick(chan, ret); | |
315 | ||
316 | return ret; | |
317 | } | |
4f055779 | 318 | EXPORT_SYMBOL_GPL(mbox_flush); |
a8803d74 | 319 | |
2b6d83e2 JB |
320 | /** |
321 | * mbox_request_channel - Request a mailbox channel. | |
322 | * @cl: Identity of the client requesting the channel. | |
323 | * @index: Index of mailbox specifier in 'mboxes' property. | |
324 | * | |
325 | * The Client specifies its requirements and capabilities while asking for | |
326 | * a mailbox channel. It can't be called from atomic context. | |
327 | * The channel is exclusively allocated and can't be used by another | |
328 | * client before the owner calls mbox_free_channel. | |
329 | * After assignment, any packet received on this channel will be | |
330 | * handed over to the client via the 'rx_callback'. | |
331 | * The framework holds reference to the client, so the mbox_client | |
332 | * structure shouldn't be modified until the mbox_free_channel returns. | |
333 | * | |
334 | * Return: Pointer to the channel assigned to the client if successful. | |
335 | * ERR_PTR for request failure. | |
336 | */ | |
337 | struct mbox_chan *mbox_request_channel(struct mbox_client *cl, int index) | |
338 | { | |
339 | struct device *dev = cl->dev; | |
340 | struct mbox_controller *mbox; | |
341 | struct of_phandle_args spec; | |
342 | struct mbox_chan *chan; | |
343 | unsigned long flags; | |
344 | int ret; | |
345 | ||
346 | if (!dev || !dev->of_node) { | |
347 | pr_debug("%s: No owner device node\n", __func__); | |
348 | return ERR_PTR(-ENODEV); | |
349 | } | |
350 | ||
351 | mutex_lock(&con_mutex); | |
352 | ||
353 | if (of_parse_phandle_with_args(dev->of_node, "mboxes", | |
354 | "#mbox-cells", index, &spec)) { | |
355 | dev_dbg(dev, "%s: can't parse \"mboxes\" property\n", __func__); | |
356 | mutex_unlock(&con_mutex); | |
357 | return ERR_PTR(-ENODEV); | |
358 | } | |
359 | ||
2d805fc1 | 360 | chan = ERR_PTR(-EPROBE_DEFER); |
2b6d83e2 JB |
361 | list_for_each_entry(mbox, &mbox_cons, node) |
362 | if (mbox->dev->of_node == spec.np) { | |
363 | chan = mbox->of_xlate(mbox, &spec); | |
8ed82e23 MP |
364 | if (!IS_ERR(chan)) |
365 | break; | |
2b6d83e2 JB |
366 | } |
367 | ||
368 | of_node_put(spec.np); | |
369 | ||
2d805fc1 BL |
370 | if (IS_ERR(chan)) { |
371 | mutex_unlock(&con_mutex); | |
372 | return chan; | |
373 | } | |
374 | ||
375 | if (chan->cl || !try_module_get(mbox->dev->driver->owner)) { | |
2b6d83e2 JB |
376 | dev_dbg(dev, "%s: mailbox not free\n", __func__); |
377 | mutex_unlock(&con_mutex); | |
378 | return ERR_PTR(-EBUSY); | |
379 | } | |
380 | ||
381 | spin_lock_irqsave(&chan->lock, flags); | |
382 | chan->msg_free = 0; | |
383 | chan->msg_count = 0; | |
384 | chan->active_req = NULL; | |
385 | chan->cl = cl; | |
386 | init_completion(&chan->tx_complete); | |
387 | ||
388 | if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone) | |
33cd7123 | 389 | chan->txdone_method = TXDONE_BY_ACK; |
2b6d83e2 JB |
390 | |
391 | spin_unlock_irqrestore(&chan->lock, flags); | |
392 | ||
b7133d6f BA |
393 | if (chan->mbox->ops->startup) { |
394 | ret = chan->mbox->ops->startup(chan); | |
395 | ||
396 | if (ret) { | |
397 | dev_err(dev, "Unable to startup the chan (%d)\n", ret); | |
398 | mbox_free_channel(chan); | |
399 | chan = ERR_PTR(ret); | |
400 | } | |
2b6d83e2 JB |
401 | } |
402 | ||
403 | mutex_unlock(&con_mutex); | |
404 | return chan; | |
405 | } | |
406 | EXPORT_SYMBOL_GPL(mbox_request_channel); | |
407 | ||
dfabde20 LJ |
408 | struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl, |
409 | const char *name) | |
410 | { | |
411 | struct device_node *np = cl->dev->of_node; | |
412 | struct property *prop; | |
413 | const char *mbox_name; | |
414 | int index = 0; | |
415 | ||
416 | if (!np) { | |
417 | dev_err(cl->dev, "%s() currently only supports DT\n", __func__); | |
0c44d789 | 418 | return ERR_PTR(-EINVAL); |
dfabde20 LJ |
419 | } |
420 | ||
421 | if (!of_get_property(np, "mbox-names", NULL)) { | |
422 | dev_err(cl->dev, | |
423 | "%s() requires an \"mbox-names\" property\n", __func__); | |
0c44d789 | 424 | return ERR_PTR(-EINVAL); |
dfabde20 LJ |
425 | } |
426 | ||
427 | of_property_for_each_string(np, "mbox-names", prop, mbox_name) { | |
428 | if (!strncmp(name, mbox_name, strlen(name))) | |
25777e57 | 429 | return mbox_request_channel(cl, index); |
dfabde20 LJ |
430 | index++; |
431 | } | |
432 | ||
25777e57 | 433 | dev_err(cl->dev, "%s() could not locate channel named \"%s\"\n", |
434 | __func__, name); | |
435 | return ERR_PTR(-EINVAL); | |
dfabde20 LJ |
436 | } |
437 | EXPORT_SYMBOL_GPL(mbox_request_channel_byname); | |
438 | ||
2b6d83e2 JB |
439 | /** |
440 | * mbox_free_channel - The client relinquishes control of a mailbox | |
441 | * channel by this call. | |
442 | * @chan: The mailbox channel to be freed. | |
443 | */ | |
444 | void mbox_free_channel(struct mbox_chan *chan) | |
445 | { | |
446 | unsigned long flags; | |
447 | ||
448 | if (!chan || !chan->cl) | |
449 | return; | |
450 | ||
b7133d6f BA |
451 | if (chan->mbox->ops->shutdown) |
452 | chan->mbox->ops->shutdown(chan); | |
2b6d83e2 JB |
453 | |
454 | /* The queued TX requests are simply aborted, no callbacks are made */ | |
455 | spin_lock_irqsave(&chan->lock, flags); | |
456 | chan->cl = NULL; | |
457 | chan->active_req = NULL; | |
33cd7123 | 458 | if (chan->txdone_method == TXDONE_BY_ACK) |
2b6d83e2 JB |
459 | chan->txdone_method = TXDONE_BY_POLL; |
460 | ||
461 | module_put(chan->mbox->dev->driver->owner); | |
462 | spin_unlock_irqrestore(&chan->lock, flags); | |
463 | } | |
464 | EXPORT_SYMBOL_GPL(mbox_free_channel); | |
465 | ||
466 | static struct mbox_chan * | |
467 | of_mbox_index_xlate(struct mbox_controller *mbox, | |
468 | const struct of_phandle_args *sp) | |
469 | { | |
470 | int ind = sp->args[0]; | |
471 | ||
472 | if (ind >= mbox->num_chans) | |
2d805fc1 | 473 | return ERR_PTR(-EINVAL); |
2b6d83e2 JB |
474 | |
475 | return &mbox->chans[ind]; | |
476 | } | |
477 | ||
478 | /** | |
479 | * mbox_controller_register - Register the mailbox controller | |
480 | * @mbox: Pointer to the mailbox controller. | |
481 | * | |
482 | * The controller driver registers its communication channels | |
483 | */ | |
484 | int mbox_controller_register(struct mbox_controller *mbox) | |
485 | { | |
486 | int i, txdone; | |
487 | ||
488 | /* Sanity check */ | |
489 | if (!mbox || !mbox->dev || !mbox->ops || !mbox->num_chans) | |
490 | return -EINVAL; | |
491 | ||
492 | if (mbox->txdone_irq) | |
493 | txdone = TXDONE_BY_IRQ; | |
494 | else if (mbox->txdone_poll) | |
495 | txdone = TXDONE_BY_POLL; | |
496 | else /* It has to be ACK then */ | |
497 | txdone = TXDONE_BY_ACK; | |
498 | ||
499 | if (txdone == TXDONE_BY_POLL) { | |
4605fff0 AK |
500 | |
501 | if (!mbox->ops->last_tx_done) { | |
502 | dev_err(mbox->dev, "last_tx_done method is absent\n"); | |
503 | return -EINVAL; | |
504 | } | |
505 | ||
0cc67945 SH |
506 | hrtimer_init(&mbox->poll_hrt, CLOCK_MONOTONIC, |
507 | HRTIMER_MODE_REL); | |
508 | mbox->poll_hrt.function = txdone_hrtimer; | |
bca1a100 | 509 | spin_lock_init(&mbox->poll_hrt_lock); |
2b6d83e2 JB |
510 | } |
511 | ||
512 | for (i = 0; i < mbox->num_chans; i++) { | |
513 | struct mbox_chan *chan = &mbox->chans[i]; | |
514 | ||
515 | chan->cl = NULL; | |
516 | chan->mbox = mbox; | |
517 | chan->txdone_method = txdone; | |
518 | spin_lock_init(&chan->lock); | |
519 | } | |
520 | ||
521 | if (!mbox->of_xlate) | |
522 | mbox->of_xlate = of_mbox_index_xlate; | |
523 | ||
524 | mutex_lock(&con_mutex); | |
525 | list_add_tail(&mbox->node, &mbox_cons); | |
526 | mutex_unlock(&con_mutex); | |
527 | ||
528 | return 0; | |
529 | } | |
530 | EXPORT_SYMBOL_GPL(mbox_controller_register); | |
531 | ||
532 | /** | |
533 | * mbox_controller_unregister - Unregister the mailbox controller | |
534 | * @mbox: Pointer to the mailbox controller. | |
535 | */ | |
536 | void mbox_controller_unregister(struct mbox_controller *mbox) | |
537 | { | |
538 | int i; | |
539 | ||
540 | if (!mbox) | |
541 | return; | |
542 | ||
543 | mutex_lock(&con_mutex); | |
544 | ||
545 | list_del(&mbox->node); | |
546 | ||
547 | for (i = 0; i < mbox->num_chans; i++) | |
548 | mbox_free_channel(&mbox->chans[i]); | |
549 | ||
550 | if (mbox->txdone_poll) | |
0cc67945 | 551 | hrtimer_cancel(&mbox->poll_hrt); |
2b6d83e2 JB |
552 | |
553 | mutex_unlock(&con_mutex); | |
554 | } | |
555 | EXPORT_SYMBOL_GPL(mbox_controller_unregister); | |
e898d9cd TR |
556 | |
557 | static void __devm_mbox_controller_unregister(struct device *dev, void *res) | |
558 | { | |
559 | struct mbox_controller **mbox = res; | |
560 | ||
561 | mbox_controller_unregister(*mbox); | |
562 | } | |
563 | ||
564 | static int devm_mbox_controller_match(struct device *dev, void *res, void *data) | |
565 | { | |
566 | struct mbox_controller **mbox = res; | |
567 | ||
568 | if (WARN_ON(!mbox || !*mbox)) | |
569 | return 0; | |
570 | ||
571 | return *mbox == data; | |
572 | } | |
573 | ||
574 | /** | |
575 | * devm_mbox_controller_register() - managed mbox_controller_register() | |
576 | * @dev: device owning the mailbox controller being registered | |
577 | * @mbox: mailbox controller being registered | |
578 | * | |
579 | * This function adds a device-managed resource that will make sure that the | |
580 | * mailbox controller, which is registered using mbox_controller_register() | |
581 | * as part of this function, will be unregistered along with the rest of | |
582 | * device-managed resources upon driver probe failure or driver removal. | |
583 | * | |
584 | * Returns 0 on success or a negative error code on failure. | |
585 | */ | |
586 | int devm_mbox_controller_register(struct device *dev, | |
587 | struct mbox_controller *mbox) | |
588 | { | |
589 | struct mbox_controller **ptr; | |
590 | int err; | |
591 | ||
592 | ptr = devres_alloc(__devm_mbox_controller_unregister, sizeof(*ptr), | |
593 | GFP_KERNEL); | |
594 | if (!ptr) | |
595 | return -ENOMEM; | |
596 | ||
597 | err = mbox_controller_register(mbox); | |
598 | if (err < 0) { | |
599 | devres_free(ptr); | |
600 | return err; | |
601 | } | |
602 | ||
603 | devres_add(dev, ptr); | |
604 | *ptr = mbox; | |
605 | ||
606 | return 0; | |
607 | } | |
608 | EXPORT_SYMBOL_GPL(devm_mbox_controller_register); | |
609 | ||
610 | /** | |
611 | * devm_mbox_controller_unregister() - managed mbox_controller_unregister() | |
612 | * @dev: device owning the mailbox controller being unregistered | |
613 | * @mbox: mailbox controller being unregistered | |
614 | * | |
615 | * This function unregisters the mailbox controller and removes the device- | |
616 | * managed resource that was set up to automatically unregister the mailbox | |
617 | * controller on driver probe failure or driver removal. It's typically not | |
618 | * necessary to call this function. | |
619 | */ | |
620 | void devm_mbox_controller_unregister(struct device *dev, struct mbox_controller *mbox) | |
621 | { | |
622 | WARN_ON(devres_release(dev, __devm_mbox_controller_unregister, | |
623 | devm_mbox_controller_match, mbox)); | |
624 | } | |
625 | EXPORT_SYMBOL_GPL(devm_mbox_controller_unregister); |