--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Alibaba Group Holding Limited.
+ */
+
+#include <linux/clk.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/mailbox_controller.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/slab.h>
+
+/* Status Register */
+#define LIGHT_MBOX_STA 0x0
+#define LIGHT_MBOX_CLR 0x4
+#define LIGHT_MBOX_MASK 0xc
+
+/* Transmit/receive data register:
+ * INFO0 ~ INFO6
+ */
+#define LIGHT_MBOX_INFO_NUM 8
+#define LIGHT_MBOX_DATA_INFO_NUM 7
+#define LIGHT_MBOX_INFO0 0x14
+/* Transmit ack register: INFO7 */
+#define LIGHT_MBOX_INFO7 0x30
+
+/* Generate remote icu IRQ Register */
+#define LIGHT_MBOX_GEN 0x10
+#define LIGHT_MBOX_GEN_RX_DATA BIT(6)
+#define LIGHT_MBOX_GEN_TX_ACK BIT(7)
+
+#define LIGHT_MBOX_CHAN_RES_SIZE 0x1000
+#define LIGHT_MBOX_CHANS 4
+#define LIGHT_MBOX_CHAN_NAME_SIZE 20
+
+#define LIGHT_MBOX_ACK_MAGIC 0xdeadbeaf
+
+#ifdef CONFIG_PM_SLEEP
+/* store MBOX context across system-wide suspend/resume transitions */
+struct light_mbox_context{
+ u32 intr_mask[LIGHT_MBOX_CHANS - 1];
+};
+
+#endif
+enum light_mbox_chan_type {
+ LIGHT_MBOX_TYPE_TXRX, /* Tx & Rx chan */
+ LIGHT_MBOX_TYPE_DB, /* Tx & Rx doorbell */
+};
+
+enum light_mbox_icu_cpu_id {
+ LIGHT_MBOX_ICU_CPU0, /* 910T */
+ LIGHT_MBOX_ICU_CPU1, /* 902 */
+ LIGHT_MBOX_ICU_CPU2, /* 906 */
+ LIGHT_MBOX_ICU_CPU3, /* 910R */
+};
+
+struct light_mbox_con_priv {
+ enum light_mbox_icu_cpu_id idx;
+ enum light_mbox_chan_type type;
+ void __iomem *comm_local_base;
+ void __iomem *comm_remote_base;
+ char irq_desc[LIGHT_MBOX_CHAN_NAME_SIZE];
+ struct mbox_chan *chan;
+ struct tasklet_struct txdb_tasklet;
+};
+
+struct light_mbox_priv {
+ struct device *dev;
+ void __iomem *local_icu[LIGHT_MBOX_CHANS];
+ void __iomem *remote_icu[LIGHT_MBOX_CHANS - 1];
+ void __iomem *cur_cpu_ch_base;
+ enum light_mbox_icu_cpu_id cur_icu_cpu_id;
+ spinlock_t mbox_lock; /* control register lock */
+
+ struct mbox_controller mbox;
+ struct mbox_chan mbox_chans[LIGHT_MBOX_CHANS];
+
+ struct light_mbox_con_priv con_priv[LIGHT_MBOX_CHANS];
+ struct clk *clk;
+ int irq;
+#ifdef CONFIG_PM_SLEEP
+ struct light_mbox_context *ctx;
+#endif
+};
+
+static struct light_mbox_priv *to_light_mbox_priv(struct mbox_controller *mbox)
+{
+ return container_of(mbox, struct light_mbox_priv, mbox);
+}
+
+static void light_mbox_write(struct light_mbox_priv *priv, u32 val, u32 offs)
+{
+ iowrite32(val, priv->cur_cpu_ch_base + offs);
+}
+
+static u32 light_mbox_read(struct light_mbox_priv *priv, u32 offs)
+{
+ return ioread32(priv->cur_cpu_ch_base + offs);
+}
+
+static u32 light_mbox_rmw(struct light_mbox_priv *priv, u32 off, u32 set, u32 clr)
+{
+ unsigned long flags;
+ u32 val;
+
+ spin_lock_irqsave(&priv->mbox_lock, flags);
+ val = light_mbox_read(priv, off);
+ val &= ~clr;
+ val |= set;
+ light_mbox_write(priv, val, off);
+ spin_unlock_irqrestore(&priv->mbox_lock, flags);
+
+ return val;
+}
+
+static void light_mbox_chan_write(struct light_mbox_con_priv *cp, u32 val, u32 offs, bool is_remote)
+{
+ if (is_remote)
+ iowrite32(val, cp->comm_remote_base + offs);
+ else
+ iowrite32(val, cp->comm_local_base + offs);
+}
+
+static u32 light_mbox_chan_read(struct light_mbox_con_priv *cp, u32 offs, bool is_remote)
+{
+ if (is_remote)
+ return ioread32(cp->comm_remote_base + offs);
+ else
+ return ioread32(cp->comm_local_base + offs);
+}
+
+static void light_mbox_chan_rmw(struct light_mbox_con_priv *cp, u32 off, u32 set, u32 clr, bool is_remote)
+{
+ struct light_mbox_priv *priv = to_light_mbox_priv(cp->chan->mbox);
+ unsigned long flags;
+ u32 val;
+
+ spin_lock_irqsave(&priv->mbox_lock, flags);
+ val = light_mbox_chan_read(cp, off, is_remote);
+ val &= ~clr;
+ val |= set;
+ light_mbox_chan_write(cp, val, off, is_remote);
+ spin_unlock_irqrestore(&priv->mbox_lock, flags);
+}
+
+static void light_mbox_chan_rd_data(struct light_mbox_con_priv *cp, void *data, bool is_remote)
+{
+ u32 off = LIGHT_MBOX_INFO0;
+ u32 *arg = data;
+ u32 i;
+
+ /* read info0 ~ info6, totally 28 bytes
+ * requires data memory size is 28 bytes
+ */
+ for (i = 0; i < LIGHT_MBOX_DATA_INFO_NUM; i++) {
+ *arg = light_mbox_chan_read(cp, off, is_remote);
+ off += 4;
+ arg++;
+ }
+}
+
+static void light_mbox_chan_wr_data(struct light_mbox_con_priv *cp, void *data, bool is_remote)
+{
+ u32 off = LIGHT_MBOX_INFO0;
+ u32 *arg = data;
+ u32 i;
+
+ /* write info0 ~ info6, totally 28 bytes
+ * requires data memory is 28 bytes valid data
+ */
+ for (i = 0; i < LIGHT_MBOX_DATA_INFO_NUM; i++) {
+ light_mbox_chan_write(cp, *arg, off, is_remote);
+ off += 4;
+ arg++;
+ }
+}
+
+static void light_mbox_chan_wr_ack(struct light_mbox_con_priv *cp, void *data, bool is_remote)
+{
+ u32 off = LIGHT_MBOX_INFO7;
+ u32 *arg = data;
+
+ light_mbox_chan_write(cp, *arg, off, is_remote);
+}
+
+static int light_mbox_chan_id_to_mapbit(struct light_mbox_con_priv *cp)
+{
+ struct light_mbox_priv *priv = to_light_mbox_priv(cp->chan->mbox);
+ int mapbit = 0;
+ int i;
+
+ for (i = 0; i < LIGHT_MBOX_CHANS; i++) {
+ if (i == cp->idx)
+ return mapbit;
+
+ if (i != priv->cur_icu_cpu_id)
+ mapbit++;
+ }
+
+ if (i == LIGHT_MBOX_CHANS)
+ dev_err(cp->chan->mbox->dev, "convert to mapbit failed\n");
+
+ return 0;
+}
+
+static void light_mbox_txdb_tasklet(unsigned long data)
+{
+ struct light_mbox_con_priv *cp = (struct light_mbox_con_priv *)data;
+
+ mbox_chan_txdone(cp->chan, 0);
+}
+
+static irqreturn_t light_mbox_isr(int irq, void *p)
+{
+ struct mbox_chan *chan = p;
+ struct light_mbox_priv *priv = to_light_mbox_priv(chan->mbox);
+ struct light_mbox_con_priv *cp = chan->con_priv;
+ int mapbit = light_mbox_chan_id_to_mapbit(cp);
+ u32 sta, dat[LIGHT_MBOX_DATA_INFO_NUM];
+ u32 ack_magic = LIGHT_MBOX_ACK_MAGIC;
+ u32 info0_data, info7_data;
+
+ sta = light_mbox_read(priv, LIGHT_MBOX_STA);
+ if (!(sta & BIT(mapbit)))
+ return IRQ_NONE;
+
+ /* clear chan irq bit in STA register */
+ light_mbox_rmw(priv, LIGHT_MBOX_CLR, BIT(mapbit), 0);
+
+ /* rx doorbell */
+ if (cp->type == LIGHT_MBOX_TYPE_DB) {
+ mbox_chan_received_data(cp->chan, NULL);
+ return IRQ_HANDLED;
+ }
+
+ /* info0 is the protocol word, shoud not be zero! */
+ info0_data = light_mbox_chan_read(cp, LIGHT_MBOX_INFO0, false);
+ if (info0_data) {
+ /* read info0~info6 data */
+ light_mbox_chan_rd_data(cp, dat, false);
+
+ /* clear local info0 */
+ light_mbox_chan_write(cp, 0x0, LIGHT_MBOX_INFO0, false);
+
+ /* notify remote cpu */
+ light_mbox_chan_wr_ack(cp, &ack_magic, true);
+ /* CPU1 902/906 use polling mode to monitor info7 */
+ if (cp->idx != LIGHT_MBOX_ICU_CPU1 && cp->idx != LIGHT_MBOX_ICU_CPU2)
+ light_mbox_chan_rmw(cp, LIGHT_MBOX_GEN, LIGHT_MBOX_GEN_TX_ACK, 0, true);
+
+ /* transfer the data to client */
+ mbox_chan_received_data(chan, (void *)dat);
+ }
+
+ /* info7 magic value mean the real ack signal, not generate bit7 */
+ info7_data = light_mbox_chan_read(cp, LIGHT_MBOX_INFO7, false);
+ if (info7_data == LIGHT_MBOX_ACK_MAGIC) {
+ /* clear local info7 */
+ light_mbox_chan_write(cp, 0x0, LIGHT_MBOX_INFO7, false);
+
+ /* notify framework the last TX has completed */
+ mbox_chan_txdone(chan, 0);
+ }
+
+ if (!info0_data && !info7_data)
+ return IRQ_NONE;
+
+ return IRQ_HANDLED;
+}
+
+static int light_mbox_send_data(struct mbox_chan *chan, void *data)
+{
+ struct light_mbox_con_priv *cp = chan->con_priv;
+
+ if (cp->type == LIGHT_MBOX_TYPE_DB)
+ tasklet_schedule(&cp->txdb_tasklet);
+ else
+ light_mbox_chan_wr_data(cp, data, true);
+ light_mbox_chan_rmw(cp, LIGHT_MBOX_GEN, LIGHT_MBOX_GEN_RX_DATA, 0, true);
+ return 0;
+}
+
+static int light_mbox_startup(struct mbox_chan *chan)
+{
+ struct light_mbox_priv *priv = to_light_mbox_priv(chan->mbox);
+ struct light_mbox_con_priv *cp = chan->con_priv;
+ u32 data[8] = {0};
+ int mask_bit;
+ int ret;
+
+ /* clear local and remote generate and info0~info7 */
+ light_mbox_chan_rmw(cp, LIGHT_MBOX_GEN, 0x0, 0xff, true);
+ light_mbox_chan_rmw(cp, LIGHT_MBOX_GEN, 0x0, 0xff, false);
+ light_mbox_chan_wr_ack(cp, &data[7], true);
+ light_mbox_chan_wr_ack(cp, &data[7], false);
+ light_mbox_chan_wr_data(cp, &data[0], true);
+ light_mbox_chan_wr_data(cp, &data[0], false);
+
+ /* enable the chan mask */
+ mask_bit = light_mbox_chan_id_to_mapbit(cp);
+ light_mbox_rmw(priv, LIGHT_MBOX_MASK, BIT(mask_bit), 0);
+
+ if (cp->type == LIGHT_MBOX_TYPE_DB)
+ /* tx doorbell doesn't have ACK, rx doorbell requires isr */
+ tasklet_init(&cp->txdb_tasklet, light_mbox_txdb_tasklet,
+ (unsigned long)cp);
+
+ ret = request_irq(priv->irq, light_mbox_isr, IRQF_SHARED |
+ IRQF_NO_SUSPEND, cp->irq_desc, chan);
+ if (ret) {
+ dev_err(priv->dev,
+ "Unable to acquire IRQ %d\n", priv->irq);
+ return ret;
+ }
+
+ return 0;
+}
+
+static void light_mbox_shutdown(struct mbox_chan *chan)
+{
+ struct light_mbox_priv *priv = to_light_mbox_priv(chan->mbox);
+ struct light_mbox_con_priv *cp = chan->con_priv;
+ int mask_bit;
+
+ /* clear the chan mask */
+ mask_bit = light_mbox_chan_id_to_mapbit(cp);
+ light_mbox_rmw(priv, LIGHT_MBOX_MASK, 0, BIT(mask_bit));
+
+ free_irq(priv->irq, chan);
+}
+
+static const struct mbox_chan_ops light_mbox_ops = {
+ .send_data = light_mbox_send_data,
+ .startup = light_mbox_startup,
+ .shutdown = light_mbox_shutdown,
+};
+
+static int light_mbox_init_generic(struct light_mbox_priv *priv)
+{
+#ifdef CONFIG_PM_SLEEP
+ priv->ctx = devm_kzalloc(priv->dev, sizeof(*priv->ctx), GFP_KERNEL);
+ if(!priv->ctx)
+ return -ENOMEM;
+#endif
+ /* Set default configuration */
+ light_mbox_write(priv, 0xff, LIGHT_MBOX_CLR);
+ light_mbox_write(priv, 0x0, LIGHT_MBOX_MASK);
+ return 0;
+}
+
+static struct mbox_chan *light_mbox_xlate(struct mbox_controller *mbox,
+ const struct of_phandle_args *sp)
+{
+ struct light_mbox_priv *priv = to_light_mbox_priv(mbox);
+ struct light_mbox_con_priv *cp;
+ u32 chan, type;
+
+ if (sp->args_count != 2) {
+ dev_err(mbox->dev, "Invalid argument count %d\n", sp->args_count);
+ return ERR_PTR(-EINVAL);
+ }
+
+ chan = sp->args[0]; /* comm remote channel */
+ type = sp->args[1]; /* comm channel type */
+
+ if (chan >= mbox->num_chans) {
+ dev_err(mbox->dev, "Not supported channel number: %d\n", chan);
+ return ERR_PTR(-EINVAL);
+ }
+
+ if (chan == priv->cur_icu_cpu_id) {
+ dev_err(mbox->dev, "Cannot communicate with yourself\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ if (type > LIGHT_MBOX_TYPE_DB) {
+ dev_err(mbox->dev, "Not supported the type for channel[%d]\n", chan);
+ return ERR_PTR(-EINVAL);
+ }
+
+ cp = mbox->chans[chan].con_priv;
+ cp->type = type;
+
+ return &mbox->chans[chan];
+}
+
+static int light_mbox_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct device_node *np = dev->of_node;
+ struct light_mbox_priv *priv;
+ struct resource *res;
+ unsigned int remote_idx = 0;
+ unsigned int i;
+ int ret;
+
+ priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ if (of_property_read_u32(np, "icu_cpu_id", &priv->cur_icu_cpu_id)) {
+ dev_err(dev, "icu_cpu_id is missing\n");
+ return -EINVAL;
+ }
+
+ if (priv->cur_icu_cpu_id != LIGHT_MBOX_ICU_CPU0 &&
+ priv->cur_icu_cpu_id != LIGHT_MBOX_ICU_CPU3) {
+ dev_err(dev, "icu_cpu_id is invalid\n");
+ return -EINVAL;
+ }
+
+ priv->dev = dev;
+
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "local_base");
+ priv->local_icu[LIGHT_MBOX_ICU_CPU0] = devm_ioremap_resource(dev, res);
+ if (IS_ERR(priv->local_icu[LIGHT_MBOX_ICU_CPU0]))
+ return PTR_ERR(priv->local_icu[LIGHT_MBOX_ICU_CPU0]);
+
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "remote_icu0");
+ priv->remote_icu[0] = devm_ioremap_resource(dev, res);
+ if (IS_ERR(priv->remote_icu[0]))
+ return PTR_ERR(priv->remote_icu[0]);
+
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "remote_icu1");
+ priv->remote_icu[1] = devm_ioremap_resource(dev, res);
+ if (IS_ERR(priv->remote_icu[1]))
+ return PTR_ERR(priv->remote_icu[1]);
+
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "remote_icu2");
+ priv->remote_icu[2] = devm_ioremap_resource(dev, res);
+ if (IS_ERR(priv->remote_icu[2]))
+ return PTR_ERR(priv->remote_icu[2]);
+
+ priv->local_icu[LIGHT_MBOX_ICU_CPU1] = priv->local_icu[LIGHT_MBOX_ICU_CPU0] +
+ LIGHT_MBOX_CHAN_RES_SIZE;
+ priv->local_icu[LIGHT_MBOX_ICU_CPU2] = priv->local_icu[LIGHT_MBOX_ICU_CPU1] +
+ LIGHT_MBOX_CHAN_RES_SIZE;
+ priv->local_icu[LIGHT_MBOX_ICU_CPU3] = priv->local_icu[LIGHT_MBOX_ICU_CPU2] +
+ LIGHT_MBOX_CHAN_RES_SIZE;
+
+ priv->cur_cpu_ch_base = priv->local_icu[priv->cur_icu_cpu_id];
+
+ priv->irq = platform_get_irq(pdev, 0);
+ if (priv->irq < 0)
+ return priv->irq;
+
+ priv->clk = devm_clk_get(dev, NULL);
+ if (IS_ERR(priv->clk)) {
+ if (PTR_ERR(priv->clk) != -ENOENT)
+ return PTR_ERR(priv->clk);
+
+ priv->clk = NULL;
+ }
+
+ ret = clk_prepare_enable(priv->clk);
+ if (ret) {
+ dev_err(dev, "Failed to enable clock\n");
+ return ret;
+ }
+
+ /* init the chans */
+ for (i = 0; i < LIGHT_MBOX_CHANS; i++) {
+ struct light_mbox_con_priv *cp = &priv->con_priv[i];
+
+ cp->idx = i;
+ cp->chan = &priv->mbox_chans[i];
+ priv->mbox_chans[i].con_priv = cp;
+ snprintf(cp->irq_desc, sizeof(cp->irq_desc),
+ "light_mbox_chan[%i]", cp->idx);
+
+ cp->comm_local_base = priv->local_icu[i];
+ if (i != priv->cur_icu_cpu_id) {
+ cp->comm_remote_base = priv->remote_icu[remote_idx];
+ remote_idx++;
+ }
+ }
+
+ spin_lock_init(&priv->mbox_lock);
+
+ priv->mbox.dev = dev;
+ priv->mbox.ops = &light_mbox_ops;
+ priv->mbox.chans = priv->mbox_chans;
+ priv->mbox.num_chans = LIGHT_MBOX_CHANS;
+ priv->mbox.of_xlate = light_mbox_xlate;
+ priv->mbox.txdone_irq = true;
+
+ platform_set_drvdata(pdev, priv);
+
+ ret = light_mbox_init_generic(priv);
+ if (ret) {
+ dev_err(dev, "Failed to init mailbox context\n");
+ return ret;
+ }
+
+ return devm_mbox_controller_register(dev, &priv->mbox);
+}
+
+static int light_mbox_remove(struct platform_device *pdev)
+{
+ struct light_mbox_priv *priv = platform_get_drvdata(pdev);
+
+ clk_disable_unprepare(priv->clk);
+
+ return 0;
+}
+
+static const struct of_device_id light_mbox_dt_ids[] = {
+ { .compatible = "thead,light-mbox" },
+ { },
+};
+MODULE_DEVICE_TABLE(of, light_mbox_dt_ids);
+
+#ifdef CONFIG_PM_SLEEP
+static int __maybe_unused light_mbox_suspend_noirq(struct device *dev)
+{
+ struct light_mbox_priv *priv = dev_get_drvdata(dev);
+ struct light_mbox_context *ctx = priv->ctx;
+ u32 i;
+ /*
+ * ONLY interrupt mask bit should be stored and restores.
+ * INFO data all assumed to be lost.
+ */
+ for(i = 0 ; i < LIGHT_MBOX_CHANS; i++) {
+ ctx->intr_mask[i] = ioread32(priv->local_icu[i] + LIGHT_MBOX_MASK);
+ }
+ return 0;
+}
+
+static int __maybe_unused light_mbox_resume_noirq(struct device *dev)
+{
+ struct light_mbox_priv *priv = dev_get_drvdata(dev);
+ struct light_mbox_context *ctx = priv->ctx;
+ u32 i;
+
+ for(i = 0 ; i < LIGHT_MBOX_CHANS; i++) {
+ iowrite32(ctx->intr_mask[i], priv->local_icu[i] + LIGHT_MBOX_MASK);
+ }
+ return 0;
+}
+
+#endif
+
+
+static int __maybe_unused light_mbox_runtime_suspend(struct device *dev)
+{
+ struct light_mbox_priv *priv = dev_get_drvdata(dev);
+
+ clk_disable_unprepare(priv->clk);
+
+ return 0;
+}
+
+static int __maybe_unused light_mbox_runtime_resume(struct device *dev)
+{
+ struct light_mbox_priv *priv = dev_get_drvdata(dev);
+ int ret;
+
+ ret = clk_prepare_enable(priv->clk);
+ if (ret)
+ dev_err(dev, "failed to enable clock\n");
+
+ return ret;
+}
+
+static const struct dev_pm_ops light_mbox_pm_ops = {
+#ifdef CONFIG_PM_SLEEP
+ SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(light_mbox_suspend_noirq,
+ light_mbox_resume_noirq)
+#endif
+ SET_RUNTIME_PM_OPS(light_mbox_runtime_suspend,
+ light_mbox_runtime_resume, NULL)
+};
+
+
+static struct platform_driver light_mbox_driver = {
+ .probe = light_mbox_probe,
+ .remove = light_mbox_remove,
+ .driver = {
+ .name = "light_mbox",
+ .of_match_table = light_mbox_dt_ids,
+ .pm = &light_mbox_pm_ops,
+ },
+};
+module_platform_driver(light_mbox_driver);
+
+MODULE_AUTHOR("fugang.duan <duanfugang.dfg@linux.alibaba.com>");
+MODULE_DESCRIPTION("Thead Light mailbox IPC driver");
+MODULE_LICENSE("GPL v2");
projects / platform / kernel / linux-thead.git / commitdiff