drivers/mailbox/bcm74110-mailbox.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Broadcom BCM74110 Mailbox Driver
 *
 * Copyright (c) 2025 Broadcom
 */
#include <linux/list.h>
#include <linux/types.h>
#include <linux/workqueue.h>
#include <linux/io-64-nonatomic-hi-lo.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/delay.h>
#include <linux/mailbox_controller.h>
#include <linux/bitfield.h>
#include <linux/slab.h>

#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;
};

#define BCM74110_INIT_MSG_MAX		16

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;
	unsigned int			rx_svc_init_count;
	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_obj(*msg, GFP_ATOMIC);
	if (!msg)
		return;

	INIT_LIST_HEAD(&msg->list_entry);
	msg->msg = val;

	spin_lock(&mbox->rx_svc_list_lock);
	if (mbox->rx_svc_init_count >= BCM74110_INIT_MSG_MAX) {
		spin_unlock(&mbox->rx_svc_list_lock);
		kfree(msg);
		dev_warn_ratelimited(&mbox->pdev->dev,
				     "PMC INIT msg list full, dropping message\n");
		return;
	}
	list_add_tail(&msg->list_entry, &mbox->rx_svc_init_list);
	mbox->rx_svc_init_count++;
	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);
			mbox->rx_svc_init_count--;
			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);
	mbox->rx_svc_init_count = 0;
	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 ret;

	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 <justin.chen@broadcom.com>");
MODULE_DESCRIPTION("BCM74110 mailbox driver");
MODULE_LICENSE("GPL");