1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright Aspeed Technology Inc. (C) 2025. All rights reserved
4 */
5
6 #include <linux/interrupt.h>
7 #include <linux/io.h>
8 #include <linux/iopoll.h>
9 #include <linux/kernel.h>
10 #include <linux/mailbox_controller.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/platform_device.h>
14 #include <linux/slab.h>
15
16 /* Each bit in the register represents an IPC ID */
17 #define IPCR_TX_TRIG 0x00
18 #define IPCR_ENABLE 0x04
19 #define IPCR_STATUS 0x08
20 #define RX_IRQ(n) BIT(n)
21 #define RX_IRQ_MASK 0xf
22 #define IPCR_DATA 0x10
23
24 struct ast2700_mbox_data {
25 u8 num_chans;
26 u8 msg_size;
27 };
28
29 struct ast2700_mbox {
30 struct mbox_controller mbox;
31 u8 msg_size;
32 void __iomem *tx_regs;
33 void __iomem *rx_regs;
34 spinlock_t lock;
35 };
36
ch_num(struct mbox_chan * chan)37 static inline int ch_num(struct mbox_chan *chan)
38 {
39 return chan - chan->mbox->chans;
40 }
41
ast2700_mbox_tx_done(struct ast2700_mbox * mb,int idx)42 static inline bool ast2700_mbox_tx_done(struct ast2700_mbox *mb, int idx)
43 {
44 return !(readl(mb->tx_regs + IPCR_STATUS) & BIT(idx));
45 }
46
ast2700_mbox_irq(int irq,void * p)47 static irqreturn_t ast2700_mbox_irq(int irq, void *p)
48 {
49 struct ast2700_mbox *mb = p;
50 void __iomem *data_reg;
51 int num_words = mb->msg_size / sizeof(u32);
52 u32 *word_data;
53 u32 status;
54 int n, i;
55
56 /* Only examine channels that are currently enabled. */
57 status = readl(mb->rx_regs + IPCR_ENABLE) &
58 readl(mb->rx_regs + IPCR_STATUS);
59
60 if (!(status & RX_IRQ_MASK))
61 return IRQ_NONE;
62
63 for (n = 0; n < mb->mbox.num_chans; ++n) {
64 struct mbox_chan *chan = &mb->mbox.chans[n];
65
66 if (!(status & RX_IRQ(n)))
67 continue;
68
69 data_reg = mb->rx_regs + IPCR_DATA + mb->msg_size * n;
70 word_data = chan->con_priv;
71 /* Read the message data */
72 for (i = 0; i < num_words; i++)
73 word_data[i] = readl(data_reg + i * sizeof(u32));
74
75 mbox_chan_received_data(chan, chan->con_priv);
76
77 /* The IRQ can be cleared only once the FIFO is empty. */
78 writel(RX_IRQ(n), mb->rx_regs + IPCR_STATUS);
79 }
80
81 return IRQ_HANDLED;
82 }
83
ast2700_mbox_send_data(struct mbox_chan * chan,void * data)84 static int ast2700_mbox_send_data(struct mbox_chan *chan, void *data)
85 {
86 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
87 int idx = ch_num(chan);
88 void __iomem *data_reg = mb->tx_regs + IPCR_DATA + mb->msg_size * idx;
89 u32 *word_data = data;
90 int num_words = mb->msg_size / sizeof(u32);
91 int i;
92
93 if (!(readl(mb->tx_regs + IPCR_ENABLE) & BIT(idx))) {
94 dev_warn(mb->mbox.dev, "%s: Ch-%d not enabled yet\n", __func__, idx);
95 return -ENODEV;
96 }
97
98 if (!(ast2700_mbox_tx_done(mb, idx))) {
99 dev_warn(mb->mbox.dev, "%s: Ch-%d last data has not finished\n", __func__, idx);
100 return -EBUSY;
101 }
102
103 /* Write the message data */
104 for (i = 0 ; i < num_words; i++)
105 writel(word_data[i], data_reg + i * sizeof(u32));
106
107 writel(BIT(idx), mb->tx_regs + IPCR_TX_TRIG);
108 dev_dbg(mb->mbox.dev, "%s: Ch-%d sent\n", __func__, idx);
109
110 return 0;
111 }
112
ast2700_mbox_startup(struct mbox_chan * chan)113 static int ast2700_mbox_startup(struct mbox_chan *chan)
114 {
115 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
116 int idx = ch_num(chan);
117 void __iomem *reg = mb->rx_regs + IPCR_ENABLE;
118 unsigned long flags;
119
120 spin_lock_irqsave(&mb->lock, flags);
121 writel(readl(reg) | BIT(idx), reg);
122 spin_unlock_irqrestore(&mb->lock, flags);
123
124 return 0;
125 }
126
ast2700_mbox_shutdown(struct mbox_chan * chan)127 static void ast2700_mbox_shutdown(struct mbox_chan *chan)
128 {
129 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
130 int idx = ch_num(chan);
131 void __iomem *reg = mb->rx_regs + IPCR_ENABLE;
132 unsigned long flags;
133
134 spin_lock_irqsave(&mb->lock, flags);
135 writel(readl(reg) & ~BIT(idx), reg);
136 spin_unlock_irqrestore(&mb->lock, flags);
137 }
138
ast2700_mbox_last_tx_done(struct mbox_chan * chan)139 static bool ast2700_mbox_last_tx_done(struct mbox_chan *chan)
140 {
141 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
142 int idx = ch_num(chan);
143
144 return ast2700_mbox_tx_done(mb, idx);
145 }
146
147 static const struct mbox_chan_ops ast2700_mbox_chan_ops = {
148 .send_data = ast2700_mbox_send_data,
149 .startup = ast2700_mbox_startup,
150 .shutdown = ast2700_mbox_shutdown,
151 .last_tx_done = ast2700_mbox_last_tx_done,
152 };
153
ast2700_mbox_probe(struct platform_device * pdev)154 static int ast2700_mbox_probe(struct platform_device *pdev)
155 {
156 struct ast2700_mbox *mb;
157 const struct ast2700_mbox_data *dev_data;
158 struct device *dev = &pdev->dev;
159 int irq, ret;
160
161 if (!pdev->dev.of_node)
162 return -ENODEV;
163
164 dev_data = device_get_match_data(&pdev->dev);
165
166 mb = devm_kzalloc(dev, sizeof(*mb), GFP_KERNEL);
167 if (!mb)
168 return -ENOMEM;
169
170 mb->mbox.chans = devm_kcalloc(&pdev->dev, dev_data->num_chans,
171 sizeof(*mb->mbox.chans), GFP_KERNEL);
172 if (!mb->mbox.chans)
173 return -ENOMEM;
174
175 /* con_priv of each channel is used to store the message received */
176 for (int i = 0; i < dev_data->num_chans; i++) {
177 mb->mbox.chans[i].con_priv = devm_kcalloc(dev, dev_data->msg_size,
178 sizeof(u8), GFP_KERNEL);
179 if (!mb->mbox.chans[i].con_priv)
180 return -ENOMEM;
181 }
182
183 platform_set_drvdata(pdev, mb);
184
185 mb->tx_regs = devm_platform_ioremap_resource_byname(pdev, "tx");
186 if (IS_ERR(mb->tx_regs))
187 return PTR_ERR(mb->tx_regs);
188
189 mb->rx_regs = devm_platform_ioremap_resource_byname(pdev, "rx");
190 if (IS_ERR(mb->rx_regs))
191 return PTR_ERR(mb->rx_regs);
192
193 mb->msg_size = dev_data->msg_size;
194 mb->mbox.dev = dev;
195 mb->mbox.num_chans = dev_data->num_chans;
196 mb->mbox.ops = &ast2700_mbox_chan_ops;
197 mb->mbox.txdone_irq = false;
198 mb->mbox.txdone_poll = true;
199 mb->mbox.txpoll_period = 5;
200 spin_lock_init(&mb->lock);
201
202 irq = platform_get_irq(pdev, 0);
203 if (irq < 0)
204 return irq;
205
206 ret = devm_request_irq(dev, irq, ast2700_mbox_irq, 0, dev_name(dev), mb);
207 if (ret)
208 return ret;
209
210 return devm_mbox_controller_register(dev, &mb->mbox);
211 }
212
213 static const struct ast2700_mbox_data ast2700_dev_data = {
214 .num_chans = 4,
215 .msg_size = 0x20,
216 };
217
218 static const struct of_device_id ast2700_mbox_of_match[] = {
219 { .compatible = "aspeed,ast2700-mailbox", .data = &ast2700_dev_data },
220 {}
221 };
222 MODULE_DEVICE_TABLE(of, ast2700_mbox_of_match);
223
224 static struct platform_driver ast2700_mbox_driver = {
225 .driver = {
226 .name = "ast2700-mailbox",
227 .of_match_table = ast2700_mbox_of_match,
228 },
229 .probe = ast2700_mbox_probe,
230 };
231 module_platform_driver(ast2700_mbox_driver);
232
233 MODULE_AUTHOR("Jammy Huang <jammy_huang@aspeedtech.com>");
234 MODULE_DESCRIPTION("ASPEED AST2700 IPC driver");
235 MODULE_LICENSE("GPL");
236