drivers/mailbox/hi3660-mailbox.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2017-2018 Hisilicon Limited.
   3 // Copyright (c) 2017-2018 Linaro Limited.
   4
   5 #include <linux/bitops.h>
   6 #include <linux/delay.h>
   7 #include <linux/device.h>
   8 #include <linux/err.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/io.h>
  11 #include <linux/iopoll.h>
  12 #include <linux/mailbox_controller.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/slab.h>
  16
  17 #include "mailbox.h"
  18
  19 #define MBOX_CHAN_MAX                   32
  20
  21 #define MBOX_RX                         0x0
  22 #define MBOX_TX                         0x1
  23
  24 #define MBOX_BASE(mbox, ch)             ((mbox)->base + ((ch) * 0x40))
  25 #define MBOX_SRC_REG                    0x00
  26 #define MBOX_DST_REG                    0x04
  27 #define MBOX_DCLR_REG                   0x08
  28 #define MBOX_DSTAT_REG                  0x0c
  29 #define MBOX_MODE_REG                   0x10
  30 #define MBOX_IMASK_REG                  0x14
  31 #define MBOX_ICLR_REG                   0x18
  32 #define MBOX_SEND_REG                   0x1c
  33 #define MBOX_DATA_REG                   0x20
  34
  35 #define MBOX_IPC_LOCK_REG               0xa00
  36 #define MBOX_IPC_UNLOCK                 0x1acce551
  37
  38 #define MBOX_AUTOMATIC_ACK              1
  39
  40 #define MBOX_STATE_IDLE                 BIT(4)
  41 #define MBOX_STATE_ACK                  BIT(7)
  42
  43 #define MBOX_MSG_LEN                    8
  44
  45 /**
  46  * Hi3660 mailbox channel information
  47  *
  48  * A channel can be used for TX or RX, it can trigger remote
  49  * processor interrupt to notify remote processor and can receive
  50  * interrupt if has incoming message.
  51  *
  52  * @dst_irq:    Interrupt vector for remote processor
  53  * @ack_irq:    Interrupt vector for local processor
  54  */
  55 struct hi3660_chan_info {
  56         unsigned int dst_irq;
  57         unsigned int ack_irq;
  58 };
  59
  60 /**
  61  * Hi3660 mailbox controller data
  62  *
  63  * Mailbox controller includes 32 channels and can allocate
  64  * channel for message transferring.
  65  *
  66  * @dev:        Device to which it is attached
  67  * @base:       Base address of the register mapping region
  68  * @chan:       Representation of channels in mailbox controller
  69  * @mchan:      Representation of channel info
  70  * @controller: Representation of a communication channel controller
  71  */
  72 struct hi3660_mbox {
  73         struct device *dev;
  74         void __iomem *base;
  75         struct mbox_chan chan[MBOX_CHAN_MAX];
  76         struct hi3660_chan_info mchan[MBOX_CHAN_MAX];
  77         struct mbox_controller controller;
  78 };
  79
  80 static struct hi3660_mbox *to_hi3660_mbox(struct mbox_controller *mbox)
  81 {
  82         return container_of(mbox, struct hi3660_mbox, controller);
  83 }
  84
  85 static int hi3660_mbox_check_state(struct mbox_chan *chan)
  86 {
  87         unsigned long ch = (unsigned long)chan->con_priv;
  88         struct hi3660_mbox *mbox = to_hi3660_mbox(chan->mbox);
  89         struct hi3660_chan_info *mchan = &mbox->mchan[ch];
  90         void __iomem *base = MBOX_BASE(mbox, ch);
  91         unsigned long val;
  92         unsigned int ret;
  93
  94         /* Mailbox is idle so directly bail out */
  95         if (readl(base + MBOX_MODE_REG) & MBOX_STATE_IDLE)
  96                 return 0;
  97
  98         /* Wait for acknowledge from remote */
  99         ret = readx_poll_timeout_atomic(readl, base + MBOX_MODE_REG,
 100                         val, (val & MBOX_STATE_ACK), 1000, 300000);
 101         if (ret) {
 102                 dev_err(mbox->dev, "%s: timeout for receiving ack\n", __func__);
 103                 return ret;
 104         }
 105
 106         /* Ensure channel is released */
 107         writel(0xffffffff, base + MBOX_IMASK_REG);
 108         writel(BIT(mchan->ack_irq), base + MBOX_SRC_REG);
 109         return 0;
 110 }
 111
 112 static int hi3660_mbox_unlock(struct mbox_chan *chan)
 113 {
 114         struct hi3660_mbox *mbox = to_hi3660_mbox(chan->mbox);
 115         unsigned int val, retry = 3;
 116
 117         do {
 118                 writel(MBOX_IPC_UNLOCK, mbox->base + MBOX_IPC_LOCK_REG);
 119
 120                 val = readl(mbox->base + MBOX_IPC_LOCK_REG);
 121                 if (!val)
 122                         break;
 123
 124                 udelay(10);
 125         } while (retry--);
 126
 127         if (val)
 128                 dev_err(mbox->dev, "%s: failed to unlock mailbox\n", __func__);
 129
 130         return (!val) ? 0 : -ETIMEDOUT;
 131 }
 132
 133 static int hi3660_mbox_acquire_channel(struct mbox_chan *chan)
 134 {
 135         unsigned long ch = (unsigned long)chan->con_priv;
 136         struct hi3660_mbox *mbox = to_hi3660_mbox(chan->mbox);
 137         struct hi3660_chan_info *mchan = &mbox->mchan[ch];
 138         void __iomem *base = MBOX_BASE(mbox, ch);
 139         unsigned int val, retry;
 140
 141         for (retry = 10; retry; retry--) {
 142                 /* Check if channel is in idle state */
 143                 if (readl(base + MBOX_MODE_REG) & MBOX_STATE_IDLE) {
 144                         writel(BIT(mchan->ack_irq), base + MBOX_SRC_REG);
 145
 146                         /* Check ack bit has been set successfully */
 147                         val = readl(base + MBOX_SRC_REG);
 148                         if (val & BIT(mchan->ack_irq))
 149                                 break;
 150                 }
 151         }
 152
 153         if (!retry)
 154                 dev_err(mbox->dev, "%s: failed to acquire channel\n", __func__);
 155
 156         return retry ? 0 : -ETIMEDOUT;
 157 }
 158
 159 static int hi3660_mbox_startup(struct mbox_chan *chan)
 160 {
 161         int ret;
 162
 163         ret = hi3660_mbox_check_state(chan);
 164         if (ret)
 165                 return ret;
 166
 167         ret = hi3660_mbox_unlock(chan);
 168         if (ret)
 169                 return ret;
 170
 171         ret = hi3660_mbox_acquire_channel(chan);
 172         if (ret)
 173                 return ret;
 174
 175         return 0;
 176 }
 177
 178 static int hi3660_mbox_send_data(struct mbox_chan *chan, void *msg)
 179 {
 180         unsigned long ch = (unsigned long)chan->con_priv;
 181         struct hi3660_mbox *mbox = to_hi3660_mbox(chan->mbox);
 182         struct hi3660_chan_info *mchan = &mbox->mchan[ch];
 183         void __iomem *base = MBOX_BASE(mbox, ch);
 184         u32 *buf = msg;
 185         unsigned int i;
 186
 187         /* Ensure channel is released */
 188         writel_relaxed(0xffffffff, base + MBOX_IMASK_REG);
 189         writel_relaxed(BIT(mchan->ack_irq), base + MBOX_SRC_REG);
 190
 191         /* Clear mask for destination interrupt */
 192         writel_relaxed(~BIT(mchan->dst_irq), base + MBOX_IMASK_REG);
 193
 194         /* Config destination for interrupt vector */
 195         writel_relaxed(BIT(mchan->dst_irq), base + MBOX_DST_REG);
 196
 197         /* Automatic acknowledge mode */
 198         writel_relaxed(MBOX_AUTOMATIC_ACK, base + MBOX_MODE_REG);
 199
 200         /* Fill message data */
 201         for (i = 0; i < MBOX_MSG_LEN; i++)
 202                 writel_relaxed(buf[i], base + MBOX_DATA_REG + i * 4);
 203
 204         /* Trigger data transferring */
 205         writel(BIT(mchan->ack_irq), base + MBOX_SEND_REG);
 206         return 0;
 207 }
 208
 209 static struct mbox_chan_ops hi3660_mbox_ops = {
 210         .startup        = hi3660_mbox_startup,
 211         .send_data      = hi3660_mbox_send_data,
 212 };
 213
 214 static struct mbox_chan *hi3660_mbox_xlate(struct mbox_controller *controller,
 215                                            const struct of_phandle_args *spec)
 216 {
 217         struct hi3660_mbox *mbox = to_hi3660_mbox(controller);
 218         struct hi3660_chan_info *mchan;
 219         unsigned int ch = spec->args[0];
 220
 221         if (ch >= MBOX_CHAN_MAX) {
 222                 dev_err(mbox->dev, "Invalid channel idx %d\n", ch);
 223                 return ERR_PTR(-EINVAL);
 224         }
 225
 226         mchan = &mbox->mchan[ch];
 227         mchan->dst_irq = spec->args[1];
 228         mchan->ack_irq = spec->args[2];
 229
 230         return &mbox->chan[ch];
 231 }
 232
 233 static const struct of_device_id hi3660_mbox_of_match[] = {
 234         { .compatible = "hisilicon,hi3660-mbox", },
 235         {},
 236 };
 237
 238 MODULE_DEVICE_TABLE(of, hi3660_mbox_of_match);
 239
 240 static int hi3660_mbox_probe(struct platform_device *pdev)
 241 {
 242         struct device *dev = &pdev->dev;
 243         struct hi3660_mbox *mbox;
 244         struct mbox_chan *chan;
 245         struct resource *res;
 246         unsigned long ch;
 247         int err;
 248
 249         mbox = devm_kzalloc(dev, sizeof(*mbox), GFP_KERNEL);
 250         if (!mbox)
 251                 return -ENOMEM;
 252
 253         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 254         mbox->base = devm_ioremap_resource(dev, res);
 255         if (IS_ERR(mbox->base))
 256                 return PTR_ERR(mbox->base);
 257
 258         mbox->dev = dev;
 259         mbox->controller.dev = dev;
 260         mbox->controller.chans = mbox->chan;
 261         mbox->controller.num_chans = MBOX_CHAN_MAX;
 262         mbox->controller.ops = &hi3660_mbox_ops;
 263         mbox->controller.of_xlate = hi3660_mbox_xlate;
 264
 265         /* Initialize mailbox channel data */
 266         chan = mbox->chan;
 267         for (ch = 0; ch < MBOX_CHAN_MAX; ch++)
 268                 chan[ch].con_priv = (void *)ch;
 269
 270         err = mbox_controller_register(&mbox->controller);
 271         if (err) {
 272                 dev_err(dev, "Failed to register mailbox %d\n", err);
 273                 return err;
 274         }
 275
 276         platform_set_drvdata(pdev, mbox);
 277         dev_info(dev, "Mailbox enabled\n");
 278         return 0;
 279 }
 280
 281 static int hi3660_mbox_remove(struct platform_device *pdev)
 282 {
 283         struct hi3660_mbox *mbox = platform_get_drvdata(pdev);
 284
 285         mbox_controller_unregister(&mbox->controller);
 286         return 0;
 287 }
 288
 289 static struct platform_driver hi3660_mbox_driver = {
 290         .probe  = hi3660_mbox_probe,
 291         .remove = hi3660_mbox_remove,
 292         .driver = {
 293                 .name = "hi3660-mbox",
 294                 .of_match_table = hi3660_mbox_of_match,
 295         },
 296 };
 297
 298 static int __init hi3660_mbox_init(void)
 299 {
 300         return platform_driver_register(&hi3660_mbox_driver);
 301 }
 302 core_initcall(hi3660_mbox_init);
 303
 304 static void __exit hi3660_mbox_exit(void)
 305 {
 306         platform_driver_unregister(&hi3660_mbox_driver);
 307 }
 308 module_exit(hi3660_mbox_exit);
 309
 310 MODULE_LICENSE("GPL");
 311 MODULE_DESCRIPTION("Hisilicon Hi3660 Mailbox Controller");
 312 MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");