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 */ 71 static int tx_poll_period = 5; 72 module_param_named(tx_poll_period, tx_poll_period, int, 0644); 73 MODULE_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 */ 85 struct 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 95 struct zynqmp_ipi_mbox; 96 97 typedef 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 */ 110 struct 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 */ 132 struct 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 143 static DEFINE_PER_CPU(struct zynqmp_ipi_pdata *, per_cpu_pdata); 144 145 static struct device_driver zynqmp_ipi_mbox_driver = { 146 .owner = THIS_MODULE, 147 .name = "zynqmp-ipi-mbox", 148 }; 149 150 static 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 */ 175 static 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, arg0, arg3, &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, (void *)msg); 204 status = IRQ_HANDLED; 205 } 206 } 207 } 208 return status; 209 } 210 211 static 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, 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 */ 226 static 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, arg0, 0, &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 */ 266 static 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, arg0, 0, &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 */ 304 static 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, arg0, 0, &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, arg0, IPI_SMC_ACK_EIRQ_MASK, 343 &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 */ 355 static 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, arg0, 0, &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, arg0, 0, &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 */ 397 static 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, arg0, 0, &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, arg0, 0, &res); 420 } 421 422 mchan->is_opened = 0; 423 } 424 425 /* ZynqMP IPI mailbox operations */ 426 static 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 */ 442 static 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(-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 */ 469 static 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(node, "reg-names", name); 476 if (index >= 0) { 477 ret = of_address_to_resource(node, index, 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 */ 493 static 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 */ 506 static 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(&ipi_mbox->dev, "%s", of_node_full_name(node)); 520 dev_set_drvdata(&ipi_mbox->dev, 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(&ipi_mbox->dev); 524 if (ret) { 525 dev_err(dev, "Failed to register ipi mbox dev.\n"); 526 put_device(&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(node, "xlnx,ipi-id", &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(mdev, 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(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 */ 587 static 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); 601 if (!ret) { 602 mchan->req_buf_size = resource_size(&res); 603 mchan->req_buf = devm_ioremap(mdev, res.start, 604 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); 616 if (!ret) { 617 mchan->resp_buf_size = resource_size(&res); 618 mchan->resp_buf = devm_ioremap(mdev, res.start, 619 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(mdev, 629 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); 638 if (!ret) { 639 mchan->req_buf_size = resource_size(&res); 640 mchan->req_buf = devm_ioremap(mdev, res.start, 641 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); 653 if (!ret) { 654 mchan->resp_buf_size = resource_size(&res); 655 mchan->resp_buf = devm_ioremap(mdev, res.start, 656 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(mdev, 666 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 */ 684 static 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(parent_node, "msg", &host_res); 699 remote_idx = zynqmp_ipi_mbox_get_buf_res(node, "msg", &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(&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(mdev, 727 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(mdev, 735 (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(mdev, 743 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(mdev, 751 (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(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(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 778 static 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(pdata->virq_sgi, IRQ_TYPE_NONE); 785 786 return 0; 787 } 788 789 static 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(pdata->virq_sgi); 796 797 return 0; 798 } 799 800 static 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(pdata->virq_sgi); 807 } 808 809 static 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(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(interrupt_parent); 837 of_node_put(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(&sgi_fwspec); 851 852 for_each_possible_cpu(cpu) 853 per_cpu(per_cpu_pdata, cpu) = pdata; 854 855 ret = request_percpu_irq(pdata->virq_sgi, zynqmp_sgi_interrupt, pdev->name, 856 &per_cpu_pdata); 857 WARN_ON(ret); 858 if (ret) { 859 irq_dispose_mapping(pdata->virq_sgi); 860 return ret; 861 } 862 863 irq_set_status_flags(pdata->virq_sgi, IRQ_PER_CPU); 864 865 /* Setup function for the CPU hot-plug cases */ 866 cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "mailbox/sgi:starting", 867 xlnx_mbox_cpuhp_start, xlnx_mbox_cpuhp_down); 868 869 return ret; 870 } 871 872 static void xlnx_mbox_cleanup_sgi(struct zynqmp_ipi_pdata *pdata) 873 { 874 cpuhp_remove_state(CPUHP_AP_ONLINE_DYN); 875 876 on_each_cpu(xlnx_disable_percpu_irq, NULL, 1); 877 878 irq_clear_status_flags(pdata->virq_sgi, IRQ_PER_CPU); 879 free_percpu_irq(pdata->virq_sgi, &per_cpu_pdata); 880 irq_dispose_mapping(pdata->virq_sgi); 881 } 882 883 /** 884 * zynqmp_ipi_free_mboxes - Free IPI mailboxes devices 885 * 886 * @pdata: IPI private data 887 */ 888 static 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(&ipi_mbox->dev)) 900 device_unregister(&ipi_mbox->dev); 901 } 902 } 903 904 static 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, "xlnx,ipi-id", &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(&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(mbox, nc); 948 if (ret) { 949 of_node_put(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(dev_of_node(dev), 0, &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, 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, pdata->irq, zynqmp_ipi_interrupt, 982 IRQF_SHARED, dev_name(dev), 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, pdata); 992 return ret; 993 994 free_mbox_dev: 995 zynqmp_ipi_free_mboxes(pdata); 996 return ret; 997 } 998 999 static 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 1007 static 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 }; 1016 MODULE_DEVICE_TABLE(of, zynqmp_ipi_of_match); 1017 1018 static 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 1027 static int __init zynqmp_ipi_init(void) 1028 { 1029 return platform_driver_register(&zynqmp_ipi_driver); 1030 } 1031 subsys_initcall(zynqmp_ipi_init); 1032 1033 static void __exit zynqmp_ipi_exit(void) 1034 { 1035 platform_driver_unregister(&zynqmp_ipi_driver); 1036 } 1037 module_exit(zynqmp_ipi_exit); 1038 1039 MODULE_LICENSE("GPL v2"); 1040 MODULE_DESCRIPTION("Xilinx ZynqMP IPI Mailbox driver"); 1041 MODULE_AUTHOR("Xilinx Inc."); 1042