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