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."); 722