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