drivers/mailbox/sprd-mailbox.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Spreadtrum mailbox driver
   4  *
   5  * Copyright (c) 2020 Spreadtrum Communications Inc.
   6  */
   7
   8 #include <linux/delay.h>
   9 #include <linux/err.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/io.h>
  12 #include <linux/mailbox_controller.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/clk.h>
  17
  18 #define SPRD_MBOX_ID            0x0
  19 #define SPRD_MBOX_MSG_LOW       0x4
  20 #define SPRD_MBOX_MSG_HIGH      0x8
  21 #define SPRD_MBOX_TRIGGER       0xc
  22 #define SPRD_MBOX_FIFO_RST      0x10
  23 #define SPRD_MBOX_FIFO_STS      0x14
  24 #define SPRD_MBOX_IRQ_STS       0x18
  25 #define SPRD_MBOX_IRQ_MSK       0x1c
  26 #define SPRD_MBOX_LOCK          0x20
  27 #define SPRD_MBOX_FIFO_DEPTH    0x24
  28
  29 /* Bit and mask definition for inbox's SPRD_MBOX_FIFO_STS register */
  30 #define SPRD_INBOX_FIFO_DELIVER_MASK            GENMASK(23, 16)
  31 #define SPRD_INBOX_FIFO_OVERLOW_MASK            GENMASK(15, 8)
  32 #define SPRD_INBOX_FIFO_DELIVER_SHIFT           16
  33 #define SPRD_INBOX_FIFO_BUSY_MASK               GENMASK(7, 0)
  34
  35 /* Bit and mask definition for SPRD_MBOX_IRQ_STS register */
  36 #define SPRD_MBOX_IRQ_CLR                       BIT(0)
  37
  38 /* Bit and mask definition for outbox's SPRD_MBOX_FIFO_STS register */
  39 #define SPRD_OUTBOX_FIFO_FULL                   BIT(2)
  40 #define SPRD_OUTBOX_FIFO_WR_SHIFT               16
  41 #define SPRD_OUTBOX_FIFO_RD_SHIFT               24
  42 #define SPRD_OUTBOX_FIFO_POS_MASK               GENMASK(7, 0)
  43
  44 /* Bit and mask definition for inbox's SPRD_MBOX_IRQ_MSK register */
  45 #define SPRD_INBOX_FIFO_BLOCK_IRQ               BIT(0)
  46 #define SPRD_INBOX_FIFO_OVERFLOW_IRQ            BIT(1)
  47 #define SPRD_INBOX_FIFO_DELIVER_IRQ             BIT(2)
  48 #define SPRD_INBOX_FIFO_IRQ_MASK                GENMASK(2, 0)
  49
  50 /* Bit and mask definition for outbox's SPRD_MBOX_IRQ_MSK register */
  51 #define SPRD_OUTBOX_FIFO_NOT_EMPTY_IRQ          BIT(0)
  52 #define SPRD_OUTBOX_FIFO_IRQ_MASK               GENMASK(4, 0)
  53
  54 #define SPRD_OUTBOX_BASE_SPAN                   0x1000
  55 #define SPRD_MBOX_CHAN_MAX                      8
  56 #define SPRD_SUPP_INBOX_ID_SC9863A              7
  57
  58 struct sprd_mbox_priv {
  59         struct mbox_controller  mbox;
  60         struct device           *dev;
  61         void __iomem            *inbox_base;
  62         void __iomem            *outbox_base;
  63         /*  Base register address for supplementary outbox */
  64         void __iomem            *supp_base;
  65         struct clk              *clk;
  66         u32                     outbox_fifo_depth;
  67
  68         struct mutex            lock;
  69         u32                     refcnt;
  70         struct mbox_chan        chan[SPRD_MBOX_CHAN_MAX];
  71 };
  72
  73 static struct sprd_mbox_priv *to_sprd_mbox_priv(struct mbox_controller *mbox)
  74 {
  75         return container_of(mbox, struct sprd_mbox_priv, mbox);
  76 }
  77
  78 static u32 sprd_mbox_get_fifo_len(struct sprd_mbox_priv *priv, u32 fifo_sts)
  79 {
  80         u32 wr_pos = (fifo_sts >> SPRD_OUTBOX_FIFO_WR_SHIFT) &
  81                 SPRD_OUTBOX_FIFO_POS_MASK;
  82         u32 rd_pos = (fifo_sts >> SPRD_OUTBOX_FIFO_RD_SHIFT) &
  83                 SPRD_OUTBOX_FIFO_POS_MASK;
  84         u32 fifo_len;
  85
  86         /*
  87          * If the read pointer is equal with write pointer, which means the fifo
  88          * is full or empty.
  89          */
  90         if (wr_pos == rd_pos) {
  91                 if (fifo_sts & SPRD_OUTBOX_FIFO_FULL)
  92                         fifo_len = priv->outbox_fifo_depth;
  93                 else
  94                         fifo_len = 0;
  95         } else if (wr_pos > rd_pos) {
  96                 fifo_len = wr_pos - rd_pos;
  97         } else {
  98                 fifo_len = priv->outbox_fifo_depth - rd_pos + wr_pos;
  99         }
 100
 101         return fifo_len;
 102 }
 103
 104 static irqreturn_t do_outbox_isr(void __iomem *base, struct sprd_mbox_priv *priv)
 105 {
 106         struct mbox_chan *chan;
 107         u32 fifo_sts, fifo_len, msg[2];
 108         int i, id;
 109
 110         fifo_sts = readl(base + SPRD_MBOX_FIFO_STS);
 111
 112         fifo_len = sprd_mbox_get_fifo_len(priv, fifo_sts);
 113         if (!fifo_len) {
 114                 dev_warn_ratelimited(priv->dev, "spurious outbox interrupt\n");
 115                 return IRQ_NONE;
 116         }
 117
 118         for (i = 0; i < fifo_len; i++) {
 119                 msg[0] = readl(base + SPRD_MBOX_MSG_LOW);
 120                 msg[1] = readl(base + SPRD_MBOX_MSG_HIGH);
 121                 id = readl(base + SPRD_MBOX_ID);
 122
 123                 chan = &priv->chan[id];
 124                 if (chan->cl)
 125                         mbox_chan_received_data(chan, (void *)msg);
 126                 else
 127                         dev_warn_ratelimited(priv->dev,
 128                                     "message's been dropped at ch[%d]\n", id);
 129
 130                 /* Trigger to update outbox FIFO pointer */
 131                 writel(0x1, base + SPRD_MBOX_TRIGGER);
 132         }
 133
 134         /* Clear irq status after reading all message. */
 135         writel(SPRD_MBOX_IRQ_CLR, base + SPRD_MBOX_IRQ_STS);
 136
 137         return IRQ_HANDLED;
 138 }
 139
 140 static irqreturn_t sprd_mbox_outbox_isr(int irq, void *data)
 141 {
 142         struct sprd_mbox_priv *priv = data;
 143
 144         return do_outbox_isr(priv->outbox_base, priv);
 145 }
 146
 147 static irqreturn_t sprd_mbox_supp_isr(int irq, void *data)
 148 {
 149         struct sprd_mbox_priv *priv = data;
 150
 151         return do_outbox_isr(priv->supp_base, priv);
 152 }
 153
 154 static irqreturn_t sprd_mbox_inbox_isr(int irq, void *data)
 155 {
 156         struct sprd_mbox_priv *priv = data;
 157         struct mbox_chan *chan;
 158         u32 fifo_sts, send_sts, busy, id;
 159
 160         fifo_sts = readl(priv->inbox_base + SPRD_MBOX_FIFO_STS);
 161
 162         /* Get the inbox data delivery status */
 163         send_sts = (fifo_sts & SPRD_INBOX_FIFO_DELIVER_MASK) >>
 164                 SPRD_INBOX_FIFO_DELIVER_SHIFT;
 165         if (!send_sts) {
 166                 dev_warn_ratelimited(priv->dev, "spurious inbox interrupt\n");
 167                 return IRQ_NONE;
 168         }
 169
 170         while (send_sts) {
 171                 id = __ffs(send_sts);
 172                 send_sts &= (send_sts - 1);
 173
 174                 chan = &priv->chan[id];
 175
 176                 /*
 177                  * Check if the message was fetched by remote target, if yes,
 178                  * that means the transmission has been completed.
 179                  */
 180                 busy = fifo_sts & SPRD_INBOX_FIFO_BUSY_MASK;
 181                 if (!(busy & BIT(id)))
 182                         mbox_chan_txdone(chan, 0);
 183         }
 184
 185         /* Clear FIFO delivery and overflow status */
 186         writel(fifo_sts &
 187                (SPRD_INBOX_FIFO_DELIVER_MASK | SPRD_INBOX_FIFO_OVERLOW_MASK),
 188                priv->inbox_base + SPRD_MBOX_FIFO_RST);
 189
 190         /* Clear irq status */
 191         writel(SPRD_MBOX_IRQ_CLR, priv->inbox_base + SPRD_MBOX_IRQ_STS);
 192
 193         return IRQ_HANDLED;
 194 }
 195
 196 static int sprd_mbox_send_data(struct mbox_chan *chan, void *msg)
 197 {
 198         struct sprd_mbox_priv *priv = to_sprd_mbox_priv(chan->mbox);
 199         unsigned long id = (unsigned long)chan->con_priv;
 200         u32 *data = msg;
 201
 202         /* Write data into inbox FIFO, and only support 8 bytes every time */
 203         writel(data[0], priv->inbox_base + SPRD_MBOX_MSG_LOW);
 204         writel(data[1], priv->inbox_base + SPRD_MBOX_MSG_HIGH);
 205
 206         /* Set target core id */
 207         writel(id, priv->inbox_base + SPRD_MBOX_ID);
 208
 209         /* Trigger remote request */
 210         writel(0x1, priv->inbox_base + SPRD_MBOX_TRIGGER);
 211
 212         return 0;
 213 }
 214
 215 static int sprd_mbox_flush(struct mbox_chan *chan, unsigned long timeout)
 216 {
 217         struct sprd_mbox_priv *priv = to_sprd_mbox_priv(chan->mbox);
 218         unsigned long id = (unsigned long)chan->con_priv;
 219         u32 busy;
 220
 221         timeout = jiffies + msecs_to_jiffies(timeout);
 222
 223         while (time_before(jiffies, timeout)) {
 224                 busy = readl(priv->inbox_base + SPRD_MBOX_FIFO_STS) &
 225                         SPRD_INBOX_FIFO_BUSY_MASK;
 226                 if (!(busy & BIT(id))) {
 227                         mbox_chan_txdone(chan, 0);
 228                         return 0;
 229                 }
 230
 231                 udelay(1);
 232         }
 233
 234         return -ETIME;
 235 }
 236
 237 static int sprd_mbox_startup(struct mbox_chan *chan)
 238 {
 239         struct sprd_mbox_priv *priv = to_sprd_mbox_priv(chan->mbox);
 240         u32 val;
 241
 242         mutex_lock(&priv->lock);
 243         if (priv->refcnt++ == 0) {
 244                 /* Select outbox FIFO mode and reset the outbox FIFO status */
 245                 writel(0x0, priv->outbox_base + SPRD_MBOX_FIFO_RST);
 246
 247                 /* Enable inbox FIFO overflow and delivery interrupt */
 248                 val = readl(priv->inbox_base + SPRD_MBOX_IRQ_MSK);
 249                 val &= ~(SPRD_INBOX_FIFO_OVERFLOW_IRQ | SPRD_INBOX_FIFO_DELIVER_IRQ);
 250                 writel(val, priv->inbox_base + SPRD_MBOX_IRQ_MSK);
 251
 252                 /* Enable outbox FIFO not empty interrupt */
 253                 val = readl(priv->outbox_base + SPRD_MBOX_IRQ_MSK);
 254                 val &= ~SPRD_OUTBOX_FIFO_NOT_EMPTY_IRQ;
 255                 writel(val, priv->outbox_base + SPRD_MBOX_IRQ_MSK);
 256
 257                 /* Enable supplementary outbox as the fundamental one */
 258                 if (priv->supp_base) {
 259                         writel(0x0, priv->supp_base + SPRD_MBOX_FIFO_RST);
 260                         val = readl(priv->supp_base + SPRD_MBOX_IRQ_MSK);
 261                         val &= ~SPRD_OUTBOX_FIFO_NOT_EMPTY_IRQ;
 262                         writel(val, priv->supp_base + SPRD_MBOX_IRQ_MSK);
 263                 }
 264         }
 265         mutex_unlock(&priv->lock);
 266
 267         return 0;
 268 }
 269
 270 static void sprd_mbox_shutdown(struct mbox_chan *chan)
 271 {
 272         struct sprd_mbox_priv *priv = to_sprd_mbox_priv(chan->mbox);
 273
 274         mutex_lock(&priv->lock);
 275         if (--priv->refcnt == 0) {
 276                 /* Disable inbox & outbox interrupt */
 277                 writel(SPRD_INBOX_FIFO_IRQ_MASK, priv->inbox_base + SPRD_MBOX_IRQ_MSK);
 278                 writel(SPRD_OUTBOX_FIFO_IRQ_MASK, priv->outbox_base + SPRD_MBOX_IRQ_MSK);
 279
 280                 if (priv->supp_base)
 281                         writel(SPRD_OUTBOX_FIFO_IRQ_MASK,
 282                                priv->supp_base + SPRD_MBOX_IRQ_MSK);
 283         }
 284         mutex_unlock(&priv->lock);
 285 }
 286
 287 static const struct mbox_chan_ops sprd_mbox_ops = {
 288         .send_data      = sprd_mbox_send_data,
 289         .flush          = sprd_mbox_flush,
 290         .startup        = sprd_mbox_startup,
 291         .shutdown       = sprd_mbox_shutdown,
 292 };
 293
 294 static void sprd_mbox_disable(void *data)
 295 {
 296         struct sprd_mbox_priv *priv = data;
 297
 298         clk_disable_unprepare(priv->clk);
 299 }
 300
 301 static int sprd_mbox_probe(struct platform_device *pdev)
 302 {
 303         struct device *dev = &pdev->dev;
 304         struct sprd_mbox_priv *priv;
 305         int ret, inbox_irq, outbox_irq, supp_irq;
 306         unsigned long id, supp;
 307
 308         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 309         if (!priv)
 310                 return -ENOMEM;
 311
 312         priv->dev = dev;
 313         mutex_init(&priv->lock);
 314
 315         /*
 316          * Unisoc mailbox uses an inbox to send messages to the target
 317          * core, and uses (an) outbox(es) to receive messages from other
 318          * cores.
 319          *
 320          * Thus in general the mailbox controller supplies 2 different
 321          * register addresses and IRQ numbers for inbox and outbox.
 322          *
 323          * If necessary, a supplementary inbox could be enabled optionally
 324          * with an independent FIFO and an extra interrupt.
 325          */
 326         priv->inbox_base = devm_platform_ioremap_resource(pdev, 0);
 327         if (IS_ERR(priv->inbox_base))
 328                 return PTR_ERR(priv->inbox_base);
 329
 330         priv->outbox_base = devm_platform_ioremap_resource(pdev, 1);
 331         if (IS_ERR(priv->outbox_base))
 332                 return PTR_ERR(priv->outbox_base);
 333
 334         priv->clk = devm_clk_get(dev, "enable");
 335         if (IS_ERR(priv->clk)) {
 336                 dev_err(dev, "failed to get mailbox clock\n");
 337                 return PTR_ERR(priv->clk);
 338         }
 339
 340         ret = clk_prepare_enable(priv->clk);
 341         if (ret)
 342                 return ret;
 343
 344         ret = devm_add_action_or_reset(dev, sprd_mbox_disable, priv);
 345         if (ret) {
 346                 dev_err(dev, "failed to add mailbox disable action\n");
 347                 return ret;
 348         }
 349
 350         inbox_irq = platform_get_irq_byname(pdev, "inbox");
 351         if (inbox_irq < 0)
 352                 return inbox_irq;
 353
 354         ret = devm_request_irq(dev, inbox_irq, sprd_mbox_inbox_isr,
 355                                IRQF_NO_SUSPEND, dev_name(dev), priv);
 356         if (ret) {
 357                 dev_err(dev, "failed to request inbox IRQ: %d\n", ret);
 358                 return ret;
 359         }
 360
 361         outbox_irq = platform_get_irq_byname(pdev, "outbox");
 362         if (outbox_irq < 0)
 363                 return outbox_irq;
 364
 365         ret = devm_request_irq(dev, outbox_irq, sprd_mbox_outbox_isr,
 366                                IRQF_NO_SUSPEND, dev_name(dev), priv);
 367         if (ret) {
 368                 dev_err(dev, "failed to request outbox IRQ: %d\n", ret);
 369                 return ret;
 370         }
 371
 372         /* Supplementary outbox IRQ is optional */
 373         supp_irq = platform_get_irq_byname(pdev, "supp-outbox");
 374         if (supp_irq > 0) {
 375                 ret = devm_request_irq(dev, supp_irq, sprd_mbox_supp_isr,
 376                                        IRQF_NO_SUSPEND, dev_name(dev), priv);
 377                 if (ret) {
 378                         dev_err(dev, "failed to request outbox IRQ: %d\n", ret);
 379                         return ret;
 380                 }
 381
 382                 supp = (unsigned long) of_device_get_match_data(dev);
 383                 if (!supp) {
 384                         dev_err(dev, "no supplementary outbox specified\n");
 385                         return -ENODEV;
 386                 }
 387                 priv->supp_base = priv->outbox_base + (SPRD_OUTBOX_BASE_SPAN * supp);
 388         }
 389
 390         /* Get the default outbox FIFO depth */
 391         priv->outbox_fifo_depth =
 392                 readl(priv->outbox_base + SPRD_MBOX_FIFO_DEPTH) + 1;
 393         priv->mbox.dev = dev;
 394         priv->mbox.chans = &priv->chan[0];
 395         priv->mbox.num_chans = SPRD_MBOX_CHAN_MAX;
 396         priv->mbox.ops = &sprd_mbox_ops;
 397         priv->mbox.txdone_irq = true;
 398
 399         for (id = 0; id < SPRD_MBOX_CHAN_MAX; id++)
 400                 priv->chan[id].con_priv = (void *)id;
 401
 402         ret = devm_mbox_controller_register(dev, &priv->mbox);
 403         if (ret) {
 404                 dev_err(dev, "failed to register mailbox: %d\n", ret);
 405                 return ret;
 406         }
 407
 408         return 0;
 409 }
 410
 411 static const struct of_device_id sprd_mbox_of_match[] = {
 412         { .compatible = "sprd,sc9860-mailbox" },
 413         { .compatible = "sprd,sc9863a-mailbox",
 414           .data = (void *)SPRD_SUPP_INBOX_ID_SC9863A },
 415         { },
 416 };
 417 MODULE_DEVICE_TABLE(of, sprd_mbox_of_match);
 418
 419 static struct platform_driver sprd_mbox_driver = {
 420         .driver = {
 421                 .name = "sprd-mailbox",
 422                 .of_match_table = sprd_mbox_of_match,
 423         },
 424         .probe  = sprd_mbox_probe,
 425 };
 426 module_platform_driver(sprd_mbox_driver);
 427
 428 MODULE_AUTHOR("Baolin Wang <baolin.wang@unisoc.com>");
 429 MODULE_DESCRIPTION("Spreadtrum mailbox driver");
 430 MODULE_LICENSE("GPL v2");