drivers/event/octeontx/ssovf_probe.c

   1 /*
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (C) Cavium networks Ltd. 2017.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of Cavium networks nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <rte_atomic.h>
  34 #include <rte_common.h>
  35 #include <rte_eal.h>
  36 #include <rte_io.h>
  37 #include <rte_pci.h>
  38
  39 #include "ssovf_evdev.h"
  40
  41 struct ssovf_res {
  42         uint16_t domain;
  43         uint16_t vfid;
  44         void *bar0;
  45         void *bar2;
  46 };
  47
  48 struct ssowvf_res {
  49         uint16_t domain;
  50         uint16_t vfid;
  51         void *bar0;
  52         void *bar2;
  53         void *bar4;
  54 };
  55
  56 struct ssowvf_identify {
  57         uint16_t domain;
  58         uint16_t vfid;
  59 };
  60
  61 struct ssodev {
  62         uint8_t total_ssovfs;
  63         uint8_t total_ssowvfs;
  64         struct ssovf_res grp[SSO_MAX_VHGRP];
  65         struct ssowvf_res hws[SSO_MAX_VHWS];
  66 };
  67
  68 static struct ssodev sdev;
  69
  70 /* SSOWVF pcie device aka event port probe */
  71
  72 static int
  73 ssowvf_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
  74 {
  75         uint16_t vfid;
  76         struct ssowvf_res *res;
  77         struct ssowvf_identify *id;
  78
  79         RTE_SET_USED(pci_drv);
  80
  81         /* For secondary processes, the primary has done all the work */
  82         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
  83                 return 0;
  84
  85         if (pci_dev->mem_resource[0].addr == NULL ||
  86                         pci_dev->mem_resource[2].addr == NULL ||
  87                         pci_dev->mem_resource[4].addr == NULL) {
  88                 ssovf_log_err("Empty bars %p %p %p",
  89                                 pci_dev->mem_resource[0].addr,
  90                                 pci_dev->mem_resource[2].addr,
  91                                 pci_dev->mem_resource[4].addr);
  92                 return -ENODEV;
  93         }
  94
  95         if (pci_dev->mem_resource[4].len != SSOW_BAR4_LEN) {
  96                 ssovf_log_err("Bar4 len mismatch %d != %d",
  97                         SSOW_BAR4_LEN, (int)pci_dev->mem_resource[4].len);
  98                 return -EINVAL;
  99         }
 100
 101         id = pci_dev->mem_resource[4].addr;
 102         vfid = id->vfid;
 103         if (vfid >= SSO_MAX_VHWS) {
 104                 ssovf_log_err("Invalid vfid(%d/%d)", vfid, SSO_MAX_VHWS);
 105                 return -EINVAL;
 106         }
 107
 108         res = &sdev.hws[vfid];
 109         res->vfid = vfid;
 110         res->bar0 = pci_dev->mem_resource[0].addr;
 111         res->bar2 = pci_dev->mem_resource[2].addr;
 112         res->bar4 = pci_dev->mem_resource[4].addr;
 113         res->domain = id->domain;
 114
 115         sdev.total_ssowvfs++;
 116         rte_wmb();
 117         ssovf_log_dbg("Domain=%d hws=%d total_ssowvfs=%d", res->domain,
 118                         res->vfid, sdev.total_ssowvfs);
 119         return 0;
 120 }
 121
 122 static const struct rte_pci_id pci_ssowvf_map[] = {
 123         {
 124                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
 125                                 PCI_DEVICE_ID_OCTEONTX_SSOWS_VF)
 126         },
 127         {
 128                 .vendor_id = 0,
 129         },
 130 };
 131
 132 static struct rte_pci_driver pci_ssowvf = {
 133         .id_table = pci_ssowvf_map,
 134         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 135         .probe = ssowvf_probe,
 136 };
 137
 138 RTE_PMD_REGISTER_PCI(octeontx_ssowvf, pci_ssowvf);
 139
 140 /* SSOVF pcie device aka event queue probe */
 141
 142 static int
 143 ssovf_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
 144 {
 145         uint64_t val;
 146         uint16_t vfid;
 147         uint8_t *idreg;
 148         struct ssovf_res *res;
 149
 150         RTE_SET_USED(pci_drv);
 151
 152         /* For secondary processes, the primary has done all the work */
 153         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 154                 return 0;
 155
 156         if (pci_dev->mem_resource[0].addr == NULL ||
 157                         pci_dev->mem_resource[2].addr == NULL) {
 158                 ssovf_log_err("Empty bars %p %p",
 159                         pci_dev->mem_resource[0].addr,
 160                         pci_dev->mem_resource[2].addr);
 161                 return -ENODEV;
 162         }
 163         idreg = pci_dev->mem_resource[0].addr;
 164         idreg += SSO_VHGRP_AQ_THR;
 165         val = rte_read64(idreg);
 166
 167         /* Write back the default value of aq_thr */
 168         rte_write64((1ULL << 33) - 1, idreg);
 169         vfid = (val >> 16) & 0xffff;
 170         if (vfid >= SSO_MAX_VHGRP) {
 171                 ssovf_log_err("Invalid vfid (%d/%d)", vfid, SSO_MAX_VHGRP);
 172                 return -EINVAL;
 173         }
 174
 175         res = &sdev.grp[vfid];
 176         res->vfid = vfid;
 177         res->bar0 = pci_dev->mem_resource[0].addr;
 178         res->bar2 = pci_dev->mem_resource[2].addr;
 179         res->domain = val & 0xffff;
 180
 181         sdev.total_ssovfs++;
 182         rte_wmb();
 183         ssovf_log_dbg("Domain=%d group=%d total_ssovfs=%d", res->domain,
 184                         res->vfid, sdev.total_ssovfs);
 185         return 0;
 186 }
 187
 188 static const struct rte_pci_id pci_ssovf_map[] = {
 189         {
 190                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
 191                                 PCI_DEVICE_ID_OCTEONTX_SSOGRP_VF)
 192         },
 193         {
 194                 .vendor_id = 0,
 195         },
 196 };
 197
 198 static struct rte_pci_driver pci_ssovf = {
 199         .id_table = pci_ssovf_map,
 200         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 201         .probe = ssovf_probe,
 202 };
 203
 204 RTE_PMD_REGISTER_PCI(octeontx_ssovf, pci_ssovf);