1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * STi Mailbox
4 *
5 * Copyright (C) 2015 ST Microelectronics
6 *
7 * Author: Lee Jones <lee.jones@linaro.org> for ST Microelectronics
8 *
9 * Based on the original driver written by;
10 * Alexandre Torgue, Olivier Lebreton and Loic Pallardy
11 */
12
13 #include <linux/err.h>
14 #include <linux/interrupt.h>
15 #include <linux/io.h>
16 #include <linux/kernel.h>
17 #include <linux/mailbox_controller.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/platform_device.h>
21 #include <linux/property.h>
22 #include <linux/slab.h>
23
24 #define STI_MBOX_INST_MAX 4 /* RAM saving: Max supported instances */
25 #define STI_MBOX_CHAN_MAX 20 /* RAM saving: Max supported channels */
26
27 #define STI_IRQ_VAL_OFFSET 0x04 /* Read interrupt status */
28 #define STI_IRQ_SET_OFFSET 0x24 /* Generate a Tx channel interrupt */
29 #define STI_IRQ_CLR_OFFSET 0x44 /* Clear pending Rx interrupts */
30 #define STI_ENA_VAL_OFFSET 0x64 /* Read enable status */
31 #define STI_ENA_SET_OFFSET 0x84 /* Enable a channel */
32 #define STI_ENA_CLR_OFFSET 0xa4 /* Disable a channel */
33
34 #define MBOX_BASE(mdev, inst) ((mdev)->base + ((inst) * 4))
35
36 /**
37 * struct sti_mbox_device - STi Mailbox device data
38 *
39 * @dev: Device to which it is attached
40 * @mbox: Representation of a communication channel controller
41 * @base: Base address of the register mapping region
42 * @name: Name of the mailbox
43 * @enabled: Local copy of enabled channels
44 * @lock: Mutex protecting enabled status
45 *
46 * An IP Mailbox is currently composed of 4 instances
47 * Each instance is currently composed of 32 channels
48 * This means that we have 128 channels per Mailbox
49 * A channel an be used for TX or RX
50 */
51 struct sti_mbox_device {
52 struct device *dev;
53 struct mbox_controller *mbox;
54 void __iomem *base;
55 const char *name;
56 u32 enabled[STI_MBOX_INST_MAX];
57 spinlock_t lock;
58 };
59
60 /**
61 * struct sti_mbox_pdata - STi Mailbox platform specific configuration
62 *
63 * @num_inst: Maximum number of instances in one HW Mailbox
64 * @num_chan: Maximum number of channel per instance
65 */
66 struct sti_mbox_pdata {
67 unsigned int num_inst;
68 unsigned int num_chan;
69 };
70
71 /**
72 * struct sti_channel - STi Mailbox allocated channel information
73 *
74 * @mdev: Pointer to parent Mailbox device
75 * @instance: Instance number channel resides in
76 * @channel: Channel number pertaining to this container
77 */
78 struct sti_channel {
79 struct sti_mbox_device *mdev;
80 unsigned int instance;
81 unsigned int channel;
82 };
83
sti_mbox_channel_is_enabled(struct mbox_chan * chan)84 static inline bool sti_mbox_channel_is_enabled(struct mbox_chan *chan)
85 {
86 struct sti_channel *chan_info = chan->con_priv;
87 struct sti_mbox_device *mdev = chan_info->mdev;
88 unsigned int instance = chan_info->instance;
89 unsigned int channel = chan_info->channel;
90
91 return mdev->enabled[instance] & BIT(channel);
92 }
93
94 static inline
sti_mbox_to_channel(struct mbox_controller * mbox,unsigned int instance,unsigned int channel)95 struct mbox_chan *sti_mbox_to_channel(struct mbox_controller *mbox,
96 unsigned int instance,
97 unsigned int channel)
98 {
99 struct sti_channel *chan_info;
100 int i;
101
102 for (i = 0; i < mbox->num_chans; i++) {
103 chan_info = mbox->chans[i].con_priv;
104 if (chan_info &&
105 chan_info->instance == instance &&
106 chan_info->channel == channel)
107 return &mbox->chans[i];
108 }
109
110 dev_err(mbox->dev,
111 "Channel not registered: instance: %d channel: %d\n",
112 instance, channel);
113
114 return NULL;
115 }
116
sti_mbox_enable_channel(struct mbox_chan * chan)117 static void sti_mbox_enable_channel(struct mbox_chan *chan)
118 {
119 struct sti_channel *chan_info = chan->con_priv;
120 struct sti_mbox_device *mdev = chan_info->mdev;
121 unsigned int instance = chan_info->instance;
122 unsigned int channel = chan_info->channel;
123 unsigned long flags;
124 void __iomem *base = MBOX_BASE(mdev, instance);
125
126 spin_lock_irqsave(&mdev->lock, flags);
127 mdev->enabled[instance] |= BIT(channel);
128 writel_relaxed(BIT(channel), base + STI_ENA_SET_OFFSET);
129 spin_unlock_irqrestore(&mdev->lock, flags);
130 }
131
sti_mbox_disable_channel(struct mbox_chan * chan)132 static void sti_mbox_disable_channel(struct mbox_chan *chan)
133 {
134 struct sti_channel *chan_info = chan->con_priv;
135 struct sti_mbox_device *mdev = chan_info->mdev;
136 unsigned int instance = chan_info->instance;
137 unsigned int channel = chan_info->channel;
138 unsigned long flags;
139 void __iomem *base = MBOX_BASE(mdev, instance);
140
141 spin_lock_irqsave(&mdev->lock, flags);
142 mdev->enabled[instance] &= ~BIT(channel);
143 writel_relaxed(BIT(channel), base + STI_ENA_CLR_OFFSET);
144 spin_unlock_irqrestore(&mdev->lock, flags);
145 }
146
sti_mbox_clear_irq(struct mbox_chan * chan)147 static void sti_mbox_clear_irq(struct mbox_chan *chan)
148 {
149 struct sti_channel *chan_info = chan->con_priv;
150 struct sti_mbox_device *mdev = chan_info->mdev;
151 unsigned int instance = chan_info->instance;
152 unsigned int channel = chan_info->channel;
153 void __iomem *base = MBOX_BASE(mdev, instance);
154
155 writel_relaxed(BIT(channel), base + STI_IRQ_CLR_OFFSET);
156 }
157
sti_mbox_irq_to_channel(struct sti_mbox_device * mdev,unsigned int instance)158 static struct mbox_chan *sti_mbox_irq_to_channel(struct sti_mbox_device *mdev,
159 unsigned int instance)
160 {
161 struct mbox_controller *mbox = mdev->mbox;
162 struct mbox_chan *chan = NULL;
163 unsigned int channel;
164 unsigned long bits;
165 void __iomem *base = MBOX_BASE(mdev, instance);
166
167 bits = readl_relaxed(base + STI_IRQ_VAL_OFFSET);
168 if (!bits)
169 /* No IRQs fired in specified instance */
170 return NULL;
171
172 /* An IRQ has fired, find the associated channel */
173 for (channel = 0; bits; channel++) {
174 if (!test_and_clear_bit(channel, &bits))
175 continue;
176
177 chan = sti_mbox_to_channel(mbox, instance, channel);
178 if (chan) {
179 dev_dbg(mbox->dev,
180 "IRQ fired on instance: %d channel: %d\n",
181 instance, channel);
182 break;
183 }
184 }
185
186 return chan;
187 }
188
sti_mbox_thread_handler(int irq,void * data)189 static irqreturn_t sti_mbox_thread_handler(int irq, void *data)
190 {
191 struct sti_mbox_device *mdev = data;
192 struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
193 struct mbox_chan *chan;
194 unsigned int instance;
195
196 for (instance = 0; instance < pdata->num_inst; instance++) {
197 keep_looking:
198 chan = sti_mbox_irq_to_channel(mdev, instance);
199 if (!chan)
200 continue;
201
202 mbox_chan_received_data(chan, NULL);
203 sti_mbox_clear_irq(chan);
204 sti_mbox_enable_channel(chan);
205 goto keep_looking;
206 }
207
208 return IRQ_HANDLED;
209 }
210
sti_mbox_irq_handler(int irq,void * data)211 static irqreturn_t sti_mbox_irq_handler(int irq, void *data)
212 {
213 struct sti_mbox_device *mdev = data;
214 struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
215 struct sti_channel *chan_info;
216 struct mbox_chan *chan;
217 unsigned int instance;
218 int ret = IRQ_NONE;
219
220 for (instance = 0; instance < pdata->num_inst; instance++) {
221 chan = sti_mbox_irq_to_channel(mdev, instance);
222 if (!chan)
223 continue;
224 chan_info = chan->con_priv;
225
226 if (!sti_mbox_channel_is_enabled(chan)) {
227 dev_warn(mdev->dev,
228 "Unexpected IRQ: %s\n"
229 " instance: %d: channel: %d [enabled: %x]\n",
230 mdev->name, chan_info->instance,
231 chan_info->channel, mdev->enabled[instance]);
232
233 /* Only handle IRQ if no other valid IRQs were found */
234 if (ret == IRQ_NONE)
235 ret = IRQ_HANDLED;
236 continue;
237 }
238
239 sti_mbox_disable_channel(chan);
240 ret = IRQ_WAKE_THREAD;
241 }
242
243 if (ret == IRQ_NONE)
244 dev_err(mdev->dev, "Spurious IRQ - was a channel requested?\n");
245
246 return ret;
247 }
248
sti_mbox_tx_is_ready(struct mbox_chan * chan)249 static bool sti_mbox_tx_is_ready(struct mbox_chan *chan)
250 {
251 struct sti_channel *chan_info = chan->con_priv;
252 struct sti_mbox_device *mdev = chan_info->mdev;
253 unsigned int instance = chan_info->instance;
254 unsigned int channel = chan_info->channel;
255 void __iomem *base = MBOX_BASE(mdev, instance);
256
257 if (!(readl_relaxed(base + STI_ENA_VAL_OFFSET) & BIT(channel))) {
258 dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d disabled\n",
259 mdev->name, instance, channel);
260 return false;
261 }
262
263 if (readl_relaxed(base + STI_IRQ_VAL_OFFSET) & BIT(channel)) {
264 dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d not ready\n",
265 mdev->name, instance, channel);
266 return false;
267 }
268
269 return true;
270 }
271
sti_mbox_send_data(struct mbox_chan * chan,void * data)272 static int sti_mbox_send_data(struct mbox_chan *chan, void *data)
273 {
274 struct sti_channel *chan_info = chan->con_priv;
275 struct sti_mbox_device *mdev = chan_info->mdev;
276 unsigned int instance = chan_info->instance;
277 unsigned int channel = chan_info->channel;
278 void __iomem *base = MBOX_BASE(mdev, instance);
279
280 /* Send event to co-processor */
281 writel_relaxed(BIT(channel), base + STI_IRQ_SET_OFFSET);
282
283 dev_dbg(mdev->dev,
284 "Sent via Mailbox %s: instance: %d channel: %d\n",
285 mdev->name, instance, channel);
286
287 return 0;
288 }
289
sti_mbox_startup_chan(struct mbox_chan * chan)290 static int sti_mbox_startup_chan(struct mbox_chan *chan)
291 {
292 sti_mbox_clear_irq(chan);
293 sti_mbox_enable_channel(chan);
294
295 return 0;
296 }
297
sti_mbox_shutdown_chan(struct mbox_chan * chan)298 static void sti_mbox_shutdown_chan(struct mbox_chan *chan)
299 {
300 struct sti_channel *chan_info = chan->con_priv;
301 struct mbox_controller *mbox = chan_info->mdev->mbox;
302 int i;
303
304 for (i = 0; i < mbox->num_chans; i++)
305 if (chan == &mbox->chans[i])
306 break;
307
308 if (mbox->num_chans == i) {
309 dev_warn(mbox->dev, "Request to free non-existent channel\n");
310 return;
311 }
312
313 /* Reset channel */
314 sti_mbox_disable_channel(chan);
315 sti_mbox_clear_irq(chan);
316 chan->con_priv = NULL;
317 }
318
sti_mbox_xlate(struct mbox_controller * mbox,const struct of_phandle_args * spec)319 static struct mbox_chan *sti_mbox_xlate(struct mbox_controller *mbox,
320 const struct of_phandle_args *spec)
321 {
322 struct sti_mbox_device *mdev = dev_get_drvdata(mbox->dev);
323 struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev);
324 struct sti_channel *chan_info;
325 struct mbox_chan *chan = NULL;
326 unsigned int instance = spec->args[0];
327 unsigned int channel = spec->args[1];
328 int i;
329
330 /* Bounds checking */
331 if (instance >= pdata->num_inst || channel >= pdata->num_chan) {
332 dev_err(mbox->dev,
333 "Invalid channel requested instance: %d channel: %d\n",
334 instance, channel);
335 return ERR_PTR(-EINVAL);
336 }
337
338 for (i = 0; i < mbox->num_chans; i++) {
339 chan_info = mbox->chans[i].con_priv;
340
341 /* Is requested channel free? */
342 if (chan_info &&
343 mbox->dev == chan_info->mdev->dev &&
344 instance == chan_info->instance &&
345 channel == chan_info->channel) {
346
347 dev_err(mbox->dev, "Channel in use\n");
348 return ERR_PTR(-EBUSY);
349 }
350
351 /*
352 * Find the first free slot, then continue checking
353 * to see if requested channel is in use
354 */
355 if (!chan && !chan_info)
356 chan = &mbox->chans[i];
357 }
358
359 if (!chan) {
360 dev_err(mbox->dev, "No free channels left\n");
361 return ERR_PTR(-EBUSY);
362 }
363
364 chan_info = devm_kzalloc(mbox->dev, sizeof(*chan_info), GFP_KERNEL);
365 if (!chan_info)
366 return ERR_PTR(-ENOMEM);
367
368 chan_info->mdev = mdev;
369 chan_info->instance = instance;
370 chan_info->channel = channel;
371
372 chan->con_priv = chan_info;
373
374 dev_info(mbox->dev,
375 "Mbox: %s: Created channel: instance: %d channel: %d\n",
376 mdev->name, instance, channel);
377
378 return chan;
379 }
380
381 static const struct mbox_chan_ops sti_mbox_ops = {
382 .startup = sti_mbox_startup_chan,
383 .shutdown = sti_mbox_shutdown_chan,
384 .send_data = sti_mbox_send_data,
385 .last_tx_done = sti_mbox_tx_is_ready,
386 };
387
388 static const struct sti_mbox_pdata mbox_stih407_pdata = {
389 .num_inst = 4,
390 .num_chan = 32,
391 };
392
393 static const struct of_device_id sti_mailbox_match[] = {
394 {
395 .compatible = "st,stih407-mailbox",
396 .data = (void *)&mbox_stih407_pdata
397 },
398 { }
399 };
400 MODULE_DEVICE_TABLE(of, sti_mailbox_match);
401
sti_mbox_probe(struct platform_device * pdev)402 static int sti_mbox_probe(struct platform_device *pdev)
403 {
404 struct mbox_controller *mbox;
405 struct sti_mbox_device *mdev;
406 struct device_node *np = pdev->dev.of_node;
407 struct mbox_chan *chans;
408 int irq;
409 int ret;
410
411 pdev->dev.platform_data = (struct sti_mbox_pdata *)device_get_match_data(&pdev->dev);
412 if (!pdev->dev.platform_data) {
413 dev_err(&pdev->dev, "No configuration found\n");
414 return -ENODEV;
415 }
416
417 mdev = devm_kzalloc(&pdev->dev, sizeof(*mdev), GFP_KERNEL);
418 if (!mdev)
419 return -ENOMEM;
420
421 platform_set_drvdata(pdev, mdev);
422
423 mdev->base = devm_platform_ioremap_resource(pdev, 0);
424 if (IS_ERR(mdev->base))
425 return PTR_ERR(mdev->base);
426
427 ret = of_property_read_string(np, "mbox-name", &mdev->name);
428 if (ret)
429 mdev->name = np->full_name;
430
431 mbox = devm_kzalloc(&pdev->dev, sizeof(*mbox), GFP_KERNEL);
432 if (!mbox)
433 return -ENOMEM;
434
435 chans = devm_kcalloc(&pdev->dev,
436 STI_MBOX_CHAN_MAX, sizeof(*chans), GFP_KERNEL);
437 if (!chans)
438 return -ENOMEM;
439
440 mdev->dev = &pdev->dev;
441 mdev->mbox = mbox;
442
443 spin_lock_init(&mdev->lock);
444
445 /* STi Mailbox does not have a Tx-Done or Tx-Ready IRQ */
446 mbox->txdone_irq = false;
447 mbox->txdone_poll = true;
448 mbox->txpoll_period = 100;
449 mbox->ops = &sti_mbox_ops;
450 mbox->dev = mdev->dev;
451 mbox->of_xlate = sti_mbox_xlate;
452 mbox->chans = chans;
453 mbox->num_chans = STI_MBOX_CHAN_MAX;
454
455 ret = devm_mbox_controller_register(&pdev->dev, mbox);
456 if (ret)
457 return ret;
458
459 /* It's okay for Tx Mailboxes to not supply IRQs */
460 irq = platform_get_irq(pdev, 0);
461 if (irq < 0) {
462 dev_info(&pdev->dev,
463 "%s: Registered Tx only Mailbox\n", mdev->name);
464 return 0;
465 }
466
467 ret = devm_request_threaded_irq(&pdev->dev, irq,
468 sti_mbox_irq_handler,
469 sti_mbox_thread_handler,
470 IRQF_ONESHOT, mdev->name, mdev);
471 if (ret) {
472 dev_err(&pdev->dev, "Can't claim IRQ %d\n", irq);
473 return -EINVAL;
474 }
475
476 dev_info(&pdev->dev, "%s: Registered Tx/Rx Mailbox\n", mdev->name);
477
478 return 0;
479 }
480
481 static struct platform_driver sti_mbox_driver = {
482 .probe = sti_mbox_probe,
483 .driver = {
484 .name = "sti-mailbox",
485 .of_match_table = sti_mailbox_match,
486 },
487 };
488 module_platform_driver(sti_mbox_driver);
489
490 MODULE_LICENSE("GPL");
491 MODULE_DESCRIPTION("STMicroelectronics Mailbox Controller");
492 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org");
493 MODULE_ALIAS("platform:mailbox-sti");
494