drivers/event/octeontx2/otx2_evdev_irq.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include "otx2_evdev.h"
   6
   7 static void
   8 sso_lf_irq(void *param)
   9 {
  10         uintptr_t base = (uintptr_t)param;
  11         uint64_t intr;
  12         uint8_t ggrp;
  13
  14         ggrp = (base >> 12) & 0xFF;
  15
  16         intr = otx2_read64(base + SSO_LF_GGRP_INT);
  17         if (intr == 0)
  18                 return;
  19
  20         otx2_err("GGRP %d GGRP_INT=0x%" PRIx64 "", ggrp, intr);
  21
  22         /* Clear interrupt */
  23         otx2_write64(intr, base + SSO_LF_GGRP_INT);
  24 }
  25
  26 static int
  27 sso_lf_register_irq(const struct rte_eventdev *event_dev, uint16_t ggrp_msixoff,
  28                     uintptr_t base)
  29 {
  30         struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(event_dev->dev);
  31         struct rte_intr_handle *handle = &pci_dev->intr_handle;
  32         int rc, vec;
  33
  34         vec = ggrp_msixoff + SSO_LF_INT_VEC_GRP;
  35
  36         /* Clear err interrupt */
  37         otx2_write64(~0ull, base + SSO_LF_GGRP_INT_ENA_W1C);
  38         /* Set used interrupt vectors */
  39         rc = otx2_register_irq(handle, sso_lf_irq, (void *)base, vec);
  40         /* Enable hw interrupt */
  41         otx2_write64(~0ull, base + SSO_LF_GGRP_INT_ENA_W1S);
  42
  43         return rc;
  44 }
  45
  46 static void
  47 ssow_lf_irq(void *param)
  48 {
  49         uintptr_t base = (uintptr_t)param;
  50         uint8_t gws = (base >> 12) & 0xFF;
  51         uint64_t intr;
  52
  53         intr = otx2_read64(base + SSOW_LF_GWS_INT);
  54         if (intr == 0)
  55                 return;
  56
  57         otx2_err("GWS %d GWS_INT=0x%" PRIx64 "", gws, intr);
  58
  59         /* Clear interrupt */
  60         otx2_write64(intr, base + SSOW_LF_GWS_INT);
  61 }
  62
  63 static int
  64 ssow_lf_register_irq(const struct rte_eventdev *event_dev, uint16_t gws_msixoff,
  65                      uintptr_t base)
  66 {
  67         struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(event_dev->dev);
  68         struct rte_intr_handle *handle = &pci_dev->intr_handle;
  69         int rc, vec;
  70
  71         vec = gws_msixoff + SSOW_LF_INT_VEC_IOP;
  72
  73         /* Clear err interrupt */
  74         otx2_write64(~0ull, base + SSOW_LF_GWS_INT_ENA_W1C);
  75         /* Set used interrupt vectors */
  76         rc = otx2_register_irq(handle, ssow_lf_irq, (void *)base, vec);
  77         /* Enable hw interrupt */
  78         otx2_write64(~0ull, base + SSOW_LF_GWS_INT_ENA_W1S);
  79
  80         return rc;
  81 }
  82
  83 static void
  84 sso_lf_unregister_irq(const struct rte_eventdev *event_dev,
  85                       uint16_t ggrp_msixoff, uintptr_t base)
  86 {
  87         struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(event_dev->dev);
  88         struct rte_intr_handle *handle = &pci_dev->intr_handle;
  89         int vec;
  90
  91         vec = ggrp_msixoff + SSO_LF_INT_VEC_GRP;
  92
  93         /* Clear err interrupt */
  94         otx2_write64(~0ull, base + SSO_LF_GGRP_INT_ENA_W1C);
  95         otx2_unregister_irq(handle, sso_lf_irq, (void *)base, vec);
  96 }
  97
  98 static void
  99 ssow_lf_unregister_irq(const struct rte_eventdev *event_dev,
 100                        uint16_t gws_msixoff, uintptr_t base)
 101 {
 102         struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(event_dev->dev);
 103         struct rte_intr_handle *handle = &pci_dev->intr_handle;
 104         int vec;
 105
 106         vec = gws_msixoff + SSOW_LF_INT_VEC_IOP;
 107
 108         /* Clear err interrupt */
 109         otx2_write64(~0ull, base + SSOW_LF_GWS_INT_ENA_W1C);
 110         otx2_unregister_irq(handle, ssow_lf_irq, (void *)base, vec);
 111 }
 112
 113 int
 114 sso_register_irqs(const struct rte_eventdev *event_dev)
 115 {
 116         struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
 117         int i, rc = -EINVAL;
 118         uint8_t nb_ports;
 119
 120         nb_ports = dev->nb_event_ports;
 121
 122         for (i = 0; i < dev->nb_event_queues; i++) {
 123                 if (dev->sso_msixoff[i] == MSIX_VECTOR_INVALID) {
 124                         otx2_err("Invalid SSOLF MSIX offset[%d] vector: 0x%x",
 125                                  i, dev->sso_msixoff[i]);
 126                         goto fail;
 127                 }
 128         }
 129
 130         for (i = 0; i < nb_ports; i++) {
 131                 if (dev->ssow_msixoff[i] == MSIX_VECTOR_INVALID) {
 132                         otx2_err("Invalid SSOWLF MSIX offset[%d] vector: 0x%x",
 133                                  i, dev->ssow_msixoff[i]);
 134                         goto fail;
 135                 }
 136         }
 137
 138         for (i = 0; i < dev->nb_event_queues; i++) {
 139                 uintptr_t base = dev->bar2 + (RVU_BLOCK_ADDR_SSO << 20 |
 140                                               i << 12);
 141                 rc = sso_lf_register_irq(event_dev, dev->sso_msixoff[i], base);
 142         }
 143
 144         for (i = 0; i < nb_ports; i++) {
 145                 uintptr_t base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 |
 146                                               i << 12);
 147                 rc = ssow_lf_register_irq(event_dev, dev->ssow_msixoff[i],
 148                                           base);
 149         }
 150
 151 fail:
 152         return rc;
 153 }
 154
 155 void
 156 sso_unregister_irqs(const struct rte_eventdev *event_dev)
 157 {
 158         struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
 159         uint8_t nb_ports;
 160         int i;
 161
 162         nb_ports = dev->nb_event_ports;
 163
 164         for (i = 0; i < dev->nb_event_queues; i++) {
 165                 uintptr_t base = dev->bar2 + (RVU_BLOCK_ADDR_SSO << 20 |
 166                                               i << 12);
 167                 sso_lf_unregister_irq(event_dev, dev->sso_msixoff[i], base);
 168         }
 169
 170         for (i = 0; i < nb_ports; i++) {
 171                 uintptr_t base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 |
 172                                               i << 12);
 173                 ssow_lf_unregister_irq(event_dev, dev->ssow_msixoff[i], base);
 174         }
 175 }