// SPDX-License-Identifier: GPL-2.0 /* * Broadcom BCM74110 Mailbox Driver * * Copyright (c) 2025 Broadcom */ #include #include #include #include #include #include #include #include #include #include #include #include #define BCM_MBOX_BASE(sel) ((sel) * 0x40) #define BCM_MBOX_IRQ_BASE(sel) (((sel) * 0x20) + 0x800) #define BCM_MBOX_CFGA 0x0 #define BCM_MBOX_CFGB 0x4 #define BCM_MBOX_CFGC 0x8 #define BCM_MBOX_CFGD 0xc #define BCM_MBOX_CTRL 0x10 #define BCM_MBOX_CTRL_EN BIT(0) #define BCM_MBOX_CTRL_CLR BIT(1) #define BCM_MBOX_STATUS0 0x14 #define BCM_MBOX_STATUS0_NOT_EMPTY BIT(28) #define BCM_MBOX_STATUS0_FULL BIT(29) #define BCM_MBOX_STATUS1 0x18 #define BCM_MBOX_STATUS2 0x1c #define BCM_MBOX_WDATA 0x20 #define BCM_MBOX_RDATA 0x28 #define BCM_MBOX_IRQ_STATUS 0x0 #define BCM_MBOX_IRQ_SET 0x4 #define BCM_MBOX_IRQ_CLEAR 0x8 #define BCM_MBOX_IRQ_MASK_STATUS 0xc #define BCM_MBOX_IRQ_MASK_SET 0x10 #define BCM_MBOX_IRQ_MASK_CLEAR 0x14 #define BCM_MBOX_IRQ_TIMEOUT BIT(0) #define BCM_MBOX_IRQ_NOT_EMPTY BIT(1) #define BCM_MBOX_IRQ_FULL BIT(2) #define BCM_MBOX_IRQ_LOW_WM BIT(3) #define BCM_MBOX_IRQ_HIGH_WM BIT(4) #define BCM_LINK_CODE0 0xbe0 #define BCM_LINK_CODE1 0xbe1 #define BCM_LINK_CODE2 0xbe2 enum { BCM_MSG_FUNC_LINK_START = 0, BCM_MSG_FUNC_LINK_STOP, BCM_MSG_FUNC_SHMEM_TX, BCM_MSG_FUNC_SHMEM_RX, BCM_MSG_FUNC_SHMEM_STOP, BCM_MSG_FUNC_MAX, }; enum { BCM_MSG_SVC_INIT = 0, BCM_MSG_SVC_PMC, BCM_MSG_SVC_SCMI, BCM_MSG_SVC_DPFE, BCM_MSG_SVC_MAX, }; struct bcm74110_mbox_msg { struct list_head list_entry; #define BCM_MSG_VERSION_MASK GENMASK(31, 29) #define BCM_MSG_VERSION 0x1 #define BCM_MSG_REQ_MASK BIT(28) #define BCM_MSG_RPLY_MASK BIT(27) #define BCM_MSG_SVC_MASK GENMASK(26, 24) #define BCM_MSG_FUNC_MASK GENMASK(23, 16) #define BCM_MSG_LENGTH_MASK GENMASK(15, 4) #define BCM_MSG_SLOT_MASK GENMASK(3, 0) #define BCM_MSG_SET_FIELD(hdr, field, val) \ do { \ hdr &= ~BCM_MSG_##field##_MASK; \ hdr |= FIELD_PREP(BCM_MSG_##field##_MASK, val); \ } while (0) #define BCM_MSG_GET_FIELD(hdr, field) \ FIELD_GET(BCM_MSG_##field##_MASK, hdr) u32 msg; }; struct bcm74110_mbox_chan { struct bcm74110_mbox *mbox; bool en; int slot; int type; }; struct bcm74110_mbox { struct platform_device *pdev; void __iomem *base; int tx_chan; int rx_chan; int rx_irq; struct list_head rx_svc_init_list; spinlock_t rx_svc_list_lock; struct mbox_controller controller; struct bcm74110_mbox_chan *mbox_chan; }; #define BCM74110_OFFSET_IO_WRITEL_MACRO(name, offset_base) \ static void bcm74110_##name##_writel(struct bcm74110_mbox *mbox,\ u32 val, u32 off) \ { \ writel_relaxed(val, mbox->base + offset_base + off); \ } BCM74110_OFFSET_IO_WRITEL_MACRO(tx, BCM_MBOX_BASE(mbox->tx_chan)); BCM74110_OFFSET_IO_WRITEL_MACRO(irq, BCM_MBOX_IRQ_BASE(mbox->rx_chan)); #define BCM74110_OFFSET_IO_READL_MACRO(name, offset_base) \ static u32 bcm74110_##name##_readl(struct bcm74110_mbox *mbox, \ u32 off) \ { \ return readl_relaxed(mbox->base + offset_base + off); \ } BCM74110_OFFSET_IO_READL_MACRO(tx, BCM_MBOX_BASE(mbox->tx_chan)); BCM74110_OFFSET_IO_READL_MACRO(rx, BCM_MBOX_BASE(mbox->rx_chan)); BCM74110_OFFSET_IO_READL_MACRO(irq, BCM_MBOX_IRQ_BASE(mbox->rx_chan)); static inline struct bcm74110_mbox *bcm74110_mbox_from_cntrl( struct mbox_controller *cntrl) { return container_of(cntrl, struct bcm74110_mbox, controller); } static void bcm74110_rx_push_init_msg(struct bcm74110_mbox *mbox, u32 val) { struct bcm74110_mbox_msg *msg; msg = kzalloc(sizeof(*msg), GFP_ATOMIC); if (!msg) return; INIT_LIST_HEAD(&msg->list_entry); msg->msg = val; spin_lock(&mbox->rx_svc_list_lock); list_add_tail(&msg->list_entry, &mbox->rx_svc_init_list); spin_unlock(&mbox->rx_svc_list_lock); } static void bcm74110_rx_process_msg(struct bcm74110_mbox *mbox) { struct device *dev = &mbox->pdev->dev; struct bcm74110_mbox_chan *chan_priv; struct mbox_chan *chan; u32 msg, status; int type; do { msg = bcm74110_rx_readl(mbox, BCM_MBOX_RDATA); status = bcm74110_rx_readl(mbox, BCM_MBOX_STATUS0); dev_dbg(dev, "rx: [{req=%lu|rply=%lu|srv=%lu|fn=%lu|length=%lu|slot=%lu]\n", BCM_MSG_GET_FIELD(msg, REQ), BCM_MSG_GET_FIELD(msg, RPLY), BCM_MSG_GET_FIELD(msg, SVC), BCM_MSG_GET_FIELD(msg, FUNC), BCM_MSG_GET_FIELD(msg, LENGTH), BCM_MSG_GET_FIELD(msg, SLOT)); type = BCM_MSG_GET_FIELD(msg, SVC); switch (type) { case BCM_MSG_SVC_INIT: bcm74110_rx_push_init_msg(mbox, msg); break; case BCM_MSG_SVC_PMC: case BCM_MSG_SVC_SCMI: case BCM_MSG_SVC_DPFE: chan = &mbox->controller.chans[type]; chan_priv = chan->con_priv; if (chan_priv->en) mbox_chan_received_data(chan, NULL); else dev_warn(dev, "Channel not enabled\n"); break; default: dev_warn(dev, "Unsupported msg received\n"); } } while (status & BCM_MBOX_STATUS0_NOT_EMPTY); } static irqreturn_t bcm74110_mbox_isr(int irq, void *data) { struct bcm74110_mbox *mbox = data; u32 status; status = bcm74110_irq_readl(mbox, BCM_MBOX_IRQ_STATUS); bcm74110_irq_writel(mbox, 0xffffffff, BCM_MBOX_IRQ_CLEAR); if (status & BCM_MBOX_IRQ_NOT_EMPTY) bcm74110_rx_process_msg(mbox); else dev_warn(&mbox->pdev->dev, "Spurious interrupt\n"); return IRQ_HANDLED; } static void bcm74110_mbox_mask_and_clear(struct bcm74110_mbox *mbox) { bcm74110_irq_writel(mbox, 0xffffffff, BCM_MBOX_IRQ_MASK_SET); bcm74110_irq_writel(mbox, 0xffffffff, BCM_MBOX_IRQ_CLEAR); } static int bcm74110_rx_pop_init_msg(struct bcm74110_mbox *mbox, u32 func_type, u32 *val) { struct bcm74110_mbox_msg *msg, *msg_tmp; unsigned long flags; bool found = false; spin_lock_irqsave(&mbox->rx_svc_list_lock, flags); list_for_each_entry_safe(msg, msg_tmp, &mbox->rx_svc_init_list, list_entry) { if (BCM_MSG_GET_FIELD(msg->msg, FUNC) == func_type) { list_del(&msg->list_entry); found = true; break; } } spin_unlock_irqrestore(&mbox->rx_svc_list_lock, flags); if (!found) return -EINVAL; *val = msg->msg; kfree(msg); return 0; } static void bcm74110_rx_flush_msg(struct bcm74110_mbox *mbox) { struct bcm74110_mbox_msg *msg, *msg_tmp; LIST_HEAD(list_temp); unsigned long flags; spin_lock_irqsave(&mbox->rx_svc_list_lock, flags); list_splice_init(&mbox->rx_svc_init_list, &list_temp); spin_unlock_irqrestore(&mbox->rx_svc_list_lock, flags); list_for_each_entry_safe(msg, msg_tmp, &list_temp, list_entry) { list_del(&msg->list_entry); kfree(msg); } } #define BCM_DEQUEUE_TIMEOUT_MS 30 static int bcm74110_rx_pop_init_msg_block(struct bcm74110_mbox *mbox, u32 func_type, u32 *val) { int ret, timeout = 0; do { ret = bcm74110_rx_pop_init_msg(mbox, func_type, val); if (!ret) return 0; /* TODO: Figure out what is a good sleep here. */ usleep_range(1000, 2000); timeout++; } while (timeout < BCM_DEQUEUE_TIMEOUT_MS); dev_warn(&mbox->pdev->dev, "Timeout waiting for service init response\n"); return -ETIMEDOUT; } static int bcm74110_mbox_create_msg(int req, int rply, int svc, int func, int length, int slot) { u32 msg = 0; BCM_MSG_SET_FIELD(msg, REQ, req); BCM_MSG_SET_FIELD(msg, RPLY, rply); BCM_MSG_SET_FIELD(msg, SVC, svc); BCM_MSG_SET_FIELD(msg, FUNC, func); BCM_MSG_SET_FIELD(msg, LENGTH, length); BCM_MSG_SET_FIELD(msg, SLOT, slot); return msg; } static int bcm74110_mbox_tx_msg(struct bcm74110_mbox *mbox, u32 msg) { int val; /* We can potentially poll with timeout here instead */ val = bcm74110_tx_readl(mbox, BCM_MBOX_STATUS0); if (val & BCM_MBOX_STATUS0_FULL) { dev_err(&mbox->pdev->dev, "Mailbox full\n"); return -EINVAL; } dev_dbg(&mbox->pdev->dev, "tx: [{req=%lu|rply=%lu|srv=%lu|fn=%lu|length=%lu|slot=%lu]\n", BCM_MSG_GET_FIELD(msg, REQ), BCM_MSG_GET_FIELD(msg, RPLY), BCM_MSG_GET_FIELD(msg, SVC), BCM_MSG_GET_FIELD(msg, FUNC), BCM_MSG_GET_FIELD(msg, LENGTH), BCM_MSG_GET_FIELD(msg, SLOT)); bcm74110_tx_writel(mbox, msg, BCM_MBOX_WDATA); return 0; } #define BCM_MBOX_LINK_TRAINING_RETRIES 5 static int bcm74110_mbox_link_training(struct bcm74110_mbox *mbox) { int ret, retries = 0; u32 msg = 0, orig_len = 0, len = BCM_LINK_CODE0; do { switch (len) { case 0: retries++; dev_warn(&mbox->pdev->dev, "Link train failed, trying again... %d\n", retries); if (retries > BCM_MBOX_LINK_TRAINING_RETRIES) return -EINVAL; len = BCM_LINK_CODE0; fallthrough; case BCM_LINK_CODE0: case BCM_LINK_CODE1: case BCM_LINK_CODE2: msg = bcm74110_mbox_create_msg(1, 0, BCM_MSG_SVC_INIT, BCM_MSG_FUNC_LINK_START, len, BCM_MSG_SVC_INIT); break; default: break; } bcm74110_mbox_tx_msg(mbox, msg); /* No response expected for LINK_CODE2 */ if (len == BCM_LINK_CODE2) return 0; orig_len = len; ret = bcm74110_rx_pop_init_msg_block(mbox, BCM_MSG_GET_FIELD(msg, FUNC), &msg); if (ret) { len = 0; continue; } if ((BCM_MSG_GET_FIELD(msg, SVC) != BCM_MSG_SVC_INIT) || (BCM_MSG_GET_FIELD(msg, FUNC) != BCM_MSG_FUNC_LINK_START) || (BCM_MSG_GET_FIELD(msg, SLOT) != 0) || (BCM_MSG_GET_FIELD(msg, RPLY) != 1) || (BCM_MSG_GET_FIELD(msg, REQ) != 0)) { len = 0; continue; } len = BCM_MSG_GET_FIELD(msg, LENGTH); /* Make sure sequence is good */ if (len != (orig_len + 1)) { len = 0; continue; } } while (1); return -EINVAL; } static int bcm74110_mbox_tx_msg_and_wait_ack(struct bcm74110_mbox *mbox, u32 msg) { int ret; u32 recv_msg; ret = bcm74110_mbox_tx_msg(mbox, msg); if (ret) return ret; ret = bcm74110_rx_pop_init_msg_block(mbox, BCM_MSG_GET_FIELD(msg, FUNC), &recv_msg); if (ret) return ret; /* * Modify tx message to verify rx ack. * Flip RPLY/REQ for synchronous messages */ if (BCM_MSG_GET_FIELD(msg, REQ) == 1) { BCM_MSG_SET_FIELD(msg, RPLY, 1); BCM_MSG_SET_FIELD(msg, REQ, 0); } if (msg != recv_msg) { dev_err(&mbox->pdev->dev, "Found ack, but ack is invalid\n"); return -EINVAL; } return 0; } /* Each index points to 0x100 of HAB MEM. IDX size counts from 0 */ #define BCM_MBOX_HAB_MEM_IDX_START 0x30 #define BCM_MBOX_HAB_MEM_IDX_SIZE 0x0 static int bcm74110_mbox_shmem_init(struct bcm74110_mbox *mbox) { u32 msg = 0; int ret; msg = bcm74110_mbox_create_msg(1, 0, BCM_MSG_SVC_INIT, BCM_MSG_FUNC_SHMEM_STOP, 0, BCM_MSG_SVC_INIT); ret = bcm74110_mbox_tx_msg_and_wait_ack(mbox, msg); if (ret) return -EINVAL; msg = bcm74110_mbox_create_msg(1, 0, BCM_MSG_SVC_INIT, BCM_MSG_FUNC_SHMEM_TX, BCM_MBOX_HAB_MEM_IDX_START, BCM_MBOX_HAB_MEM_IDX_SIZE); ret = bcm74110_mbox_tx_msg_and_wait_ack(mbox, msg); if (ret) return -EINVAL; msg = bcm74110_mbox_create_msg(1, 0, BCM_MSG_SVC_INIT, BCM_MSG_FUNC_SHMEM_RX, BCM_MBOX_HAB_MEM_IDX_START, BCM_MBOX_HAB_MEM_IDX_SIZE); ret = bcm74110_mbox_tx_msg_and_wait_ack(mbox, msg); if (ret) return -EINVAL; return 0; } static int bcm74110_mbox_init(struct bcm74110_mbox *mbox) { int ret = 0; /* Disable queues tx/rx */ bcm74110_tx_writel(mbox, 0x0, BCM_MBOX_CTRL); /* Clear status & restart tx/rx*/ bcm74110_tx_writel(mbox, BCM_MBOX_CTRL_EN | BCM_MBOX_CTRL_CLR, BCM_MBOX_CTRL); /* Unmask irq */ bcm74110_irq_writel(mbox, BCM_MBOX_IRQ_NOT_EMPTY, BCM_MBOX_IRQ_MASK_CLEAR); ret = bcm74110_mbox_link_training(mbox); if (ret) { dev_err(&mbox->pdev->dev, "Training failed\n"); return ret; } return bcm74110_mbox_shmem_init(mbox); } static int bcm74110_mbox_send_data(struct mbox_chan *chan, void *data) { struct bcm74110_mbox_chan *chan_priv = chan->con_priv; u32 msg; switch (chan_priv->type) { case BCM_MSG_SVC_PMC: case BCM_MSG_SVC_SCMI: case BCM_MSG_SVC_DPFE: msg = bcm74110_mbox_create_msg(1, 0, chan_priv->type, 0, 128 + 28, chan_priv->slot); break; default: return -EINVAL; } return bcm74110_mbox_tx_msg(chan_priv->mbox, msg); } static int bcm74110_mbox_chan_startup(struct mbox_chan *chan) { struct bcm74110_mbox_chan *chan_priv = chan->con_priv; chan_priv->en = true; return 0; } static void bcm74110_mbox_chan_shutdown(struct mbox_chan *chan) { struct bcm74110_mbox_chan *chan_priv = chan->con_priv; chan_priv->en = false; } static const struct mbox_chan_ops bcm74110_mbox_chan_ops = { .send_data = bcm74110_mbox_send_data, .startup = bcm74110_mbox_chan_startup, .shutdown = bcm74110_mbox_chan_shutdown, }; static void bcm74110_mbox_shutdown(struct platform_device *pdev) { struct bcm74110_mbox *mbox = dev_get_drvdata(&pdev->dev); u32 msg; msg = bcm74110_mbox_create_msg(1, 0, BCM_MSG_SVC_INIT, BCM_MSG_FUNC_LINK_STOP, 0, 0); bcm74110_mbox_tx_msg_and_wait_ack(mbox, msg); /* Even if we don't receive ACK, lets shut it down */ bcm74110_mbox_mask_and_clear(mbox); /* Disable queues tx/rx */ bcm74110_tx_writel(mbox, 0x0, BCM_MBOX_CTRL); /* Flush queues */ bcm74110_rx_flush_msg(mbox); } static struct mbox_chan *bcm74110_mbox_of_xlate(struct mbox_controller *cntrl, const struct of_phandle_args *p) { struct bcm74110_mbox *mbox = bcm74110_mbox_from_cntrl(cntrl); struct device *dev = &mbox->pdev->dev; struct bcm74110_mbox_chan *chan_priv; int slot, type; if (p->args_count != 2) { dev_err(dev, "Invalid arguments\n"); return ERR_PTR(-EINVAL); } type = p->args[0]; slot = p->args[1]; switch (type) { case BCM_MSG_SVC_PMC: case BCM_MSG_SVC_SCMI: case BCM_MSG_SVC_DPFE: if (slot > BCM_MBOX_HAB_MEM_IDX_SIZE) { dev_err(dev, "Not enough shared memory\n"); return ERR_PTR(-EINVAL); } chan_priv = cntrl->chans[type].con_priv; chan_priv->slot = slot; chan_priv->type = type; break; default: dev_err(dev, "Invalid channel type: %d\n", type); return ERR_PTR(-EINVAL); } return &cntrl->chans[type]; } static int bcm74110_mbox_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct bcm74110_mbox *mbox; int i, ret; mbox = devm_kzalloc(dev, sizeof(*mbox), GFP_KERNEL); if (!mbox) return -ENOMEM; mbox->pdev = pdev; platform_set_drvdata(pdev, mbox); mbox->base = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(mbox->base)) return dev_err_probe(dev, PTR_ERR(mbox->base), "Failed to iomap\n"); ret = of_property_read_u32(dev->of_node, "brcm,tx", &mbox->tx_chan); if (ret) return dev_err_probe(dev, ret, "Failed to find tx channel\n"); ret = of_property_read_u32(dev->of_node, "brcm,rx", &mbox->rx_chan); if (ret) return dev_err_probe(dev, ret, "Failed to find rx channel\n"); mbox->rx_irq = platform_get_irq(pdev, 0); if (mbox->rx_irq < 0) return mbox->rx_irq; INIT_LIST_HEAD(&mbox->rx_svc_init_list); spin_lock_init(&mbox->rx_svc_list_lock); bcm74110_mbox_mask_and_clear(mbox); ret = devm_request_irq(dev, mbox->rx_irq, bcm74110_mbox_isr, IRQF_NO_SUSPEND, pdev->name, mbox); if (ret) return dev_err_probe(dev, ret, "Failed to request irq\n"); mbox->controller.ops = &bcm74110_mbox_chan_ops; mbox->controller.dev = dev; mbox->controller.num_chans = BCM_MSG_SVC_MAX; mbox->controller.of_xlate = &bcm74110_mbox_of_xlate; mbox->controller.chans = devm_kcalloc(dev, BCM_MSG_SVC_MAX, sizeof(*mbox->controller.chans), GFP_KERNEL); if (!mbox->controller.chans) return -ENOMEM; mbox->mbox_chan = devm_kcalloc(dev, BCM_MSG_SVC_MAX, sizeof(*mbox->mbox_chan), GFP_KERNEL); if (!mbox->mbox_chan) return -ENOMEM; for (i = 0; i < BCM_MSG_SVC_MAX; i++) { mbox->mbox_chan[i].mbox = mbox; mbox->controller.chans[i].con_priv = &mbox->mbox_chan[i]; } ret = devm_mbox_controller_register(dev, &mbox->controller); if (ret) return ret; ret = bcm74110_mbox_init(mbox); if (ret) return ret; return 0; } static const struct of_device_id bcm74110_mbox_of_match[] = { { .compatible = "brcm,bcm74110-mbox", }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(of, bcm74110_mbox_of_match); static struct platform_driver bcm74110_mbox_driver = { .driver = { .name = "bcm74110-mbox", .of_match_table = bcm74110_mbox_of_match, }, .probe = bcm74110_mbox_probe, .shutdown = bcm74110_mbox_shutdown, }; module_platform_driver(bcm74110_mbox_driver); MODULE_AUTHOR("Justin Chen "); MODULE_DESCRIPTION("BCM74110 mailbox driver"); MODULE_LICENSE("GPL");