drivers/common/cnxk/roc_bphy_irq.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4 #include <fcntl.h>
   5 #include <sys/ioctl.h>
   6 #include <unistd.h>
   7
   8 #include "roc_api.h"
   9 #include "roc_bphy_irq.h"
  10
  11 #define ROC_BPHY_MEMZONE_NAME "roc_bphy_mz"
  12 #define ROC_BPHY_CTR_DEV_PATH "/dev/otx-bphy-ctr"
  13
  14 #define ROC_BPHY_IOC_MAGIC 0xF3
  15 #define ROC_BPHY_IOC_GET_BPHY_MAX_IRQ   _IOR(ROC_BPHY_IOC_MAGIC, 3, uint64_t)
  16 #define ROC_BPHY_IOC_GET_BPHY_BMASK_IRQ _IOR(ROC_BPHY_IOC_MAGIC, 4, uint64_t)
  17
  18 struct roc_bphy_irq_chip *
  19 roc_bphy_intr_init(void)
  20 {
  21         struct roc_bphy_irq_chip *irq_chip;
  22         uint64_t max_irq, i, avail_irqs;
  23         int fd, ret;
  24
  25         fd = open(ROC_BPHY_CTR_DEV_PATH, O_RDWR | O_SYNC);
  26         if (fd < 0) {
  27                 plt_err("Failed to open %s", ROC_BPHY_CTR_DEV_PATH);
  28                 return NULL;
  29         }
  30
  31         ret = ioctl(fd, ROC_BPHY_IOC_GET_BPHY_MAX_IRQ, &max_irq);
  32         if (ret < 0) {
  33                 plt_err("Failed to get max irq number via ioctl");
  34                 goto err_ioctl;
  35         }
  36
  37         ret = ioctl(fd, ROC_BPHY_IOC_GET_BPHY_BMASK_IRQ, &avail_irqs);
  38         if (ret < 0) {
  39                 plt_err("Failed to get available irqs bitmask via ioctl");
  40                 goto err_ioctl;
  41         }
  42
  43         irq_chip = plt_zmalloc(sizeof(*irq_chip), 0);
  44         if (irq_chip == NULL) {
  45                 plt_err("Failed to alloc irq_chip");
  46                 goto err_alloc_chip;
  47         }
  48
  49         irq_chip->intfd = fd;
  50         irq_chip->max_irq = max_irq;
  51         irq_chip->avail_irq_bmask = avail_irqs;
  52         irq_chip->irq_vecs =
  53                 plt_zmalloc(irq_chip->max_irq * sizeof(*irq_chip->irq_vecs), 0);
  54         if (irq_chip->irq_vecs == NULL) {
  55                 plt_err("Failed to alloc irq_chip irq_vecs");
  56                 goto err_alloc_irq;
  57         }
  58
  59         irq_chip->mz_name = plt_zmalloc(strlen(ROC_BPHY_MEMZONE_NAME) + 1, 0);
  60         if (irq_chip->mz_name == NULL) {
  61                 plt_err("Failed to alloc irq_chip name");
  62                 goto err_alloc_name;
  63         }
  64         plt_strlcpy(irq_chip->mz_name, ROC_BPHY_MEMZONE_NAME,
  65                     strlen(ROC_BPHY_MEMZONE_NAME) + 1);
  66
  67         for (i = 0; i < irq_chip->max_irq; i++) {
  68                 irq_chip->irq_vecs[i].fd = -1;
  69                 irq_chip->irq_vecs[i].handler_cpu = -1;
  70         }
  71
  72         return irq_chip;
  73
  74 err_alloc_name:
  75         plt_free(irq_chip->irq_vecs);
  76
  77 err_alloc_irq:
  78         plt_free(irq_chip);
  79
  80 err_ioctl:
  81 err_alloc_chip:
  82         close(fd);
  83         return NULL;
  84 }
  85
  86 void
  87 roc_bphy_intr_fini(struct roc_bphy_irq_chip *irq_chip)
  88 {
  89         if (irq_chip == NULL)
  90                 return;
  91
  92         close(irq_chip->intfd);
  93         plt_free(irq_chip->mz_name);
  94         plt_free(irq_chip->irq_vecs);
  95         plt_free(irq_chip);
  96 }
  97
  98 bool
  99 roc_bphy_intr_available(struct roc_bphy_irq_chip *irq_chip, int irq_num)
 100 {
 101         if (irq_num < 0 || (uint64_t)irq_num >= irq_chip->max_irq)
 102                 return false;
 103
 104         return irq_chip->avail_irq_bmask & BIT(irq_num);
 105 }