drivers/mailbox/zynqmp-ipi-mailbox.c

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