1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Xilinx Inter Processor Interrupt(IPI) Mailbox Driver
4 *
5 * Copyright (C) 2018 Xilinx, Inc.
6 */
7
8#include <linux/arm-smccc.h>
9#include <linux/cpuhotplug.h>
10#include <linux/delay.h>
11#include <linux/device.h>
12#include <linux/interrupt.h>
13#include <linux/irqdomain.h>
14#include <linux/io.h>
15#include <linux/kernel.h>
16#include <linux/mailbox_controller.h>
17#include <linux/mailbox/zynqmp-ipi-message.h>
18#include <linux/module.h>
19#include <linux/of.h>
20#include <linux/of_address.h>
21#include <linux/of_irq.h>
22#include <linux/platform_device.h>
23
24/* IPI agent ID any */
25#define IPI_ID_ANY 0xFFUL
26
27/* indicate if ZynqMP IPI mailbox driver uses SMC calls or HVC calls */
28#define USE_SMC 0
29#define USE_HVC 1
30
31/* Default IPI SMC function IDs */
32#define SMC_IPI_MAILBOX_OPEN 0x82001000U
33#define SMC_IPI_MAILBOX_RELEASE 0x82001001U
34#define SMC_IPI_MAILBOX_STATUS_ENQUIRY 0x82001002U
35#define SMC_IPI_MAILBOX_NOTIFY 0x82001003U
36#define SMC_IPI_MAILBOX_ACK 0x82001004U
37#define SMC_IPI_MAILBOX_ENABLE_IRQ 0x82001005U
38#define SMC_IPI_MAILBOX_DISABLE_IRQ 0x82001006U
39
40/* IPI SMC Macros */
41#define IPI_SMC_ENQUIRY_DIRQ_MASK 0x00000001UL /* Flag to indicate if
42 * notification interrupt
43 * to be disabled.
44 */
45#define IPI_SMC_ACK_EIRQ_MASK 0x00000001UL /* Flag to indicate if
46 * notification interrupt
47 * to be enabled.
48 */
49
50/* IPI mailbox status */
51#define IPI_MB_STATUS_IDLE 0
52#define IPI_MB_STATUS_SEND_PENDING 1
53#define IPI_MB_STATUS_RECV_PENDING 2
54
55#define IPI_MB_CHNL_TX 0 /* IPI mailbox TX channel */
56#define IPI_MB_CHNL_RX 1 /* IPI mailbox RX channel */
57
58/* IPI Message Buffer Information */
59#define RESP_OFFSET 0x20U
60#define DEST_OFFSET 0x40U
61#define IPI_BUF_SIZE 0x20U
62#define DST_BIT_POS 9U
63#define SRC_BITMASK GENMASK(11, 8)
64
65/* Macro to represent SGI type for IPI IRQs */
66#define IPI_IRQ_TYPE_SGI 2
67
68/*
69 * Module parameters
70 */
71static int tx_poll_period = 5;
72module_param_named(tx_poll_period, tx_poll_period, int, 0644);
73MODULE_PARM_DESC(tx_poll_period, "Poll period waiting for ack after send.");
74
75/**
76 * struct zynqmp_ipi_mchan - Description of a Xilinx ZynqMP IPI mailbox channel
77 * @is_opened: indicate if the IPI channel is opened
78 * @req_buf: local to remote request buffer start address
79 * @resp_buf: local to remote response buffer start address
80 * @req_buf_size: request buffer size
81 * @resp_buf_size: response buffer size
82 * @rx_buf: receive buffer to pass received message to client
83 * @chan_type: channel type
84 */
85struct zynqmp_ipi_mchan {
86 int is_opened;
87 void __iomem *req_buf;
88 void __iomem *resp_buf;
89 void *rx_buf;
90 size_t req_buf_size;
91 size_t resp_buf_size;
92 unsigned int chan_type;
93};
94
95struct zynqmp_ipi_mbox;
96
97typedef int (*setup_ipi_fn)(struct zynqmp_ipi_mbox *ipi_mbox, struct device_node *node);
98
99/**
100 * struct zynqmp_ipi_mbox - Description of a ZynqMP IPI mailbox
101 * platform data.
102 * @pdata: pointer to the IPI private data
103 * @dev: device pointer corresponding to the Xilinx ZynqMP
104 * IPI mailbox
105 * @remote_id: remote IPI agent ID
106 * @mbox: mailbox Controller
107 * @mchans: array for channels, tx channel and rx channel.
108 * @setup_ipi_fn: Function Pointer to set up IPI Channels
109 */
110struct zynqmp_ipi_mbox {
111 struct zynqmp_ipi_pdata *pdata;
112 struct device dev;
113 u32 remote_id;
114 struct mbox_controller mbox;
115 struct zynqmp_ipi_mchan mchans[2];
116 setup_ipi_fn setup_ipi_fn;
117};
118
119/**
120 * struct zynqmp_ipi_pdata - Description of z ZynqMP IPI agent platform data.
121 *
122 * @dev: device pointer corresponding to the Xilinx ZynqMP
123 * IPI agent
124 * @irq: IPI agent interrupt ID
125 * @irq_type: IPI SGI or SPI IRQ type
126 * @method: IPI SMC or HVC is going to be used
127 * @local_id: local IPI agent ID
128 * @virq_sgi: IRQ number mapped to SGI
129 * @num_mboxes: number of mailboxes of this IPI agent
130 * @ipi_mboxes: IPI mailboxes of this IPI agent
131 */
132struct zynqmp_ipi_pdata {
133 struct device *dev;
134 int irq;
135 unsigned int irq_type;
136 unsigned int method;
137 u32 local_id;
138 int virq_sgi;
139 int num_mboxes;
140 struct zynqmp_ipi_mbox ipi_mboxes[] __counted_by(num_mboxes);
141};
142
143static DEFINE_PER_CPU(struct zynqmp_ipi_pdata *, per_cpu_pdata);
144
145static struct device_driver zynqmp_ipi_mbox_driver = {
146 .owner = THIS_MODULE,
147 .name = "zynqmp-ipi-mbox",
148};
149
150static void zynqmp_ipi_fw_call(struct zynqmp_ipi_mbox *ipi_mbox,
151 unsigned long a0, unsigned long a3,
152 struct arm_smccc_res *res)
153{
154 struct zynqmp_ipi_pdata *pdata = ipi_mbox->pdata;
155 unsigned long a1, a2;
156
157 a1 = pdata->local_id;
158 a2 = ipi_mbox->remote_id;
159 if (pdata->method == USE_SMC)
160 arm_smccc_smc(a0, a1, a2, a3, 0, 0, 0, 0, res);
161 else
162 arm_smccc_hvc(a0, a1, a2, a3, 0, 0, 0, 0, res);
163}
164
165/**
166 * zynqmp_ipi_interrupt - Interrupt handler for IPI notification
167 *
168 * @irq: Interrupt number
169 * @data: ZynqMP IPI mailbox platform data.
170 *
171 * Return: -EINVAL if there is no instance
172 * IRQ_NONE if the interrupt is not ours.
173 * IRQ_HANDLED if the rx interrupt was successfully handled.
174 */
175static irqreturn_t zynqmp_ipi_interrupt(int irq, void *data)
176{
177 struct zynqmp_ipi_pdata *pdata = data;
178 struct mbox_chan *chan;
179 struct zynqmp_ipi_mbox *ipi_mbox;
180 struct zynqmp_ipi_mchan *mchan;
181 struct zynqmp_ipi_message *msg;
182 u64 arg0, arg3;
183 struct arm_smccc_res res;
184 int ret, i, status = IRQ_NONE;
185
186 (void)irq;
187 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
188 arg3 = IPI_SMC_ENQUIRY_DIRQ_MASK;
189 for (i = 0; i < pdata->num_mboxes; i++) {
190 ipi_mbox = &pdata->ipi_mboxes[i];
191 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
192 chan = &ipi_mbox->mbox.chans[IPI_MB_CHNL_RX];
193 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: arg3, res: &res);
194 ret = (int)(res.a0 & 0xFFFFFFFF);
195 if (ret > 0 && ret & IPI_MB_STATUS_RECV_PENDING) {
196 if (mchan->is_opened) {
197 msg = mchan->rx_buf;
198 if (msg) {
199 msg->len = mchan->req_buf_size;
200 memcpy_fromio(msg->data, mchan->req_buf,
201 msg->len);
202 }
203 mbox_chan_received_data(chan, data: (void *)msg);
204 status = IRQ_HANDLED;
205 }
206 }
207 }
208 return status;
209}
210
211static irqreturn_t zynqmp_sgi_interrupt(int irq, void *data)
212{
213 struct zynqmp_ipi_pdata **pdata_ptr = data;
214 struct zynqmp_ipi_pdata *pdata = *pdata_ptr;
215
216 return zynqmp_ipi_interrupt(irq, data: pdata);
217}
218
219/**
220 * zynqmp_ipi_peek_data - Peek to see if there are any rx messages.
221 *
222 * @chan: Channel Pointer
223 *
224 * Return: 'true' if there is pending rx data, 'false' if there is none.
225 */
226static bool zynqmp_ipi_peek_data(struct mbox_chan *chan)
227{
228 struct device *dev = chan->mbox->dev;
229 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
230 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
231 int ret;
232 u64 arg0;
233 struct arm_smccc_res res;
234
235 if (WARN_ON(!ipi_mbox)) {
236 dev_err(dev, "no platform drv data??\n");
237 return false;
238 }
239
240 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
241 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: 0, res: &res);
242 ret = (int)(res.a0 & 0xFFFFFFFF);
243
244 if (mchan->chan_type == IPI_MB_CHNL_TX) {
245 /* TX channel, check if the message has been acked
246 * by the remote, if yes, response is available.
247 */
248 if (ret < 0 || ret & IPI_MB_STATUS_SEND_PENDING)
249 return false;
250 else
251 return true;
252 } else if (ret > 0 && ret & IPI_MB_STATUS_RECV_PENDING) {
253 /* RX channel, check if there is message arrived. */
254 return true;
255 }
256 return false;
257}
258
259/**
260 * zynqmp_ipi_last_tx_done - See if the last tx message is sent
261 *
262 * @chan: Channel pointer
263 *
264 * Return: 'true' is no pending tx data, 'false' if there are any.
265 */
266static bool zynqmp_ipi_last_tx_done(struct mbox_chan *chan)
267{
268 struct device *dev = chan->mbox->dev;
269 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
270 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
271 int ret;
272 u64 arg0;
273 struct arm_smccc_res res;
274
275 if (WARN_ON(!ipi_mbox)) {
276 dev_err(dev, "no platform drv data??\n");
277 return false;
278 }
279
280 if (mchan->chan_type == IPI_MB_CHNL_TX) {
281 /* We only need to check if the message been taken
282 * by the remote in the TX channel
283 */
284 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
285 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: 0, res: &res);
286 /* Check the SMC call status, a0 of the result */
287 ret = (int)(res.a0 & 0xFFFFFFFF);
288 if (ret < 0 || ret & IPI_MB_STATUS_SEND_PENDING)
289 return false;
290 return true;
291 }
292 /* Always true for the response message in RX channel */
293 return true;
294}
295
296/**
297 * zynqmp_ipi_send_data - Send data
298 *
299 * @chan: Channel Pointer
300 * @data: Message Pointer
301 *
302 * Return: 0 if all goes good, else appropriate error messages.
303 */
304static int zynqmp_ipi_send_data(struct mbox_chan *chan, void *data)
305{
306 struct device *dev = chan->mbox->dev;
307 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
308 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
309 struct zynqmp_ipi_message *msg = data;
310 u64 arg0;
311 struct arm_smccc_res res;
312
313 if (WARN_ON(!ipi_mbox)) {
314 dev_err(dev, "no platform drv data??\n");
315 return -EINVAL;
316 }
317
318 if (mchan->chan_type == IPI_MB_CHNL_TX) {
319 /* Send request message */
320 if (msg && msg->len > mchan->req_buf_size && mchan->req_buf) {
321 dev_err(dev, "channel %d message length %u > max %lu\n",
322 mchan->chan_type, (unsigned int)msg->len,
323 mchan->req_buf_size);
324 return -EINVAL;
325 }
326 if (msg && msg->len && mchan->req_buf)
327 memcpy_toio(mchan->req_buf, msg->data, msg->len);
328 /* Kick IPI mailbox to send message */
329 arg0 = SMC_IPI_MAILBOX_NOTIFY;
330 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: 0, res: &res);
331 } else {
332 /* Send response message */
333 if (msg && msg->len > mchan->resp_buf_size && mchan->resp_buf) {
334 dev_err(dev, "channel %d message length %u > max %lu\n",
335 mchan->chan_type, (unsigned int)msg->len,
336 mchan->resp_buf_size);
337 return -EINVAL;
338 }
339 if (msg && msg->len && mchan->resp_buf)
340 memcpy_toio(mchan->resp_buf, msg->data, msg->len);
341 arg0 = SMC_IPI_MAILBOX_ACK;
342 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, IPI_SMC_ACK_EIRQ_MASK,
343 res: &res);
344 }
345 return 0;
346}
347
348/**
349 * zynqmp_ipi_startup - Startup the IPI channel
350 *
351 * @chan: Channel pointer
352 *
353 * Return: 0 if all goes good, else return corresponding error message
354 */
355static int zynqmp_ipi_startup(struct mbox_chan *chan)
356{
357 struct device *dev = chan->mbox->dev;
358 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
359 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
360 u64 arg0;
361 struct arm_smccc_res res;
362 int ret = 0;
363 unsigned int nchan_type;
364
365 if (mchan->is_opened)
366 return 0;
367
368 /* If no channel has been opened, open the IPI mailbox */
369 nchan_type = (mchan->chan_type + 1) % 2;
370 if (!ipi_mbox->mchans[nchan_type].is_opened) {
371 arg0 = SMC_IPI_MAILBOX_OPEN;
372 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: 0, res: &res);
373 /* Check the SMC call status, a0 of the result */
374 ret = (int)(res.a0 & 0xFFFFFFFF);
375 if (ret < 0) {
376 dev_err(dev, "SMC to open the IPI channel failed.\n");
377 return ret;
378 }
379 ret = 0;
380 }
381
382 /* If it is RX channel, enable the IPI notification interrupt */
383 if (mchan->chan_type == IPI_MB_CHNL_RX) {
384 arg0 = SMC_IPI_MAILBOX_ENABLE_IRQ;
385 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: 0, res: &res);
386 }
387 mchan->is_opened = 1;
388
389 return ret;
390}
391
392/**
393 * zynqmp_ipi_shutdown - Shutdown the IPI channel
394 *
395 * @chan: Channel pointer
396 */
397static void zynqmp_ipi_shutdown(struct mbox_chan *chan)
398{
399 struct device *dev = chan->mbox->dev;
400 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
401 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
402 u64 arg0;
403 struct arm_smccc_res res;
404 unsigned int chan_type;
405
406 if (!mchan->is_opened)
407 return;
408
409 /* If it is RX channel, disable notification interrupt */
410 chan_type = mchan->chan_type;
411 if (chan_type == IPI_MB_CHNL_RX) {
412 arg0 = SMC_IPI_MAILBOX_DISABLE_IRQ;
413 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: 0, res: &res);
414 }
415 /* Release IPI mailbox if no other channel is opened */
416 chan_type = (chan_type + 1) % 2;
417 if (!ipi_mbox->mchans[chan_type].is_opened) {
418 arg0 = SMC_IPI_MAILBOX_RELEASE;
419 zynqmp_ipi_fw_call(ipi_mbox, a0: arg0, a3: 0, res: &res);
420 }
421
422 mchan->is_opened = 0;
423}
424
425/* ZynqMP IPI mailbox operations */
426static const struct mbox_chan_ops zynqmp_ipi_chan_ops = {
427 .startup = zynqmp_ipi_startup,
428 .shutdown = zynqmp_ipi_shutdown,
429 .peek_data = zynqmp_ipi_peek_data,
430 .last_tx_done = zynqmp_ipi_last_tx_done,
431 .send_data = zynqmp_ipi_send_data,
432};
433
434/**
435 * zynqmp_ipi_of_xlate - Translate of phandle to IPI mailbox channel
436 *
437 * @mbox: mailbox controller pointer
438 * @p: phandle pointer
439 *
440 * Return: Mailbox channel, else return error pointer.
441 */
442static struct mbox_chan *zynqmp_ipi_of_xlate(struct mbox_controller *mbox,
443 const struct of_phandle_args *p)
444{
445 struct mbox_chan *chan;
446 struct device *dev = mbox->dev;
447 unsigned int chan_type;
448
449 /* Only supports TX and RX channels */
450 chan_type = p->args[0];
451 if (chan_type != IPI_MB_CHNL_TX && chan_type != IPI_MB_CHNL_RX) {
452 dev_err(dev, "req chnl failure: invalid chnl type %u.\n",
453 chan_type);
454 return ERR_PTR(error: -EINVAL);
455 }
456 chan = &mbox->chans[chan_type];
457 return chan;
458}
459
460/**
461 * zynqmp_ipi_mbox_get_buf_res - Get buffer resource from the IPI dev node
462 *
463 * @node: IPI mbox device child node
464 * @name: name of the IPI buffer
465 * @res: pointer to where the resource information will be stored.
466 *
467 * Return: 0 for success, negative value for failure
468 */
469static int zynqmp_ipi_mbox_get_buf_res(struct device_node *node,
470 const char *name,
471 struct resource *res)
472{
473 int ret, index;
474
475 index = of_property_match_string(np: node, propname: "reg-names", string: name);
476 if (index >= 0) {
477 ret = of_address_to_resource(dev: node, index, r: res);
478 if (ret < 0)
479 return -EINVAL;
480 return 0;
481 }
482 return -ENODEV;
483}
484
485/**
486 * zynqmp_ipi_mbox_dev_release() - release the existence of a ipi mbox dev
487 *
488 * @dev: the ipi mailbox device
489 *
490 * This is to avoid the no device release() function kernel warning.
491 *
492 */
493static void zynqmp_ipi_mbox_dev_release(struct device *dev)
494{
495 (void)dev;
496}
497
498/**
499 * zynqmp_ipi_mbox_probe - probe IPI mailbox resource from device node
500 *
501 * @ipi_mbox: pointer to IPI mailbox private data structure
502 * @node: IPI mailbox device node
503 *
504 * Return: 0 for success, negative value for failure
505 */
506static int zynqmp_ipi_mbox_probe(struct zynqmp_ipi_mbox *ipi_mbox,
507 struct device_node *node)
508{
509 struct mbox_chan *chans;
510 struct mbox_controller *mbox;
511 struct device *dev, *mdev;
512 int ret;
513
514 dev = ipi_mbox->pdata->dev;
515 /* Initialize dev for IPI mailbox */
516 ipi_mbox->dev.parent = dev;
517 ipi_mbox->dev.release = NULL;
518 ipi_mbox->dev.of_node = node;
519 dev_set_name(dev: &ipi_mbox->dev, name: "%s", of_node_full_name(np: node));
520 dev_set_drvdata(dev: &ipi_mbox->dev, data: ipi_mbox);
521 ipi_mbox->dev.release = zynqmp_ipi_mbox_dev_release;
522 ipi_mbox->dev.driver = &zynqmp_ipi_mbox_driver;
523 ret = device_register(dev: &ipi_mbox->dev);
524 if (ret) {
525 dev_err(dev, "Failed to register ipi mbox dev.\n");
526 put_device(dev: &ipi_mbox->dev);
527 return ret;
528 }
529 mdev = &ipi_mbox->dev;
530
531 /* Get the IPI remote agent ID */
532 ret = of_property_read_u32(np: node, propname: "xlnx,ipi-id", out_value: &ipi_mbox->remote_id);
533 if (ret < 0) {
534 dev_err(dev, "No IPI remote ID is specified.\n");
535 return ret;
536 }
537
538 ret = ipi_mbox->setup_ipi_fn(ipi_mbox, node);
539 if (ret) {
540 dev_err(dev, "Failed to set up IPI Buffers.\n");
541 return ret;
542 }
543
544 mbox = &ipi_mbox->mbox;
545 mbox->dev = mdev;
546 mbox->ops = &zynqmp_ipi_chan_ops;
547 mbox->num_chans = 2;
548 mbox->txdone_irq = false;
549 mbox->txdone_poll = true;
550 mbox->txpoll_period = tx_poll_period;
551 mbox->of_xlate = zynqmp_ipi_of_xlate;
552 chans = devm_kzalloc(dev: mdev, size: 2 * sizeof(*chans), GFP_KERNEL);
553 if (!chans)
554 return -ENOMEM;
555 mbox->chans = chans;
556 chans[IPI_MB_CHNL_TX].con_priv = &ipi_mbox->mchans[IPI_MB_CHNL_TX];
557 chans[IPI_MB_CHNL_RX].con_priv = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
558 ipi_mbox->mchans[IPI_MB_CHNL_TX].chan_type = IPI_MB_CHNL_TX;
559 ipi_mbox->mchans[IPI_MB_CHNL_RX].chan_type = IPI_MB_CHNL_RX;
560 ret = devm_mbox_controller_register(dev: mdev, mbox);
561 if (ret)
562 dev_err(mdev,
563 "Failed to register mbox_controller(%d)\n", ret);
564 else
565 dev_info(mdev,
566 "Registered ZynqMP IPI mbox with TX/RX channels.\n");
567 return ret;
568}
569
570/**
571 * zynqmp_ipi_setup - set up IPI Buffers for classic flow
572 *
573 * @ipi_mbox: pointer to IPI mailbox private data structure
574 * @node: IPI mailbox device node
575 *
576 * This will be used to set up IPI Buffers for ZynqMP SOC if user
577 * wishes to use classic driver usage model on new SOC's with only
578 * buffered IPIs.
579 *
580 * Note that bufferless IPIs and mixed usage of buffered and bufferless
581 * IPIs are not supported with this flow.
582 *
583 * This will be invoked with compatible string "xlnx,zynqmp-ipi-mailbox".
584 *
585 * Return: 0 for success, negative value for failure
586 */
587static int zynqmp_ipi_setup(struct zynqmp_ipi_mbox *ipi_mbox,
588 struct device_node *node)
589{
590 struct zynqmp_ipi_mchan *mchan;
591 struct device *mdev;
592 struct resource res;
593 const char *name;
594 int ret;
595
596 mdev = &ipi_mbox->dev;
597
598 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_TX];
599 name = "local_request_region";
600 ret = zynqmp_ipi_mbox_get_buf_res(node, name, res: &res);
601 if (!ret) {
602 mchan->req_buf_size = resource_size(res: &res);
603 mchan->req_buf = devm_ioremap(dev: mdev, offset: res.start,
604 size: mchan->req_buf_size);
605 if (!mchan->req_buf) {
606 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
607 return -ENOMEM;
608 }
609 } else if (ret != -ENODEV) {
610 dev_err(mdev, "Unmatched resource %s, %d.\n", name, ret);
611 return ret;
612 }
613
614 name = "remote_response_region";
615 ret = zynqmp_ipi_mbox_get_buf_res(node, name, res: &res);
616 if (!ret) {
617 mchan->resp_buf_size = resource_size(res: &res);
618 mchan->resp_buf = devm_ioremap(dev: mdev, offset: res.start,
619 size: mchan->resp_buf_size);
620 if (!mchan->resp_buf) {
621 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
622 return -ENOMEM;
623 }
624 } else if (ret != -ENODEV) {
625 dev_err(mdev, "Unmatched resource %s.\n", name);
626 return ret;
627 }
628 mchan->rx_buf = devm_kzalloc(dev: mdev,
629 size: mchan->resp_buf_size +
630 sizeof(struct zynqmp_ipi_message),
631 GFP_KERNEL);
632 if (!mchan->rx_buf)
633 return -ENOMEM;
634
635 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
636 name = "remote_request_region";
637 ret = zynqmp_ipi_mbox_get_buf_res(node, name, res: &res);
638 if (!ret) {
639 mchan->req_buf_size = resource_size(res: &res);
640 mchan->req_buf = devm_ioremap(dev: mdev, offset: res.start,
641 size: mchan->req_buf_size);
642 if (!mchan->req_buf) {
643 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
644 return -ENOMEM;
645 }
646 } else if (ret != -ENODEV) {
647 dev_err(mdev, "Unmatched resource %s.\n", name);
648 return ret;
649 }
650
651 name = "local_response_region";
652 ret = zynqmp_ipi_mbox_get_buf_res(node, name, res: &res);
653 if (!ret) {
654 mchan->resp_buf_size = resource_size(res: &res);
655 mchan->resp_buf = devm_ioremap(dev: mdev, offset: res.start,
656 size: mchan->resp_buf_size);
657 if (!mchan->resp_buf) {
658 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
659 return -ENOMEM;
660 }
661 } else if (ret != -ENODEV) {
662 dev_err(mdev, "Unmatched resource %s.\n", name);
663 return ret;
664 }
665 mchan->rx_buf = devm_kzalloc(dev: mdev,
666 size: mchan->resp_buf_size +
667 sizeof(struct zynqmp_ipi_message),
668 GFP_KERNEL);
669 if (!mchan->rx_buf)
670 return -ENOMEM;
671
672 return 0;
673}
674
675/**
676 * versal_ipi_setup - Set up IPIs to support mixed usage of
677 * Buffered and Bufferless IPIs.
678 *
679 * @ipi_mbox: pointer to IPI mailbox private data structure
680 * @node: IPI mailbox device node
681 *
682 * Return: 0 for success, negative value for failure
683 */
684static int versal_ipi_setup(struct zynqmp_ipi_mbox *ipi_mbox,
685 struct device_node *node)
686{
687 struct zynqmp_ipi_mchan *tx_mchan, *rx_mchan;
688 struct resource host_res, remote_res;
689 struct device_node *parent_node;
690 int host_idx, remote_idx;
691 struct device *mdev;
692
693 tx_mchan = &ipi_mbox->mchans[IPI_MB_CHNL_TX];
694 rx_mchan = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
695 parent_node = of_get_parent(node);
696 mdev = &ipi_mbox->dev;
697
698 host_idx = zynqmp_ipi_mbox_get_buf_res(node: parent_node, name: "msg", res: &host_res);
699 remote_idx = zynqmp_ipi_mbox_get_buf_res(node, name: "msg", res: &remote_res);
700
701 /*
702 * Only set up buffers if both sides claim to have msg buffers.
703 * This is because each buffered IPI's corresponding msg buffers
704 * are reserved for use by other buffered IPI's.
705 */
706 if (!host_idx && !remote_idx) {
707 u32 host_src, host_dst, remote_src, remote_dst;
708 u32 buff_sz;
709
710 buff_sz = resource_size(res: &host_res);
711
712 host_src = host_res.start & SRC_BITMASK;
713 remote_src = remote_res.start & SRC_BITMASK;
714
715 host_dst = (host_src >> DST_BIT_POS) * DEST_OFFSET;
716 remote_dst = (remote_src >> DST_BIT_POS) * DEST_OFFSET;
717
718 /* Validate that IPI IDs is within IPI Message buffer space. */
719 if (host_dst >= buff_sz || remote_dst >= buff_sz) {
720 dev_err(mdev,
721 "Invalid IPI Message buffer values: %x %x\n",
722 host_dst, remote_dst);
723 return -EINVAL;
724 }
725
726 tx_mchan->req_buf = devm_ioremap(dev: mdev,
727 offset: host_res.start | remote_dst,
728 IPI_BUF_SIZE);
729 if (!tx_mchan->req_buf) {
730 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
731 return -ENOMEM;
732 }
733
734 tx_mchan->resp_buf = devm_ioremap(dev: mdev,
735 offset: (remote_res.start | host_dst) +
736 RESP_OFFSET, IPI_BUF_SIZE);
737 if (!tx_mchan->resp_buf) {
738 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
739 return -ENOMEM;
740 }
741
742 rx_mchan->req_buf = devm_ioremap(dev: mdev,
743 offset: remote_res.start | host_dst,
744 IPI_BUF_SIZE);
745 if (!rx_mchan->req_buf) {
746 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
747 return -ENOMEM;
748 }
749
750 rx_mchan->resp_buf = devm_ioremap(dev: mdev,
751 offset: (host_res.start | remote_dst) +
752 RESP_OFFSET, IPI_BUF_SIZE);
753 if (!rx_mchan->resp_buf) {
754 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
755 return -ENOMEM;
756 }
757
758 tx_mchan->resp_buf_size = IPI_BUF_SIZE;
759 tx_mchan->req_buf_size = IPI_BUF_SIZE;
760 tx_mchan->rx_buf = devm_kzalloc(dev: mdev, IPI_BUF_SIZE +
761 sizeof(struct zynqmp_ipi_message),
762 GFP_KERNEL);
763 if (!tx_mchan->rx_buf)
764 return -ENOMEM;
765
766 rx_mchan->resp_buf_size = IPI_BUF_SIZE;
767 rx_mchan->req_buf_size = IPI_BUF_SIZE;
768 rx_mchan->rx_buf = devm_kzalloc(dev: mdev, IPI_BUF_SIZE +
769 sizeof(struct zynqmp_ipi_message),
770 GFP_KERNEL);
771 if (!rx_mchan->rx_buf)
772 return -ENOMEM;
773 }
774
775 return 0;
776}
777
778static int xlnx_mbox_cpuhp_start(unsigned int cpu)
779{
780 struct zynqmp_ipi_pdata *pdata;
781
782 pdata = get_cpu_var(per_cpu_pdata);
783 put_cpu_var(per_cpu_pdata);
784 enable_percpu_irq(irq: pdata->virq_sgi, type: IRQ_TYPE_NONE);
785
786 return 0;
787}
788
789static int xlnx_mbox_cpuhp_down(unsigned int cpu)
790{
791 struct zynqmp_ipi_pdata *pdata;
792
793 pdata = get_cpu_var(per_cpu_pdata);
794 put_cpu_var(per_cpu_pdata);
795 disable_percpu_irq(irq: pdata->virq_sgi);
796
797 return 0;
798}
799
800static void xlnx_disable_percpu_irq(void *data)
801{
802 struct zynqmp_ipi_pdata *pdata;
803
804 pdata = *this_cpu_ptr(&per_cpu_pdata);
805
806 disable_percpu_irq(irq: pdata->virq_sgi);
807}
808
809static int xlnx_mbox_init_sgi(struct platform_device *pdev,
810 int sgi_num,
811 struct zynqmp_ipi_pdata *pdata)
812{
813 int ret = 0;
814 int cpu;
815
816 /*
817 * IRQ related structures are used for the following:
818 * for each SGI interrupt ensure its mapped by GIC IRQ domain
819 * and that each corresponding linux IRQ for the HW IRQ has
820 * a handler for when receiving an interrupt from the remote
821 * processor.
822 */
823 struct irq_domain *domain;
824 struct irq_fwspec sgi_fwspec;
825 struct device_node *interrupt_parent = NULL;
826 struct device *dev = &pdev->dev;
827
828 /* Find GIC controller to map SGIs. */
829 interrupt_parent = of_irq_find_parent(child: dev->of_node);
830 if (!interrupt_parent) {
831 dev_err(&pdev->dev, "Failed to find property for Interrupt parent\n");
832 return -EINVAL;
833 }
834
835 /* Each SGI needs to be associated with GIC's IRQ domain. */
836 domain = irq_find_host(node: interrupt_parent);
837 of_node_put(node: interrupt_parent);
838
839 /* Each mapping needs GIC domain when finding IRQ mapping. */
840 sgi_fwspec.fwnode = domain->fwnode;
841
842 /*
843 * When irq domain looks at mapping each arg is as follows:
844 * 3 args for: interrupt type (SGI), interrupt # (set later), type
845 */
846 sgi_fwspec.param_count = 1;
847
848 /* Set SGI's hwirq */
849 sgi_fwspec.param[0] = sgi_num;
850 pdata->virq_sgi = irq_create_fwspec_mapping(fwspec: &sgi_fwspec);
851
852 for_each_possible_cpu(cpu)
853 per_cpu(per_cpu_pdata, cpu) = pdata;
854
855 ret = request_percpu_irq(irq: pdata->virq_sgi, handler: zynqmp_sgi_interrupt, devname: pdev->name,
856 percpu_dev_id: &per_cpu_pdata);
857 WARN_ON(ret);
858 if (ret) {
859 irq_dispose_mapping(virq: pdata->virq_sgi);
860 return ret;
861 }
862
863 irq_set_status_flags(irq: pdata->virq_sgi, set: IRQ_PER_CPU);
864
865 /* Setup function for the CPU hot-plug cases */
866 cpuhp_setup_state(state: CPUHP_AP_ONLINE_DYN, name: "mailbox/sgi:starting",
867 startup: xlnx_mbox_cpuhp_start, teardown: xlnx_mbox_cpuhp_down);
868
869 return ret;
870}
871
872static void xlnx_mbox_cleanup_sgi(struct zynqmp_ipi_pdata *pdata)
873{
874 cpuhp_remove_state(state: CPUHP_AP_ONLINE_DYN);
875
876 on_each_cpu(func: xlnx_disable_percpu_irq, NULL, wait: 1);
877
878 irq_clear_status_flags(irq: pdata->virq_sgi, clr: IRQ_PER_CPU);
879 free_percpu_irq(pdata->virq_sgi, &per_cpu_pdata);
880 irq_dispose_mapping(virq: pdata->virq_sgi);
881}
882
883/**
884 * zynqmp_ipi_free_mboxes - Free IPI mailboxes devices
885 *
886 * @pdata: IPI private data
887 */
888static void zynqmp_ipi_free_mboxes(struct zynqmp_ipi_pdata *pdata)
889{
890 struct zynqmp_ipi_mbox *ipi_mbox;
891 int i;
892
893 if (pdata->irq_type == IPI_IRQ_TYPE_SGI)
894 xlnx_mbox_cleanup_sgi(pdata);
895
896 i = pdata->num_mboxes - 1;
897 for (; i >= 0; i--) {
898 ipi_mbox = &pdata->ipi_mboxes[i];
899 if (device_is_registered(dev: &ipi_mbox->dev))
900 device_unregister(dev: &ipi_mbox->dev);
901 }
902}
903
904static int zynqmp_ipi_probe(struct platform_device *pdev)
905{
906 struct device *dev = &pdev->dev;
907 struct device_node *nc, *np = pdev->dev.of_node;
908 struct zynqmp_ipi_pdata *pdata;
909 struct of_phandle_args out_irq;
910 struct zynqmp_ipi_mbox *mbox;
911 int num_mboxes, ret = -EINVAL;
912 setup_ipi_fn ipi_fn;
913
914 num_mboxes = of_get_available_child_count(np);
915 if (num_mboxes == 0) {
916 dev_err(dev, "mailbox nodes not available\n");
917 return -EINVAL;
918 }
919
920 pdata = devm_kzalloc(dev, struct_size(pdata, ipi_mboxes, num_mboxes),
921 GFP_KERNEL);
922 if (!pdata)
923 return -ENOMEM;
924 pdata->dev = dev;
925
926 /* Get the IPI local agents ID */
927 ret = of_property_read_u32(np, propname: "xlnx,ipi-id", out_value: &pdata->local_id);
928 if (ret < 0) {
929 dev_err(dev, "No IPI local ID is specified.\n");
930 return ret;
931 }
932
933 ipi_fn = (setup_ipi_fn)device_get_match_data(dev: &pdev->dev);
934 if (!ipi_fn) {
935 dev_err(dev,
936 "Mbox Compatible String is missing IPI Setup fn.\n");
937 return -ENODEV;
938 }
939
940 pdata->num_mboxes = num_mboxes;
941
942 mbox = pdata->ipi_mboxes;
943 for_each_available_child_of_node(np, nc) {
944 mbox->pdata = pdata;
945 mbox->setup_ipi_fn = ipi_fn;
946
947 ret = zynqmp_ipi_mbox_probe(ipi_mbox: mbox, node: nc);
948 if (ret) {
949 of_node_put(node: nc);
950 dev_err(dev, "failed to probe subdev.\n");
951 ret = -EINVAL;
952 goto free_mbox_dev;
953 }
954 mbox++;
955 }
956
957 ret = of_irq_parse_one(device: dev_of_node(dev), index: 0, out_irq: &out_irq);
958 if (ret < 0) {
959 dev_err(dev, "failed to parse interrupts\n");
960 goto free_mbox_dev;
961 }
962
963 /* Use interrupt type to distinguish SGI and SPI interrupts */
964 pdata->irq_type = out_irq.args[0];
965
966 /*
967 * If Interrupt number is in SGI range, then request SGI else request
968 * IPI system IRQ.
969 */
970 if (pdata->irq_type == IPI_IRQ_TYPE_SGI) {
971 pdata->irq = out_irq.args[1];
972 ret = xlnx_mbox_init_sgi(pdev, sgi_num: pdata->irq, pdata);
973 if (ret)
974 goto free_mbox_dev;
975 } else {
976 ret = platform_get_irq(pdev, 0);
977 if (ret < 0)
978 goto free_mbox_dev;
979
980 pdata->irq = ret;
981 ret = devm_request_irq(dev, irq: pdata->irq, handler: zynqmp_ipi_interrupt,
982 IRQF_SHARED, devname: dev_name(dev), dev_id: pdata);
983 }
984
985 if (ret) {
986 dev_err(dev, "IRQ %d is not requested successfully.\n",
987 pdata->irq);
988 goto free_mbox_dev;
989 }
990
991 platform_set_drvdata(pdev, data: pdata);
992 return ret;
993
994free_mbox_dev:
995 zynqmp_ipi_free_mboxes(pdata);
996 return ret;
997}
998
999static void zynqmp_ipi_remove(struct platform_device *pdev)
1000{
1001 struct zynqmp_ipi_pdata *pdata;
1002
1003 pdata = platform_get_drvdata(pdev);
1004 zynqmp_ipi_free_mboxes(pdata);
1005}
1006
1007static const struct of_device_id zynqmp_ipi_of_match[] = {
1008 { .compatible = "xlnx,zynqmp-ipi-mailbox",
1009 .data = &zynqmp_ipi_setup,
1010 },
1011 { .compatible = "xlnx,versal-ipi-mailbox",
1012 .data = &versal_ipi_setup,
1013 },
1014 {},
1015};
1016MODULE_DEVICE_TABLE(of, zynqmp_ipi_of_match);
1017
1018static struct platform_driver zynqmp_ipi_driver = {
1019 .probe = zynqmp_ipi_probe,
1020 .remove = zynqmp_ipi_remove,
1021 .driver = {
1022 .name = "zynqmp-ipi",
1023 .of_match_table = of_match_ptr(zynqmp_ipi_of_match),
1024 },
1025};
1026
1027static int __init zynqmp_ipi_init(void)
1028{
1029 return platform_driver_register(&zynqmp_ipi_driver);
1030}
1031subsys_initcall(zynqmp_ipi_init);
1032
1033static void __exit zynqmp_ipi_exit(void)
1034{
1035 platform_driver_unregister(&zynqmp_ipi_driver);
1036}
1037module_exit(zynqmp_ipi_exit);
1038
1039MODULE_LICENSE("GPL v2");
1040MODULE_DESCRIPTION("Xilinx ZynqMP IPI Mailbox driver");
1041MODULE_AUTHOR("Xilinx Inc.");
1042

source code of linux/drivers/mailbox/zynqmp-ipi-mailbox.c