mailbox.c 16 KB

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