Loading...
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/delay.h>
10#include <linux/device.h>
11#include <linux/interrupt.h>
12#include <linux/io.h>
13#include <linux/kernel.h>
14#include <linux/mailbox_controller.h>
15#include <linux/mailbox/zynqmp-ipi-message.h>
16#include <linux/module.h>
17#include <linux/of.h>
18#include <linux/of_address.h>
19#include <linux/of_device.h>
20#include <linux/of_irq.h>
21#include <linux/platform_device.h>
22
23/* IPI agent ID any */
24#define IPI_ID_ANY 0xFFUL
25
26/* indicate if ZynqMP IPI mailbox driver uses SMC calls or HVC calls */
27#define USE_SMC 0
28#define USE_HVC 1
29
30/* Default IPI SMC function IDs */
31#define SMC_IPI_MAILBOX_OPEN 0x82001000U
32#define SMC_IPI_MAILBOX_RELEASE 0x82001001U
33#define SMC_IPI_MAILBOX_STATUS_ENQUIRY 0x82001002U
34#define SMC_IPI_MAILBOX_NOTIFY 0x82001003U
35#define SMC_IPI_MAILBOX_ACK 0x82001004U
36#define SMC_IPI_MAILBOX_ENABLE_IRQ 0x82001005U
37#define SMC_IPI_MAILBOX_DISABLE_IRQ 0x82001006U
38
39/* IPI SMC Macros */
40#define IPI_SMC_ENQUIRY_DIRQ_MASK 0x00000001UL /* Flag to indicate if
41 * notification interrupt
42 * to be disabled.
43 */
44#define IPI_SMC_ACK_EIRQ_MASK 0x00000001UL /* Flag to indicate if
45 * notification interrupt
46 * to be enabled.
47 */
48
49/* IPI mailbox status */
50#define IPI_MB_STATUS_IDLE 0
51#define IPI_MB_STATUS_SEND_PENDING 1
52#define IPI_MB_STATUS_RECV_PENDING 2
53
54#define IPI_MB_CHNL_TX 0 /* IPI mailbox TX channel */
55#define IPI_MB_CHNL_RX 1 /* IPI mailbox RX channel */
56
57/**
58 * struct zynqmp_ipi_mchan - Description of a Xilinx ZynqMP IPI mailbox channel
59 * @is_opened: indicate if the IPI channel is opened
60 * @req_buf: local to remote request buffer start address
61 * @resp_buf: local to remote response buffer start address
62 * @req_buf_size: request buffer size
63 * @resp_buf_size: response buffer size
64 * @rx_buf: receive buffer to pass received message to client
65 * @chan_type: channel type
66 */
67struct zynqmp_ipi_mchan {
68 int is_opened;
69 void __iomem *req_buf;
70 void __iomem *resp_buf;
71 void *rx_buf;
72 size_t req_buf_size;
73 size_t resp_buf_size;
74 unsigned int chan_type;
75};
76
77/**
78 * struct zynqmp_ipi_mbox - Description of a ZynqMP IPI mailbox
79 * platform data.
80 * @pdata: pointer to the IPI private data
81 * @dev: device pointer corresponding to the Xilinx ZynqMP
82 * IPI mailbox
83 * @remote_id: remote IPI agent ID
84 * @mbox: mailbox Controller
85 * @mchans: array for channels, tx channel and rx channel.
86 * @irq: IPI agent interrupt ID
87 */
88struct zynqmp_ipi_mbox {
89 struct zynqmp_ipi_pdata *pdata;
90 struct device dev;
91 u32 remote_id;
92 struct mbox_controller mbox;
93 struct zynqmp_ipi_mchan mchans[2];
94};
95
96/**
97 * struct zynqmp_ipi_pdata - Description of z ZynqMP IPI agent platform data.
98 *
99 * @dev: device pointer corresponding to the Xilinx ZynqMP
100 * IPI agent
101 * @irq: IPI agent interrupt ID
102 * @method: IPI SMC or HVC is going to be used
103 * @local_id: local IPI agent ID
104 * @num_mboxes: number of mailboxes of this IPI agent
105 * @ipi_mboxes: IPI mailboxes of this IPI agent
106 */
107struct zynqmp_ipi_pdata {
108 struct device *dev;
109 int irq;
110 unsigned int method;
111 u32 local_id;
112 int num_mboxes;
113 struct zynqmp_ipi_mbox *ipi_mboxes;
114};
115
116static struct device_driver zynqmp_ipi_mbox_driver = {
117 .owner = THIS_MODULE,
118 .name = "zynqmp-ipi-mbox",
119};
120
121static void zynqmp_ipi_fw_call(struct zynqmp_ipi_mbox *ipi_mbox,
122 unsigned long a0, unsigned long a3,
123 struct arm_smccc_res *res)
124{
125 struct zynqmp_ipi_pdata *pdata = ipi_mbox->pdata;
126 unsigned long a1, a2;
127
128 a1 = pdata->local_id;
129 a2 = ipi_mbox->remote_id;
130 if (pdata->method == USE_SMC)
131 arm_smccc_smc(a0, a1, a2, a3, 0, 0, 0, 0, res);
132 else
133 arm_smccc_hvc(a0, a1, a2, a3, 0, 0, 0, 0, res);
134}
135
136/**
137 * zynqmp_ipi_interrupt - Interrupt handler for IPI notification
138 *
139 * @irq: Interrupt number
140 * @data: ZynqMP IPI mailbox platform data.
141 *
142 * Return: -EINVAL if there is no instance
143 * IRQ_NONE if the interrupt is not ours.
144 * IRQ_HANDLED if the rx interrupt was successfully handled.
145 */
146static irqreturn_t zynqmp_ipi_interrupt(int irq, void *data)
147{
148 struct zynqmp_ipi_pdata *pdata = data;
149 struct mbox_chan *chan;
150 struct zynqmp_ipi_mbox *ipi_mbox;
151 struct zynqmp_ipi_mchan *mchan;
152 struct zynqmp_ipi_message *msg;
153 u64 arg0, arg3;
154 struct arm_smccc_res res;
155 int ret, i;
156
157 (void)irq;
158 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
159 arg3 = IPI_SMC_ENQUIRY_DIRQ_MASK;
160 for (i = 0; i < pdata->num_mboxes; i++) {
161 ipi_mbox = &pdata->ipi_mboxes[i];
162 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
163 chan = &ipi_mbox->mbox.chans[IPI_MB_CHNL_RX];
164 zynqmp_ipi_fw_call(ipi_mbox, arg0, arg3, &res);
165 ret = (int)(res.a0 & 0xFFFFFFFF);
166 if (ret > 0 && ret & IPI_MB_STATUS_RECV_PENDING) {
167 if (mchan->is_opened) {
168 msg = mchan->rx_buf;
169 msg->len = mchan->req_buf_size;
170 memcpy_fromio(msg->data, mchan->req_buf,
171 msg->len);
172 mbox_chan_received_data(chan, (void *)msg);
173 return IRQ_HANDLED;
174 }
175 }
176 }
177 return IRQ_NONE;
178}
179
180/**
181 * zynqmp_ipi_peek_data - Peek to see if there are any rx messages.
182 *
183 * @chan: Channel Pointer
184 *
185 * Return: 'true' if there is pending rx data, 'false' if there is none.
186 */
187static bool zynqmp_ipi_peek_data(struct mbox_chan *chan)
188{
189 struct device *dev = chan->mbox->dev;
190 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
191 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
192 int ret;
193 u64 arg0;
194 struct arm_smccc_res res;
195
196 if (WARN_ON(!ipi_mbox)) {
197 dev_err(dev, "no platform drv data??\n");
198 return false;
199 }
200
201 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
202 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
203 ret = (int)(res.a0 & 0xFFFFFFFF);
204
205 if (mchan->chan_type == IPI_MB_CHNL_TX) {
206 /* TX channel, check if the message has been acked
207 * by the remote, if yes, response is available.
208 */
209 if (ret < 0 || ret & IPI_MB_STATUS_SEND_PENDING)
210 return false;
211 else
212 return true;
213 } else if (ret > 0 && ret & IPI_MB_STATUS_RECV_PENDING) {
214 /* RX channel, check if there is message arrived. */
215 return true;
216 }
217 return false;
218}
219
220/**
221 * zynqmp_ipi_last_tx_done - See if the last tx message is sent
222 *
223 * @chan: Channel pointer
224 *
225 * Return: 'true' is no pending tx data, 'false' if there are any.
226 */
227static bool zynqmp_ipi_last_tx_done(struct mbox_chan *chan)
228{
229 struct device *dev = chan->mbox->dev;
230 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
231 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
232 int ret;
233 u64 arg0;
234 struct arm_smccc_res res;
235
236 if (WARN_ON(!ipi_mbox)) {
237 dev_err(dev, "no platform drv data??\n");
238 return false;
239 }
240
241 if (mchan->chan_type == IPI_MB_CHNL_TX) {
242 /* We only need to check if the message been taken
243 * by the remote in the TX channel
244 */
245 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
246 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
247 /* Check the SMC call status, a0 of the result */
248 ret = (int)(res.a0 & 0xFFFFFFFF);
249 if (ret < 0 || ret & IPI_MB_STATUS_SEND_PENDING)
250 return false;
251 return true;
252 }
253 /* Always true for the response message in RX channel */
254 return true;
255}
256
257/**
258 * zynqmp_ipi_send_data - Send data
259 *
260 * @chan: Channel Pointer
261 * @data: Message Pointer
262 *
263 * Return: 0 if all goes good, else appropriate error messages.
264 */
265static int zynqmp_ipi_send_data(struct mbox_chan *chan, void *data)
266{
267 struct device *dev = chan->mbox->dev;
268 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
269 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
270 struct zynqmp_ipi_message *msg = data;
271 u64 arg0;
272 struct arm_smccc_res res;
273
274 if (WARN_ON(!ipi_mbox)) {
275 dev_err(dev, "no platform drv data??\n");
276 return -EINVAL;
277 }
278
279 if (mchan->chan_type == IPI_MB_CHNL_TX) {
280 /* Send request message */
281 if (msg && msg->len > mchan->req_buf_size) {
282 dev_err(dev, "channel %d message length %u > max %lu\n",
283 mchan->chan_type, (unsigned int)msg->len,
284 mchan->req_buf_size);
285 return -EINVAL;
286 }
287 if (msg && msg->len)
288 memcpy_toio(mchan->req_buf, msg->data, msg->len);
289 /* Kick IPI mailbox to send message */
290 arg0 = SMC_IPI_MAILBOX_NOTIFY;
291 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
292 } else {
293 /* Send response message */
294 if (msg && msg->len > mchan->resp_buf_size) {
295 dev_err(dev, "channel %d message length %u > max %lu\n",
296 mchan->chan_type, (unsigned int)msg->len,
297 mchan->resp_buf_size);
298 return -EINVAL;
299 }
300 if (msg && msg->len)
301 memcpy_toio(mchan->resp_buf, msg->data, msg->len);
302 arg0 = SMC_IPI_MAILBOX_ACK;
303 zynqmp_ipi_fw_call(ipi_mbox, arg0, IPI_SMC_ACK_EIRQ_MASK,
304 &res);
305 }
306 return 0;
307}
308
309/**
310 * zynqmp_ipi_startup - Startup the IPI channel
311 *
312 * @chan: Channel pointer
313 *
314 * Return: 0 if all goes good, else return corresponding error message
315 */
316static int zynqmp_ipi_startup(struct mbox_chan *chan)
317{
318 struct device *dev = chan->mbox->dev;
319 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
320 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
321 u64 arg0;
322 struct arm_smccc_res res;
323 int ret = 0;
324 unsigned int nchan_type;
325
326 if (mchan->is_opened)
327 return 0;
328
329 /* If no channel has been opened, open the IPI mailbox */
330 nchan_type = (mchan->chan_type + 1) % 2;
331 if (!ipi_mbox->mchans[nchan_type].is_opened) {
332 arg0 = SMC_IPI_MAILBOX_OPEN;
333 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
334 /* Check the SMC call status, a0 of the result */
335 ret = (int)(res.a0 & 0xFFFFFFFF);
336 if (ret < 0) {
337 dev_err(dev, "SMC to open the IPI channel failed.\n");
338 return ret;
339 }
340 ret = 0;
341 }
342
343 /* If it is RX channel, enable the IPI notification interrupt */
344 if (mchan->chan_type == IPI_MB_CHNL_RX) {
345 arg0 = SMC_IPI_MAILBOX_ENABLE_IRQ;
346 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
347 }
348 mchan->is_opened = 1;
349
350 return ret;
351}
352
353/**
354 * zynqmp_ipi_shutdown - Shutdown the IPI channel
355 *
356 * @chan: Channel pointer
357 */
358static void zynqmp_ipi_shutdown(struct mbox_chan *chan)
359{
360 struct device *dev = chan->mbox->dev;
361 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
362 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
363 u64 arg0;
364 struct arm_smccc_res res;
365 unsigned int chan_type;
366
367 if (!mchan->is_opened)
368 return;
369
370 /* If it is RX channel, disable notification interrupt */
371 chan_type = mchan->chan_type;
372 if (chan_type == IPI_MB_CHNL_RX) {
373 arg0 = SMC_IPI_MAILBOX_DISABLE_IRQ;
374 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
375 }
376 /* Release IPI mailbox if no other channel is opened */
377 chan_type = (chan_type + 1) % 2;
378 if (!ipi_mbox->mchans[chan_type].is_opened) {
379 arg0 = SMC_IPI_MAILBOX_RELEASE;
380 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
381 }
382
383 mchan->is_opened = 0;
384}
385
386/* ZynqMP IPI mailbox operations */
387static const struct mbox_chan_ops zynqmp_ipi_chan_ops = {
388 .startup = zynqmp_ipi_startup,
389 .shutdown = zynqmp_ipi_shutdown,
390 .peek_data = zynqmp_ipi_peek_data,
391 .last_tx_done = zynqmp_ipi_last_tx_done,
392 .send_data = zynqmp_ipi_send_data,
393};
394
395/**
396 * zynqmp_ipi_of_xlate - Translate of phandle to IPI mailbox channel
397 *
398 * @mbox: mailbox controller pointer
399 * @p: phandle pointer
400 *
401 * Return: Mailbox channel, else return error pointer.
402 */
403static struct mbox_chan *zynqmp_ipi_of_xlate(struct mbox_controller *mbox,
404 const struct of_phandle_args *p)
405{
406 struct mbox_chan *chan;
407 struct device *dev = mbox->dev;
408 unsigned int chan_type;
409
410 /* Only supports TX and RX channels */
411 chan_type = p->args[0];
412 if (chan_type != IPI_MB_CHNL_TX && chan_type != IPI_MB_CHNL_RX) {
413 dev_err(dev, "req chnl failure: invalid chnl type %u.\n",
414 chan_type);
415 return ERR_PTR(-EINVAL);
416 }
417 chan = &mbox->chans[chan_type];
418 return chan;
419}
420
421static const struct of_device_id zynqmp_ipi_of_match[] = {
422 { .compatible = "xlnx,zynqmp-ipi-mailbox" },
423 {},
424};
425MODULE_DEVICE_TABLE(of, zynqmp_ipi_of_match);
426
427/**
428 * zynqmp_ipi_mbox_get_buf_res - Get buffer resource from the IPI dev node
429 *
430 * @node: IPI mbox device child node
431 * @name: name of the IPI buffer
432 * @res: pointer to where the resource information will be stored.
433 *
434 * Return: 0 for success, negative value for failure
435 */
436static int zynqmp_ipi_mbox_get_buf_res(struct device_node *node,
437 const char *name,
438 struct resource *res)
439{
440 int ret, index;
441
442 index = of_property_match_string(node, "reg-names", name);
443 if (index >= 0) {
444 ret = of_address_to_resource(node, index, res);
445 if (ret < 0)
446 return -EINVAL;
447 return 0;
448 }
449 return -ENODEV;
450}
451
452/**
453 * zynqmp_ipi_mbox_dev_release() - release the existence of a ipi mbox dev
454 *
455 * @dev: the ipi mailbox device
456 *
457 * This is to avoid the no device release() function kernel warning.
458 *
459 */
460static void zynqmp_ipi_mbox_dev_release(struct device *dev)
461{
462 (void)dev;
463}
464
465/**
466 * zynqmp_ipi_mbox_probe - probe IPI mailbox resource from device node
467 *
468 * @ipi_mbox: pointer to IPI mailbox private data structure
469 * @node: IPI mailbox device node
470 *
471 * Return: 0 for success, negative value for failure
472 */
473static int zynqmp_ipi_mbox_probe(struct zynqmp_ipi_mbox *ipi_mbox,
474 struct device_node *node)
475{
476 struct zynqmp_ipi_mchan *mchan;
477 struct mbox_chan *chans;
478 struct mbox_controller *mbox;
479 struct resource res;
480 struct device *dev, *mdev;
481 const char *name;
482 int ret;
483
484 dev = ipi_mbox->pdata->dev;
485 /* Initialize dev for IPI mailbox */
486 ipi_mbox->dev.parent = dev;
487 ipi_mbox->dev.release = NULL;
488 ipi_mbox->dev.of_node = node;
489 dev_set_name(&ipi_mbox->dev, "%s", of_node_full_name(node));
490 dev_set_drvdata(&ipi_mbox->dev, ipi_mbox);
491 ipi_mbox->dev.release = zynqmp_ipi_mbox_dev_release;
492 ipi_mbox->dev.driver = &zynqmp_ipi_mbox_driver;
493 ret = device_register(&ipi_mbox->dev);
494 if (ret) {
495 dev_err(dev, "Failed to register ipi mbox dev.\n");
496 put_device(&ipi_mbox->dev);
497 return ret;
498 }
499 mdev = &ipi_mbox->dev;
500
501 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_TX];
502 name = "local_request_region";
503 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
504 if (!ret) {
505 mchan->req_buf_size = resource_size(&res);
506 mchan->req_buf = devm_ioremap(mdev, res.start,
507 mchan->req_buf_size);
508 if (!mchan->req_buf) {
509 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
510 return -ENOMEM;
511 }
512 } else if (ret != -ENODEV) {
513 dev_err(mdev, "Unmatched resource %s, %d.\n", name, ret);
514 return ret;
515 }
516
517 name = "remote_response_region";
518 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
519 if (!ret) {
520 mchan->resp_buf_size = resource_size(&res);
521 mchan->resp_buf = devm_ioremap(mdev, res.start,
522 mchan->resp_buf_size);
523 if (!mchan->resp_buf) {
524 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
525 return -ENOMEM;
526 }
527 } else if (ret != -ENODEV) {
528 dev_err(mdev, "Unmatched resource %s.\n", name);
529 return ret;
530 }
531 mchan->rx_buf = devm_kzalloc(mdev,
532 mchan->resp_buf_size +
533 sizeof(struct zynqmp_ipi_message),
534 GFP_KERNEL);
535 if (!mchan->rx_buf)
536 return -ENOMEM;
537
538 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
539 name = "remote_request_region";
540 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
541 if (!ret) {
542 mchan->req_buf_size = resource_size(&res);
543 mchan->req_buf = devm_ioremap(mdev, res.start,
544 mchan->req_buf_size);
545 if (!mchan->req_buf) {
546 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
547 return -ENOMEM;
548 }
549 } else if (ret != -ENODEV) {
550 dev_err(mdev, "Unmatched resource %s.\n", name);
551 return ret;
552 }
553
554 name = "local_response_region";
555 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
556 if (!ret) {
557 mchan->resp_buf_size = resource_size(&res);
558 mchan->resp_buf = devm_ioremap(mdev, res.start,
559 mchan->resp_buf_size);
560 if (!mchan->resp_buf) {
561 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
562 return -ENOMEM;
563 }
564 } else if (ret != -ENODEV) {
565 dev_err(mdev, "Unmatched resource %s.\n", name);
566 return ret;
567 }
568 mchan->rx_buf = devm_kzalloc(mdev,
569 mchan->resp_buf_size +
570 sizeof(struct zynqmp_ipi_message),
571 GFP_KERNEL);
572 if (!mchan->rx_buf)
573 return -ENOMEM;
574
575 /* Get the IPI remote agent ID */
576 ret = of_property_read_u32(node, "xlnx,ipi-id", &ipi_mbox->remote_id);
577 if (ret < 0) {
578 dev_err(dev, "No IPI remote ID is specified.\n");
579 return ret;
580 }
581
582 mbox = &ipi_mbox->mbox;
583 mbox->dev = mdev;
584 mbox->ops = &zynqmp_ipi_chan_ops;
585 mbox->num_chans = 2;
586 mbox->txdone_irq = false;
587 mbox->txdone_poll = true;
588 mbox->txpoll_period = 5;
589 mbox->of_xlate = zynqmp_ipi_of_xlate;
590 chans = devm_kzalloc(mdev, 2 * sizeof(*chans), GFP_KERNEL);
591 if (!chans)
592 return -ENOMEM;
593 mbox->chans = chans;
594 chans[IPI_MB_CHNL_TX].con_priv = &ipi_mbox->mchans[IPI_MB_CHNL_TX];
595 chans[IPI_MB_CHNL_RX].con_priv = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
596 ipi_mbox->mchans[IPI_MB_CHNL_TX].chan_type = IPI_MB_CHNL_TX;
597 ipi_mbox->mchans[IPI_MB_CHNL_RX].chan_type = IPI_MB_CHNL_RX;
598 ret = devm_mbox_controller_register(mdev, mbox);
599 if (ret)
600 dev_err(mdev,
601 "Failed to register mbox_controller(%d)\n", ret);
602 else
603 dev_info(mdev,
604 "Registered ZynqMP IPI mbox with TX/RX channels.\n");
605 return ret;
606}
607
608/**
609 * zynqmp_ipi_free_mboxes - Free IPI mailboxes devices
610 *
611 * @pdata: IPI private data
612 */
613static void zynqmp_ipi_free_mboxes(struct zynqmp_ipi_pdata *pdata)
614{
615 struct zynqmp_ipi_mbox *ipi_mbox;
616 int i;
617
618 i = pdata->num_mboxes;
619 for (; i >= 0; i--) {
620 ipi_mbox = &pdata->ipi_mboxes[i];
621 if (ipi_mbox->dev.parent) {
622 mbox_controller_unregister(&ipi_mbox->mbox);
623 if (device_is_registered(&ipi_mbox->dev))
624 device_unregister(&ipi_mbox->dev);
625 }
626 }
627}
628
629static int zynqmp_ipi_probe(struct platform_device *pdev)
630{
631 struct device *dev = &pdev->dev;
632 struct device_node *nc, *np = pdev->dev.of_node;
633 struct zynqmp_ipi_pdata *pdata;
634 struct zynqmp_ipi_mbox *mbox;
635 int num_mboxes, ret = -EINVAL;
636
637 num_mboxes = of_get_child_count(np);
638 pdata = devm_kzalloc(dev, sizeof(*pdata) + (num_mboxes * sizeof(*mbox)),
639 GFP_KERNEL);
640 if (!pdata)
641 return -ENOMEM;
642 pdata->dev = dev;
643
644 /* Get the IPI local agents ID */
645 ret = of_property_read_u32(np, "xlnx,ipi-id", &pdata->local_id);
646 if (ret < 0) {
647 dev_err(dev, "No IPI local ID is specified.\n");
648 return ret;
649 }
650
651 pdata->num_mboxes = num_mboxes;
652 pdata->ipi_mboxes = (struct zynqmp_ipi_mbox *)
653 ((char *)pdata + sizeof(*pdata));
654
655 mbox = pdata->ipi_mboxes;
656 for_each_available_child_of_node(np, nc) {
657 mbox->pdata = pdata;
658 ret = zynqmp_ipi_mbox_probe(mbox, nc);
659 if (ret) {
660 of_node_put(nc);
661 dev_err(dev, "failed to probe subdev.\n");
662 ret = -EINVAL;
663 goto free_mbox_dev;
664 }
665 mbox++;
666 }
667
668 /* IPI IRQ */
669 ret = platform_get_irq(pdev, 0);
670 if (ret < 0)
671 goto free_mbox_dev;
672
673 pdata->irq = ret;
674 ret = devm_request_irq(dev, pdata->irq, zynqmp_ipi_interrupt,
675 IRQF_SHARED, dev_name(dev), pdata);
676 if (ret) {
677 dev_err(dev, "IRQ %d is not requested successfully.\n",
678 pdata->irq);
679 goto free_mbox_dev;
680 }
681
682 platform_set_drvdata(pdev, pdata);
683 return ret;
684
685free_mbox_dev:
686 zynqmp_ipi_free_mboxes(pdata);
687 return ret;
688}
689
690static int zynqmp_ipi_remove(struct platform_device *pdev)
691{
692 struct zynqmp_ipi_pdata *pdata;
693
694 pdata = platform_get_drvdata(pdev);
695 zynqmp_ipi_free_mboxes(pdata);
696
697 return 0;
698}
699
700static struct platform_driver zynqmp_ipi_driver = {
701 .probe = zynqmp_ipi_probe,
702 .remove = zynqmp_ipi_remove,
703 .driver = {
704 .name = "zynqmp-ipi",
705 .of_match_table = of_match_ptr(zynqmp_ipi_of_match),
706 },
707};
708
709static int __init zynqmp_ipi_init(void)
710{
711 return platform_driver_register(&zynqmp_ipi_driver);
712}
713subsys_initcall(zynqmp_ipi_init);
714
715static void __exit zynqmp_ipi_exit(void)
716{
717 platform_driver_unregister(&zynqmp_ipi_driver);
718}
719module_exit(zynqmp_ipi_exit);
720
721MODULE_LICENSE("GPL v2");
722MODULE_DESCRIPTION("Xilinx ZynqMP IPI Mailbox driver");
723MODULE_AUTHOR("Xilinx Inc.");
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/delay.h>
10#include <linux/device.h>
11#include <linux/interrupt.h>
12#include <linux/io.h>
13#include <linux/kernel.h>
14#include <linux/mailbox_controller.h>
15#include <linux/mailbox/zynqmp-ipi-message.h>
16#include <linux/module.h>
17#include <linux/of.h>
18#include <linux/of_address.h>
19#include <linux/platform_device.h>
20
21/* IPI agent ID any */
22#define IPI_ID_ANY 0xFFUL
23
24/* indicate if ZynqMP IPI mailbox driver uses SMC calls or HVC calls */
25#define USE_SMC 0
26#define USE_HVC 1
27
28/* Default IPI SMC function IDs */
29#define SMC_IPI_MAILBOX_OPEN 0x82001000U
30#define SMC_IPI_MAILBOX_RELEASE 0x82001001U
31#define SMC_IPI_MAILBOX_STATUS_ENQUIRY 0x82001002U
32#define SMC_IPI_MAILBOX_NOTIFY 0x82001003U
33#define SMC_IPI_MAILBOX_ACK 0x82001004U
34#define SMC_IPI_MAILBOX_ENABLE_IRQ 0x82001005U
35#define SMC_IPI_MAILBOX_DISABLE_IRQ 0x82001006U
36
37/* IPI SMC Macros */
38#define IPI_SMC_ENQUIRY_DIRQ_MASK 0x00000001UL /* Flag to indicate if
39 * notification interrupt
40 * to be disabled.
41 */
42#define IPI_SMC_ACK_EIRQ_MASK 0x00000001UL /* Flag to indicate if
43 * notification interrupt
44 * to be enabled.
45 */
46
47/* IPI mailbox status */
48#define IPI_MB_STATUS_IDLE 0
49#define IPI_MB_STATUS_SEND_PENDING 1
50#define IPI_MB_STATUS_RECV_PENDING 2
51
52#define IPI_MB_CHNL_TX 0 /* IPI mailbox TX channel */
53#define IPI_MB_CHNL_RX 1 /* IPI mailbox RX channel */
54
55/**
56 * struct zynqmp_ipi_mchan - Description of a Xilinx ZynqMP IPI mailbox channel
57 * @is_opened: indicate if the IPI channel is opened
58 * @req_buf: local to remote request buffer start address
59 * @resp_buf: local to remote response buffer start address
60 * @req_buf_size: request buffer size
61 * @resp_buf_size: response buffer size
62 * @rx_buf: receive buffer to pass received message to client
63 * @chan_type: channel type
64 */
65struct zynqmp_ipi_mchan {
66 int is_opened;
67 void __iomem *req_buf;
68 void __iomem *resp_buf;
69 void *rx_buf;
70 size_t req_buf_size;
71 size_t resp_buf_size;
72 unsigned int chan_type;
73};
74
75/**
76 * struct zynqmp_ipi_mbox - Description of a ZynqMP IPI mailbox
77 * platform data.
78 * @pdata: pointer to the IPI private data
79 * @dev: device pointer corresponding to the Xilinx ZynqMP
80 * IPI mailbox
81 * @remote_id: remote IPI agent ID
82 * @mbox: mailbox Controller
83 * @mchans: array for channels, tx channel and rx channel.
84 */
85struct zynqmp_ipi_mbox {
86 struct zynqmp_ipi_pdata *pdata;
87 struct device dev;
88 u32 remote_id;
89 struct mbox_controller mbox;
90 struct zynqmp_ipi_mchan mchans[2];
91};
92
93/**
94 * struct zynqmp_ipi_pdata - Description of z ZynqMP IPI agent platform data.
95 *
96 * @dev: device pointer corresponding to the Xilinx ZynqMP
97 * IPI agent
98 * @irq: IPI agent interrupt ID
99 * @method: IPI SMC or HVC is going to be used
100 * @local_id: local IPI agent ID
101 * @num_mboxes: number of mailboxes of this IPI agent
102 * @ipi_mboxes: IPI mailboxes of this IPI agent
103 */
104struct zynqmp_ipi_pdata {
105 struct device *dev;
106 int irq;
107 unsigned int method;
108 u32 local_id;
109 int num_mboxes;
110 struct zynqmp_ipi_mbox ipi_mboxes[] __counted_by(num_mboxes);
111};
112
113static struct device_driver zynqmp_ipi_mbox_driver = {
114 .owner = THIS_MODULE,
115 .name = "zynqmp-ipi-mbox",
116};
117
118static void zynqmp_ipi_fw_call(struct zynqmp_ipi_mbox *ipi_mbox,
119 unsigned long a0, unsigned long a3,
120 struct arm_smccc_res *res)
121{
122 struct zynqmp_ipi_pdata *pdata = ipi_mbox->pdata;
123 unsigned long a1, a2;
124
125 a1 = pdata->local_id;
126 a2 = ipi_mbox->remote_id;
127 if (pdata->method == USE_SMC)
128 arm_smccc_smc(a0, a1, a2, a3, 0, 0, 0, 0, res);
129 else
130 arm_smccc_hvc(a0, a1, a2, a3, 0, 0, 0, 0, res);
131}
132
133/**
134 * zynqmp_ipi_interrupt - Interrupt handler for IPI notification
135 *
136 * @irq: Interrupt number
137 * @data: ZynqMP IPI mailbox platform data.
138 *
139 * Return: -EINVAL if there is no instance
140 * IRQ_NONE if the interrupt is not ours.
141 * IRQ_HANDLED if the rx interrupt was successfully handled.
142 */
143static irqreturn_t zynqmp_ipi_interrupt(int irq, void *data)
144{
145 struct zynqmp_ipi_pdata *pdata = data;
146 struct mbox_chan *chan;
147 struct zynqmp_ipi_mbox *ipi_mbox;
148 struct zynqmp_ipi_mchan *mchan;
149 struct zynqmp_ipi_message *msg;
150 u64 arg0, arg3;
151 struct arm_smccc_res res;
152 int ret, i, status = IRQ_NONE;
153
154 (void)irq;
155 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
156 arg3 = IPI_SMC_ENQUIRY_DIRQ_MASK;
157 for (i = 0; i < pdata->num_mboxes; i++) {
158 ipi_mbox = &pdata->ipi_mboxes[i];
159 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
160 chan = &ipi_mbox->mbox.chans[IPI_MB_CHNL_RX];
161 zynqmp_ipi_fw_call(ipi_mbox, arg0, arg3, &res);
162 ret = (int)(res.a0 & 0xFFFFFFFF);
163 if (ret > 0 && ret & IPI_MB_STATUS_RECV_PENDING) {
164 if (mchan->is_opened) {
165 msg = mchan->rx_buf;
166 msg->len = mchan->req_buf_size;
167 memcpy_fromio(msg->data, mchan->req_buf,
168 msg->len);
169 mbox_chan_received_data(chan, (void *)msg);
170 status = IRQ_HANDLED;
171 }
172 }
173 }
174 return status;
175}
176
177/**
178 * zynqmp_ipi_peek_data - Peek to see if there are any rx messages.
179 *
180 * @chan: Channel Pointer
181 *
182 * Return: 'true' if there is pending rx data, 'false' if there is none.
183 */
184static bool zynqmp_ipi_peek_data(struct mbox_chan *chan)
185{
186 struct device *dev = chan->mbox->dev;
187 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
188 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
189 int ret;
190 u64 arg0;
191 struct arm_smccc_res res;
192
193 if (WARN_ON(!ipi_mbox)) {
194 dev_err(dev, "no platform drv data??\n");
195 return false;
196 }
197
198 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
199 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
200 ret = (int)(res.a0 & 0xFFFFFFFF);
201
202 if (mchan->chan_type == IPI_MB_CHNL_TX) {
203 /* TX channel, check if the message has been acked
204 * by the remote, if yes, response is available.
205 */
206 if (ret < 0 || ret & IPI_MB_STATUS_SEND_PENDING)
207 return false;
208 else
209 return true;
210 } else if (ret > 0 && ret & IPI_MB_STATUS_RECV_PENDING) {
211 /* RX channel, check if there is message arrived. */
212 return true;
213 }
214 return false;
215}
216
217/**
218 * zynqmp_ipi_last_tx_done - See if the last tx message is sent
219 *
220 * @chan: Channel pointer
221 *
222 * Return: 'true' is no pending tx data, 'false' if there are any.
223 */
224static bool zynqmp_ipi_last_tx_done(struct mbox_chan *chan)
225{
226 struct device *dev = chan->mbox->dev;
227 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
228 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
229 int ret;
230 u64 arg0;
231 struct arm_smccc_res res;
232
233 if (WARN_ON(!ipi_mbox)) {
234 dev_err(dev, "no platform drv data??\n");
235 return false;
236 }
237
238 if (mchan->chan_type == IPI_MB_CHNL_TX) {
239 /* We only need to check if the message been taken
240 * by the remote in the TX channel
241 */
242 arg0 = SMC_IPI_MAILBOX_STATUS_ENQUIRY;
243 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
244 /* Check the SMC call status, a0 of the result */
245 ret = (int)(res.a0 & 0xFFFFFFFF);
246 if (ret < 0 || ret & IPI_MB_STATUS_SEND_PENDING)
247 return false;
248 return true;
249 }
250 /* Always true for the response message in RX channel */
251 return true;
252}
253
254/**
255 * zynqmp_ipi_send_data - Send data
256 *
257 * @chan: Channel Pointer
258 * @data: Message Pointer
259 *
260 * Return: 0 if all goes good, else appropriate error messages.
261 */
262static int zynqmp_ipi_send_data(struct mbox_chan *chan, void *data)
263{
264 struct device *dev = chan->mbox->dev;
265 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
266 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
267 struct zynqmp_ipi_message *msg = data;
268 u64 arg0;
269 struct arm_smccc_res res;
270
271 if (WARN_ON(!ipi_mbox)) {
272 dev_err(dev, "no platform drv data??\n");
273 return -EINVAL;
274 }
275
276 if (mchan->chan_type == IPI_MB_CHNL_TX) {
277 /* Send request message */
278 if (msg && msg->len > mchan->req_buf_size) {
279 dev_err(dev, "channel %d message length %u > max %lu\n",
280 mchan->chan_type, (unsigned int)msg->len,
281 mchan->req_buf_size);
282 return -EINVAL;
283 }
284 if (msg && msg->len)
285 memcpy_toio(mchan->req_buf, msg->data, msg->len);
286 /* Kick IPI mailbox to send message */
287 arg0 = SMC_IPI_MAILBOX_NOTIFY;
288 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
289 } else {
290 /* Send response message */
291 if (msg && msg->len > mchan->resp_buf_size) {
292 dev_err(dev, "channel %d message length %u > max %lu\n",
293 mchan->chan_type, (unsigned int)msg->len,
294 mchan->resp_buf_size);
295 return -EINVAL;
296 }
297 if (msg && msg->len)
298 memcpy_toio(mchan->resp_buf, msg->data, msg->len);
299 arg0 = SMC_IPI_MAILBOX_ACK;
300 zynqmp_ipi_fw_call(ipi_mbox, arg0, IPI_SMC_ACK_EIRQ_MASK,
301 &res);
302 }
303 return 0;
304}
305
306/**
307 * zynqmp_ipi_startup - Startup the IPI channel
308 *
309 * @chan: Channel pointer
310 *
311 * Return: 0 if all goes good, else return corresponding error message
312 */
313static int zynqmp_ipi_startup(struct mbox_chan *chan)
314{
315 struct device *dev = chan->mbox->dev;
316 struct zynqmp_ipi_mbox *ipi_mbox = dev_get_drvdata(dev);
317 struct zynqmp_ipi_mchan *mchan = chan->con_priv;
318 u64 arg0;
319 struct arm_smccc_res res;
320 int ret = 0;
321 unsigned int nchan_type;
322
323 if (mchan->is_opened)
324 return 0;
325
326 /* If no channel has been opened, open the IPI mailbox */
327 nchan_type = (mchan->chan_type + 1) % 2;
328 if (!ipi_mbox->mchans[nchan_type].is_opened) {
329 arg0 = SMC_IPI_MAILBOX_OPEN;
330 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
331 /* Check the SMC call status, a0 of the result */
332 ret = (int)(res.a0 & 0xFFFFFFFF);
333 if (ret < 0) {
334 dev_err(dev, "SMC to open the IPI channel failed.\n");
335 return ret;
336 }
337 ret = 0;
338 }
339
340 /* If it is RX channel, enable the IPI notification interrupt */
341 if (mchan->chan_type == IPI_MB_CHNL_RX) {
342 arg0 = SMC_IPI_MAILBOX_ENABLE_IRQ;
343 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
344 }
345 mchan->is_opened = 1;
346
347 return ret;
348}
349
350/**
351 * zynqmp_ipi_shutdown - Shutdown the IPI channel
352 *
353 * @chan: Channel pointer
354 */
355static void zynqmp_ipi_shutdown(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 unsigned int chan_type;
363
364 if (!mchan->is_opened)
365 return;
366
367 /* If it is RX channel, disable notification interrupt */
368 chan_type = mchan->chan_type;
369 if (chan_type == IPI_MB_CHNL_RX) {
370 arg0 = SMC_IPI_MAILBOX_DISABLE_IRQ;
371 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
372 }
373 /* Release IPI mailbox if no other channel is opened */
374 chan_type = (chan_type + 1) % 2;
375 if (!ipi_mbox->mchans[chan_type].is_opened) {
376 arg0 = SMC_IPI_MAILBOX_RELEASE;
377 zynqmp_ipi_fw_call(ipi_mbox, arg0, 0, &res);
378 }
379
380 mchan->is_opened = 0;
381}
382
383/* ZynqMP IPI mailbox operations */
384static const struct mbox_chan_ops zynqmp_ipi_chan_ops = {
385 .startup = zynqmp_ipi_startup,
386 .shutdown = zynqmp_ipi_shutdown,
387 .peek_data = zynqmp_ipi_peek_data,
388 .last_tx_done = zynqmp_ipi_last_tx_done,
389 .send_data = zynqmp_ipi_send_data,
390};
391
392/**
393 * zynqmp_ipi_of_xlate - Translate of phandle to IPI mailbox channel
394 *
395 * @mbox: mailbox controller pointer
396 * @p: phandle pointer
397 *
398 * Return: Mailbox channel, else return error pointer.
399 */
400static struct mbox_chan *zynqmp_ipi_of_xlate(struct mbox_controller *mbox,
401 const struct of_phandle_args *p)
402{
403 struct mbox_chan *chan;
404 struct device *dev = mbox->dev;
405 unsigned int chan_type;
406
407 /* Only supports TX and RX channels */
408 chan_type = p->args[0];
409 if (chan_type != IPI_MB_CHNL_TX && chan_type != IPI_MB_CHNL_RX) {
410 dev_err(dev, "req chnl failure: invalid chnl type %u.\n",
411 chan_type);
412 return ERR_PTR(-EINVAL);
413 }
414 chan = &mbox->chans[chan_type];
415 return chan;
416}
417
418static const struct of_device_id zynqmp_ipi_of_match[] = {
419 { .compatible = "xlnx,zynqmp-ipi-mailbox" },
420 {},
421};
422MODULE_DEVICE_TABLE(of, zynqmp_ipi_of_match);
423
424/**
425 * zynqmp_ipi_mbox_get_buf_res - Get buffer resource from the IPI dev node
426 *
427 * @node: IPI mbox device child node
428 * @name: name of the IPI buffer
429 * @res: pointer to where the resource information will be stored.
430 *
431 * Return: 0 for success, negative value for failure
432 */
433static int zynqmp_ipi_mbox_get_buf_res(struct device_node *node,
434 const char *name,
435 struct resource *res)
436{
437 int ret, index;
438
439 index = of_property_match_string(node, "reg-names", name);
440 if (index >= 0) {
441 ret = of_address_to_resource(node, index, res);
442 if (ret < 0)
443 return -EINVAL;
444 return 0;
445 }
446 return -ENODEV;
447}
448
449/**
450 * zynqmp_ipi_mbox_dev_release() - release the existence of a ipi mbox dev
451 *
452 * @dev: the ipi mailbox device
453 *
454 * This is to avoid the no device release() function kernel warning.
455 *
456 */
457static void zynqmp_ipi_mbox_dev_release(struct device *dev)
458{
459 (void)dev;
460}
461
462/**
463 * zynqmp_ipi_mbox_probe - probe IPI mailbox resource from device node
464 *
465 * @ipi_mbox: pointer to IPI mailbox private data structure
466 * @node: IPI mailbox device node
467 *
468 * Return: 0 for success, negative value for failure
469 */
470static int zynqmp_ipi_mbox_probe(struct zynqmp_ipi_mbox *ipi_mbox,
471 struct device_node *node)
472{
473 struct zynqmp_ipi_mchan *mchan;
474 struct mbox_chan *chans;
475 struct mbox_controller *mbox;
476 struct resource res;
477 struct device *dev, *mdev;
478 const char *name;
479 int ret;
480
481 dev = ipi_mbox->pdata->dev;
482 /* Initialize dev for IPI mailbox */
483 ipi_mbox->dev.parent = dev;
484 ipi_mbox->dev.release = NULL;
485 ipi_mbox->dev.of_node = node;
486 dev_set_name(&ipi_mbox->dev, "%s", of_node_full_name(node));
487 dev_set_drvdata(&ipi_mbox->dev, ipi_mbox);
488 ipi_mbox->dev.release = zynqmp_ipi_mbox_dev_release;
489 ipi_mbox->dev.driver = &zynqmp_ipi_mbox_driver;
490 ret = device_register(&ipi_mbox->dev);
491 if (ret) {
492 dev_err(dev, "Failed to register ipi mbox dev.\n");
493 put_device(&ipi_mbox->dev);
494 return ret;
495 }
496 mdev = &ipi_mbox->dev;
497
498 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_TX];
499 name = "local_request_region";
500 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
501 if (!ret) {
502 mchan->req_buf_size = resource_size(&res);
503 mchan->req_buf = devm_ioremap(mdev, res.start,
504 mchan->req_buf_size);
505 if (!mchan->req_buf) {
506 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
507 return -ENOMEM;
508 }
509 } else if (ret != -ENODEV) {
510 dev_err(mdev, "Unmatched resource %s, %d.\n", name, ret);
511 return ret;
512 }
513
514 name = "remote_response_region";
515 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
516 if (!ret) {
517 mchan->resp_buf_size = resource_size(&res);
518 mchan->resp_buf = devm_ioremap(mdev, res.start,
519 mchan->resp_buf_size);
520 if (!mchan->resp_buf) {
521 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
522 return -ENOMEM;
523 }
524 } else if (ret != -ENODEV) {
525 dev_err(mdev, "Unmatched resource %s.\n", name);
526 return ret;
527 }
528 mchan->rx_buf = devm_kzalloc(mdev,
529 mchan->resp_buf_size +
530 sizeof(struct zynqmp_ipi_message),
531 GFP_KERNEL);
532 if (!mchan->rx_buf)
533 return -ENOMEM;
534
535 mchan = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
536 name = "remote_request_region";
537 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
538 if (!ret) {
539 mchan->req_buf_size = resource_size(&res);
540 mchan->req_buf = devm_ioremap(mdev, res.start,
541 mchan->req_buf_size);
542 if (!mchan->req_buf) {
543 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
544 return -ENOMEM;
545 }
546 } else if (ret != -ENODEV) {
547 dev_err(mdev, "Unmatched resource %s.\n", name);
548 return ret;
549 }
550
551 name = "local_response_region";
552 ret = zynqmp_ipi_mbox_get_buf_res(node, name, &res);
553 if (!ret) {
554 mchan->resp_buf_size = resource_size(&res);
555 mchan->resp_buf = devm_ioremap(mdev, res.start,
556 mchan->resp_buf_size);
557 if (!mchan->resp_buf) {
558 dev_err(mdev, "Unable to map IPI buffer I/O memory\n");
559 return -ENOMEM;
560 }
561 } else if (ret != -ENODEV) {
562 dev_err(mdev, "Unmatched resource %s.\n", name);
563 return ret;
564 }
565 mchan->rx_buf = devm_kzalloc(mdev,
566 mchan->resp_buf_size +
567 sizeof(struct zynqmp_ipi_message),
568 GFP_KERNEL);
569 if (!mchan->rx_buf)
570 return -ENOMEM;
571
572 /* Get the IPI remote agent ID */
573 ret = of_property_read_u32(node, "xlnx,ipi-id", &ipi_mbox->remote_id);
574 if (ret < 0) {
575 dev_err(dev, "No IPI remote ID is specified.\n");
576 return ret;
577 }
578
579 mbox = &ipi_mbox->mbox;
580 mbox->dev = mdev;
581 mbox->ops = &zynqmp_ipi_chan_ops;
582 mbox->num_chans = 2;
583 mbox->txdone_irq = false;
584 mbox->txdone_poll = true;
585 mbox->txpoll_period = 5;
586 mbox->of_xlate = zynqmp_ipi_of_xlate;
587 chans = devm_kzalloc(mdev, 2 * sizeof(*chans), GFP_KERNEL);
588 if (!chans)
589 return -ENOMEM;
590 mbox->chans = chans;
591 chans[IPI_MB_CHNL_TX].con_priv = &ipi_mbox->mchans[IPI_MB_CHNL_TX];
592 chans[IPI_MB_CHNL_RX].con_priv = &ipi_mbox->mchans[IPI_MB_CHNL_RX];
593 ipi_mbox->mchans[IPI_MB_CHNL_TX].chan_type = IPI_MB_CHNL_TX;
594 ipi_mbox->mchans[IPI_MB_CHNL_RX].chan_type = IPI_MB_CHNL_RX;
595 ret = devm_mbox_controller_register(mdev, mbox);
596 if (ret)
597 dev_err(mdev,
598 "Failed to register mbox_controller(%d)\n", ret);
599 else
600 dev_info(mdev,
601 "Registered ZynqMP IPI mbox with TX/RX channels.\n");
602 return ret;
603}
604
605/**
606 * zynqmp_ipi_free_mboxes - Free IPI mailboxes devices
607 *
608 * @pdata: IPI private data
609 */
610static void zynqmp_ipi_free_mboxes(struct zynqmp_ipi_pdata *pdata)
611{
612 struct zynqmp_ipi_mbox *ipi_mbox;
613 int i;
614
615 i = pdata->num_mboxes;
616 for (; i >= 0; i--) {
617 ipi_mbox = &pdata->ipi_mboxes[i];
618 if (ipi_mbox->dev.parent) {
619 mbox_controller_unregister(&ipi_mbox->mbox);
620 if (device_is_registered(&ipi_mbox->dev))
621 device_unregister(&ipi_mbox->dev);
622 }
623 }
624}
625
626static int zynqmp_ipi_probe(struct platform_device *pdev)
627{
628 struct device *dev = &pdev->dev;
629 struct device_node *nc, *np = pdev->dev.of_node;
630 struct zynqmp_ipi_pdata *pdata;
631 struct zynqmp_ipi_mbox *mbox;
632 int num_mboxes, ret = -EINVAL;
633
634 num_mboxes = of_get_available_child_count(np);
635 if (num_mboxes == 0) {
636 dev_err(dev, "mailbox nodes not available\n");
637 return -EINVAL;
638 }
639
640 pdata = devm_kzalloc(dev, struct_size(pdata, ipi_mboxes, num_mboxes),
641 GFP_KERNEL);
642 if (!pdata)
643 return -ENOMEM;
644 pdata->dev = dev;
645
646 /* Get the IPI local agents ID */
647 ret = of_property_read_u32(np, "xlnx,ipi-id", &pdata->local_id);
648 if (ret < 0) {
649 dev_err(dev, "No IPI local ID is specified.\n");
650 return ret;
651 }
652
653 pdata->num_mboxes = num_mboxes;
654
655 mbox = pdata->ipi_mboxes;
656 for_each_available_child_of_node(np, nc) {
657 mbox->pdata = pdata;
658 ret = zynqmp_ipi_mbox_probe(mbox, nc);
659 if (ret) {
660 of_node_put(nc);
661 dev_err(dev, "failed to probe subdev.\n");
662 ret = -EINVAL;
663 goto free_mbox_dev;
664 }
665 mbox++;
666 }
667
668 /* IPI IRQ */
669 ret = platform_get_irq(pdev, 0);
670 if (ret < 0)
671 goto free_mbox_dev;
672
673 pdata->irq = ret;
674 ret = devm_request_irq(dev, pdata->irq, zynqmp_ipi_interrupt,
675 IRQF_SHARED, dev_name(dev), pdata);
676 if (ret) {
677 dev_err(dev, "IRQ %d is not requested successfully.\n",
678 pdata->irq);
679 goto free_mbox_dev;
680 }
681
682 platform_set_drvdata(pdev, pdata);
683 return ret;
684
685free_mbox_dev:
686 zynqmp_ipi_free_mboxes(pdata);
687 return ret;
688}
689
690static void zynqmp_ipi_remove(struct platform_device *pdev)
691{
692 struct zynqmp_ipi_pdata *pdata;
693
694 pdata = platform_get_drvdata(pdev);
695 zynqmp_ipi_free_mboxes(pdata);
696}
697
698static struct platform_driver zynqmp_ipi_driver = {
699 .probe = zynqmp_ipi_probe,
700 .remove_new = zynqmp_ipi_remove,
701 .driver = {
702 .name = "zynqmp-ipi",
703 .of_match_table = of_match_ptr(zynqmp_ipi_of_match),
704 },
705};
706
707static int __init zynqmp_ipi_init(void)
708{
709 return platform_driver_register(&zynqmp_ipi_driver);
710}
711subsys_initcall(zynqmp_ipi_init);
712
713static void __exit zynqmp_ipi_exit(void)
714{
715 platform_driver_unregister(&zynqmp_ipi_driver);
716}
717module_exit(zynqmp_ipi_exit);
718
719MODULE_LICENSE("GPL v2");
720MODULE_DESCRIPTION("Xilinx ZynqMP IPI Mailbox driver");
721MODULE_AUTHOR("Xilinx Inc.");