mailbox-sti.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * STi Mailbox
  4. *
  5. * Copyright (C) 2015 ST Microelectronics
  6. *
  7. * Author: Lee Jones <lee.jones@linaro.org> for ST Microelectronics
  8. *
  9. * Based on the original driver written by;
  10. * Alexandre Torgue, Olivier Lebreton and Loic Pallardy
  11. */
  12. #include <linux/err.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/io.h>
  15. #include <linux/kernel.h>
  16. #include <linux/mailbox_controller.h>
  17. #include <linux/module.h>
  18. #include <linux/of.h>
  19. #include <linux/of_device.h>
  20. #include <linux/platform_device.h>
  21. #include <linux/slab.h>
  22. #include "mailbox.h"
  23. #define STI_MBOX_INST_MAX 4 /* RAM saving: Max supported instances */
  24. #define STI_MBOX_CHAN_MAX 20 /* RAM saving: Max supported channels */
  25. #define STI_IRQ_VAL_OFFSET 0x04 /* Read interrupt status */
  26. #define STI_IRQ_SET_OFFSET 0x24 /* Generate a Tx channel interrupt */
  27. #define STI_IRQ_CLR_OFFSET 0x44 /* Clear pending Rx interrupts */
  28. #define STI_ENA_VAL_OFFSET 0x64 /* Read enable status */
  29. #define STI_ENA_SET_OFFSET 0x84 /* Enable a channel */
  30. #define STI_ENA_CLR_OFFSET 0xa4 /* Disable a channel */
  31. #define MBOX_BASE(mdev, inst) ((mdev)->base + ((inst) * 4))
  32. /**
  33. * STi Mailbox device data
  34. *
  35. * An IP Mailbox is currently composed of 4 instances
  36. * Each instance is currently composed of 32 channels
  37. * This means that we have 128 channels per Mailbox
  38. * A channel an be used for TX or RX
  39. *
  40. * @dev: Device to which it is attached
  41. * @mbox: Representation of a communication channel controller
  42. * @base: Base address of the register mapping region
  43. * @name: Name of the mailbox
  44. * @enabled: Local copy of enabled channels
  45. * @lock: Mutex protecting enabled status
  46. */
  47. struct sti_mbox_device {
  48. struct device *dev;
  49. struct mbox_controller *mbox;
  50. void __iomem *base;
  51. const char *name;
  52. u32 enabled[STI_MBOX_INST_MAX];
  53. spinlock_t lock;
  54. };
  55. /**
  56. * STi Mailbox platform specific configuration
  57. *
  58. * @num_inst: Maximum number of instances in one HW Mailbox
  59. * @num_chan: Maximum number of channel per instance
  60. */
  61. struct sti_mbox_pdata {
  62. unsigned int num_inst;
  63. unsigned int num_chan;
  64. };
  65. /**
  66. * STi Mailbox allocated channel information
  67. *
  68. * @mdev: Pointer to parent Mailbox device
  69. * @instance: Instance number channel resides in
  70. * @channel: Channel number pertaining to this container
  71. */
  72. struct sti_channel {
  73. struct sti_mbox_device *mdev;
  74. unsigned int instance;
  75. unsigned int channel;
  76. };
  77. static inline bool sti_mbox_channel_is_enabled(struct mbox_chan *chan)
  78. {
  79. struct sti_channel *chan_info = chan->con_priv;
  80. struct sti_mbox_device *mdev = chan_info->mdev;
  81. unsigned int instance = chan_info->instance;
  82. unsigned int channel = chan_info->channel;
  83. return mdev->enabled[instance] & BIT(channel);
  84. }
  85. static inline
  86. struct mbox_chan *sti_mbox_to_channel(struct mbox_controller *mbox,
  87. unsigned int instance,
  88. unsigned int channel)
  89. {
  90. struct sti_channel *chan_info;
  91. int i;
  92. for (i = 0; i < mbox->num_chans; i++) {
  93. chan_info = mbox->chans[i].con_priv;
  94. if (chan_info &&
  95. chan_info->instance == instance &&
  96. chan_info->channel == channel)
  97. return &mbox->chans[i];
  98. }
  99. dev_err(mbox->dev,
  100. "Channel not registered: instance: %d channel: %d\n",
  101. instance, channel);
  102. return NULL;
  103. }
  104. static void sti_mbox_enable_channel(struct mbox_chan *chan)
  105. {
  106. struct sti_channel *chan_info = chan->con_priv;
  107. struct sti_mbox_device *mdev = chan_info->mdev;
  108. unsigned int instance = chan_info->instance;
  109. unsigned int channel = chan_info->channel;
  110. unsigned long flags;
  111. void __iomem *base = MBOX_BASE(mdev, instance);
  112. spin_lock_irqsave(&mdev->lock, flags);
  113. mdev->enabled[instance] |= BIT(channel);
  114. writel_relaxed(BIT(channel), base + STI_ENA_SET_OFFSET);
  115. spin_unlock_irqrestore(&mdev->lock, flags);
  116. }
  117. static void sti_mbox_disable_channel(struct mbox_chan *chan)
  118. {
  119. struct sti_channel *chan_info = chan->con_priv;
  120. struct sti_mbox_device *mdev = chan_info->mdev;
  121. unsigned int instance = chan_info->instance;
  122. unsigned int channel = chan_info->channel;
  123. unsigned long flags;
  124. void __iomem *base = MBOX_BASE(mdev, instance);
  125. spin_lock_irqsave(&mdev->lock, flags);
  126. mdev->enabled[instance] &= ~BIT(channel);
  127. writel_relaxed(BIT(channel), base + STI_ENA_CLR_OFFSET);
  128. spin_unlock_irqrestore(&mdev->lock, flags);
  129. }
  130. static void sti_mbox_clear_irq(struct mbox_chan *chan)
  131. {
  132. struct sti_channel *chan_info = chan->con_priv;
  133. struct sti_mbox_device *mdev = chan_info->mdev;
  134. unsigned int instance = chan_info->instance;
  135. unsigned int channel = chan_info->channel;
  136. void __iomem *base = MBOX_BASE(mdev, instance);
  137. writel_relaxed(BIT(channel), base + STI_IRQ_CLR_OFFSET);
  138. }
  139. static struct mbox_chan *sti_mbox_irq_to_channel(struct sti_mbox_device *mdev,
  140. unsigned int instance)
  141. {
  142. struct mbox_controller *mbox = mdev->mbox;
  143. struct mbox_chan *chan = NULL;
  144. unsigned int channel;
  145. unsigned long bits;
  146. void __iomem *base = MBOX_BASE(mdev, instance);
  147. bits = readl_relaxed(base + STI_IRQ_VAL_OFFSET);
  148. if (!bits)
  149. /* No IRQs fired in specified instance */
  150. return NULL;
  151. /* An IRQ has fired, find the associated channel */
  152. for (channel = 0; bits; channel++) {
  153. if (!test_and_clear_bit(channel, &bits))
  154. continue;
  155. chan = sti_mbox_to_channel(mbox, instance, channel);
  156. if (chan) {
  157. dev_dbg(mbox->dev,
  158. "IRQ fired on instance: %d channel: %d\n",
  159. instance, channel);
  160. break;
  161. }
  162. }
  163. return chan;
  164. }
  165. static irqreturn_t sti_mbox_thread_handler(int irq, void *data)
  166. {
  167. struct sti_mbox_device *mdev = data;
  168. struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
  169. struct mbox_chan *chan;
  170. unsigned int instance;
  171. for (instance = 0; instance < pdata->num_inst; instance++) {
  172. keep_looking:
  173. chan = sti_mbox_irq_to_channel(mdev, instance);
  174. if (!chan)
  175. continue;
  176. mbox_chan_received_data(chan, NULL);
  177. sti_mbox_clear_irq(chan);
  178. sti_mbox_enable_channel(chan);
  179. goto keep_looking;
  180. }
  181. return IRQ_HANDLED;
  182. }
  183. static irqreturn_t sti_mbox_irq_handler(int irq, void *data)
  184. {
  185. struct sti_mbox_device *mdev = data;
  186. struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
  187. struct sti_channel *chan_info;
  188. struct mbox_chan *chan;
  189. unsigned int instance;
  190. int ret = IRQ_NONE;
  191. for (instance = 0; instance < pdata->num_inst; instance++) {
  192. chan = sti_mbox_irq_to_channel(mdev, instance);
  193. if (!chan)
  194. continue;
  195. chan_info = chan->con_priv;
  196. if (!sti_mbox_channel_is_enabled(chan)) {
  197. dev_warn(mdev->dev,
  198. "Unexpected IRQ: %s\n"
  199. " instance: %d: channel: %d [enabled: %x]\n",
  200. mdev->name, chan_info->instance,
  201. chan_info->channel, mdev->enabled[instance]);
  202. /* Only handle IRQ if no other valid IRQs were found */
  203. if (ret == IRQ_NONE)
  204. ret = IRQ_HANDLED;
  205. continue;
  206. }
  207. sti_mbox_disable_channel(chan);
  208. ret = IRQ_WAKE_THREAD;
  209. }
  210. if (ret == IRQ_NONE)
  211. dev_err(mdev->dev, "Spurious IRQ - was a channel requested?\n");
  212. return ret;
  213. }
  214. static bool sti_mbox_tx_is_ready(struct mbox_chan *chan)
  215. {
  216. struct sti_channel *chan_info = chan->con_priv;
  217. struct sti_mbox_device *mdev = chan_info->mdev;
  218. unsigned int instance = chan_info->instance;
  219. unsigned int channel = chan_info->channel;
  220. void __iomem *base = MBOX_BASE(mdev, instance);
  221. if (!(readl_relaxed(base + STI_ENA_VAL_OFFSET) & BIT(channel))) {
  222. dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d disabled\n",
  223. mdev->name, instance, channel);
  224. return false;
  225. }
  226. if (readl_relaxed(base + STI_IRQ_VAL_OFFSET) & BIT(channel)) {
  227. dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d not ready\n",
  228. mdev->name, instance, channel);
  229. return false;
  230. }
  231. return true;
  232. }
  233. static int sti_mbox_send_data(struct mbox_chan *chan, void *data)
  234. {
  235. struct sti_channel *chan_info = chan->con_priv;
  236. struct sti_mbox_device *mdev = chan_info->mdev;
  237. unsigned int instance = chan_info->instance;
  238. unsigned int channel = chan_info->channel;
  239. void __iomem *base = MBOX_BASE(mdev, instance);
  240. /* Send event to co-processor */
  241. writel_relaxed(BIT(channel), base + STI_IRQ_SET_OFFSET);
  242. dev_dbg(mdev->dev,
  243. "Sent via Mailbox %s: instance: %d channel: %d\n",
  244. mdev->name, instance, channel);
  245. return 0;
  246. }
  247. static int sti_mbox_startup_chan(struct mbox_chan *chan)
  248. {
  249. sti_mbox_clear_irq(chan);
  250. sti_mbox_enable_channel(chan);
  251. return 0;
  252. }
  253. static void sti_mbox_shutdown_chan(struct mbox_chan *chan)
  254. {
  255. struct sti_channel *chan_info = chan->con_priv;
  256. struct mbox_controller *mbox = chan_info->mdev->mbox;
  257. int i;
  258. for (i = 0; i < mbox->num_chans; i++)
  259. if (chan == &mbox->chans[i])
  260. break;
  261. if (mbox->num_chans == i) {
  262. dev_warn(mbox->dev, "Request to free non-existent channel\n");
  263. return;
  264. }
  265. /* Reset channel */
  266. sti_mbox_disable_channel(chan);
  267. sti_mbox_clear_irq(chan);
  268. chan->con_priv = NULL;
  269. }
  270. static struct mbox_chan *sti_mbox_xlate(struct mbox_controller *mbox,
  271. const struct of_phandle_args *spec)
  272. {
  273. struct sti_mbox_device *mdev = dev_get_drvdata(mbox->dev);
  274. struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
  275. struct sti_channel *chan_info;
  276. struct mbox_chan *chan = NULL;
  277. unsigned int instance = spec->args[0];
  278. unsigned int channel = spec->args[1];
  279. int i;
  280. /* Bounds checking */
  281. if (instance >= pdata->num_inst || channel >= pdata->num_chan) {
  282. dev_err(mbox->dev,
  283. "Invalid channel requested instance: %d channel: %d\n",
  284. instance, channel);
  285. return ERR_PTR(-EINVAL);
  286. }
  287. for (i = 0; i < mbox->num_chans; i++) {
  288. chan_info = mbox->chans[i].con_priv;
  289. /* Is requested channel free? */
  290. if (chan_info &&
  291. mbox->dev == chan_info->mdev->dev &&
  292. instance == chan_info->instance &&
  293. channel == chan_info->channel) {
  294. dev_err(mbox->dev, "Channel in use\n");
  295. return ERR_PTR(-EBUSY);
  296. }
  297. /*
  298. * Find the first free slot, then continue checking
  299. * to see if requested channel is in use
  300. */
  301. if (!chan && !chan_info)
  302. chan = &mbox->chans[i];
  303. }
  304. if (!chan) {
  305. dev_err(mbox->dev, "No free channels left\n");
  306. return ERR_PTR(-EBUSY);
  307. }
  308. chan_info = devm_kzalloc(mbox->dev, sizeof(*chan_info), GFP_KERNEL);
  309. if (!chan_info)
  310. return ERR_PTR(-ENOMEM);
  311. chan_info->mdev = mdev;
  312. chan_info->instance = instance;
  313. chan_info->channel = channel;
  314. chan->con_priv = chan_info;
  315. dev_info(mbox->dev,
  316. "Mbox: %s: Created channel: instance: %d channel: %d\n",
  317. mdev->name, instance, channel);
  318. return chan;
  319. }
  320. static const struct mbox_chan_ops sti_mbox_ops = {
  321. .startup = sti_mbox_startup_chan,
  322. .shutdown = sti_mbox_shutdown_chan,
  323. .send_data = sti_mbox_send_data,
  324. .last_tx_done = sti_mbox_tx_is_ready,
  325. };
  326. static const struct sti_mbox_pdata mbox_stih407_pdata = {
  327. .num_inst = 4,
  328. .num_chan = 32,
  329. };
  330. static const struct of_device_id sti_mailbox_match[] = {
  331. {
  332. .compatible = "st,stih407-mailbox",
  333. .data = (void *)&mbox_stih407_pdata
  334. },
  335. { }
  336. };
  337. MODULE_DEVICE_TABLE(of, sti_mailbox_match);
  338. static int sti_mbox_probe(struct platform_device *pdev)
  339. {
  340. const struct of_device_id *match;
  341. struct mbox_controller *mbox;
  342. struct sti_mbox_device *mdev;
  343. struct device_node *np = pdev->dev.of_node;
  344. struct mbox_chan *chans;
  345. struct resource *res;
  346. int irq;
  347. int ret;
  348. match = of_match_device(sti_mailbox_match, &pdev->dev);
  349. if (!match) {
  350. dev_err(&pdev->dev, "No configuration found\n");
  351. return -ENODEV;
  352. }
  353. pdev->dev.platform_data = (struct sti_mbox_pdata *) match->data;
  354. mdev = devm_kzalloc(&pdev->dev, sizeof(*mdev), GFP_KERNEL);
  355. if (!mdev)
  356. return -ENOMEM;
  357. platform_set_drvdata(pdev, mdev);
  358. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  359. mdev->base = devm_ioremap_resource(&pdev->dev, res);
  360. if (IS_ERR(mdev->base))
  361. return PTR_ERR(mdev->base);
  362. ret = of_property_read_string(np, "mbox-name", &mdev->name);
  363. if (ret)
  364. mdev->name = np->full_name;
  365. mbox = devm_kzalloc(&pdev->dev, sizeof(*mbox), GFP_KERNEL);
  366. if (!mbox)
  367. return -ENOMEM;
  368. chans = devm_kcalloc(&pdev->dev,
  369. STI_MBOX_CHAN_MAX, sizeof(*chans), GFP_KERNEL);
  370. if (!chans)
  371. return -ENOMEM;
  372. mdev->dev = &pdev->dev;
  373. mdev->mbox = mbox;
  374. spin_lock_init(&mdev->lock);
  375. /* STi Mailbox does not have a Tx-Done or Tx-Ready IRQ */
  376. mbox->txdone_irq = false;
  377. mbox->txdone_poll = true;
  378. mbox->txpoll_period = 100;
  379. mbox->ops = &sti_mbox_ops;
  380. mbox->dev = mdev->dev;
  381. mbox->of_xlate = sti_mbox_xlate;
  382. mbox->chans = chans;
  383. mbox->num_chans = STI_MBOX_CHAN_MAX;
  384. ret = devm_mbox_controller_register(&pdev->dev, mbox);
  385. if (ret)
  386. return ret;
  387. /* It's okay for Tx Mailboxes to not supply IRQs */
  388. irq = platform_get_irq(pdev, 0);
  389. if (irq < 0) {
  390. dev_info(&pdev->dev,
  391. "%s: Registered Tx only Mailbox\n", mdev->name);
  392. return 0;
  393. }
  394. ret = devm_request_threaded_irq(&pdev->dev, irq,
  395. sti_mbox_irq_handler,
  396. sti_mbox_thread_handler,
  397. IRQF_ONESHOT, mdev->name, mdev);
  398. if (ret) {
  399. dev_err(&pdev->dev, "Can't claim IRQ %d\n", irq);
  400. return -EINVAL;
  401. }
  402. dev_info(&pdev->dev, "%s: Registered Tx/Rx Mailbox\n", mdev->name);
  403. return 0;
  404. }
  405. static struct platform_driver sti_mbox_driver = {
  406. .probe = sti_mbox_probe,
  407. .driver = {
  408. .name = "sti-mailbox",
  409. .of_match_table = sti_mailbox_match,
  410. },
  411. };
  412. module_platform_driver(sti_mbox_driver);
  413. MODULE_LICENSE("GPL");
  414. MODULE_DESCRIPTION("STMicroelectronics Mailbox Controller");
  415. MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org");
  416. MODULE_ALIAS("platform:mailbox-sti");