drivers/mempool/octeontx/octeontx_ssovf.c

   1 /*
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (C) Cavium, Inc. 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, Inc 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 "octeontx_mbox.h"
  40 #include "octeontx_pool_logs.h"
  41
  42 #define PCI_VENDOR_ID_CAVIUM              0x177D
  43 #define PCI_DEVICE_ID_OCTEONTX_SSOGRP_VF  0xA04B
  44 #define PCI_DEVICE_ID_OCTEONTX_SSOWS_VF   0xA04D
  45
  46 #define SSO_MAX_VHGRP                     (64)
  47 #define SSO_MAX_VHWS                      (32)
  48
  49 #define SSO_VHGRP_AQ_THR                  (0x1E0ULL)
  50
  51 struct ssovf_res {
  52         uint16_t domain;
  53         uint16_t vfid;
  54         void *bar0;
  55         void *bar2;
  56 };
  57
  58 struct ssowvf_res {
  59         uint16_t domain;
  60         uint16_t vfid;
  61         void *bar0;
  62         void *bar2;
  63         void *bar4;
  64 };
  65
  66 struct ssowvf_identify {
  67         uint16_t domain;
  68         uint16_t vfid;
  69 };
  70
  71 struct ssodev {
  72         uint8_t total_ssovfs;
  73         uint8_t total_ssowvfs;
  74         struct ssovf_res grp[SSO_MAX_VHGRP];
  75         struct ssowvf_res hws[SSO_MAX_VHWS];
  76 };
  77
  78 static struct ssodev sdev;
  79
  80 /* Interface functions */
  81 int
  82 octeontx_ssovf_info(struct octeontx_ssovf_info *info)
  83 {
  84         uint8_t i;
  85         uint16_t domain;
  86
  87         if (rte_eal_process_type() != RTE_PROC_PRIMARY || info == NULL)
  88                 return -EINVAL;
  89
  90         if (sdev.total_ssovfs == 0 || sdev.total_ssowvfs == 0)
  91                 return -ENODEV;
  92
  93         domain = sdev.grp[0].domain;
  94         for (i = 0; i < sdev.total_ssovfs; i++) {
  95                 /* Check vfid's are contiguous and belong to same domain */
  96                 if (sdev.grp[i].vfid != i ||
  97                         sdev.grp[i].bar0 == NULL ||
  98                         sdev.grp[i].domain != domain) {
  99                         mbox_log_err("GRP error, vfid=%d/%d domain=%d/%d %p",
 100                                 i, sdev.grp[i].vfid,
 101                                 domain, sdev.grp[i].domain,
 102                                 sdev.grp[i].bar0);
 103                         return -EINVAL;
 104                 }
 105         }
 106
 107         for (i = 0; i < sdev.total_ssowvfs; i++) {
 108                 /* Check vfid's are contiguous and belong to same domain */
 109                 if (sdev.hws[i].vfid != i ||
 110                         sdev.hws[i].bar0 == NULL ||
 111                         sdev.hws[i].domain != domain) {
 112                         mbox_log_err("HWS error, vfid=%d/%d domain=%d/%d %p",
 113                                 i, sdev.hws[i].vfid,
 114                                 domain, sdev.hws[i].domain,
 115                                 sdev.hws[i].bar0);
 116                         return -EINVAL;
 117                 }
 118         }
 119
 120         info->domain = domain;
 121         info->total_ssovfs = sdev.total_ssovfs;
 122         info->total_ssowvfs = sdev.total_ssowvfs;
 123         return 0;
 124 }
 125
 126 void*
 127 octeontx_ssovf_bar(enum octeontx_ssovf_type type, uint8_t id, uint8_t bar)
 128 {
 129         if (rte_eal_process_type() != RTE_PROC_PRIMARY ||
 130                         type > OCTEONTX_SSO_HWS)
 131                 return NULL;
 132
 133         if (type == OCTEONTX_SSO_GROUP) {
 134                 if (id >= sdev.total_ssovfs)
 135                         return NULL;
 136         } else {
 137                 if (id >= sdev.total_ssowvfs)
 138                         return NULL;
 139         }
 140
 141         if (type == OCTEONTX_SSO_GROUP) {
 142                 switch (bar) {
 143                 case 0:
 144                         return sdev.grp[id].bar0;
 145                 case 2:
 146                         return sdev.grp[id].bar2;
 147                 default:
 148                         return NULL;
 149                 }
 150         } else {
 151                 switch (bar) {
 152                 case 0:
 153                         return sdev.hws[id].bar0;
 154                 case 2:
 155                         return sdev.hws[id].bar2;
 156                 case 4:
 157                         return sdev.hws[id].bar4;
 158                 default:
 159                         return NULL;
 160                 }
 161         }
 162 }
 163
 164 /* SSOWVF pcie device aka event port probe */
 165
 166 static int
 167 ssowvf_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
 168 {
 169         uint16_t vfid;
 170         struct ssowvf_res *res;
 171         struct ssowvf_identify *id;
 172
 173         RTE_SET_USED(pci_drv);
 174
 175         /* For secondary processes, the primary has done all the work */
 176         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 177                 return 0;
 178
 179         if (pci_dev->mem_resource[0].addr == NULL ||
 180                         pci_dev->mem_resource[2].addr == NULL ||
 181                         pci_dev->mem_resource[4].addr == NULL) {
 182                 mbox_log_err("Empty bars %p %p %p",
 183                                 pci_dev->mem_resource[0].addr,
 184                                 pci_dev->mem_resource[2].addr,
 185                                 pci_dev->mem_resource[4].addr);
 186                 return -ENODEV;
 187         }
 188
 189         if (pci_dev->mem_resource[4].len != SSOW_BAR4_LEN) {
 190                 mbox_log_err("Bar4 len mismatch %d != %d",
 191                         SSOW_BAR4_LEN, (int)pci_dev->mem_resource[4].len);
 192                 return -EINVAL;
 193         }
 194
 195         id = pci_dev->mem_resource[4].addr;
 196         vfid = id->vfid;
 197         if (vfid >= SSO_MAX_VHWS) {
 198                 mbox_log_err("Invalid vfid(%d/%d)", vfid, SSO_MAX_VHWS);
 199                 return -EINVAL;
 200         }
 201
 202         res = &sdev.hws[vfid];
 203         res->vfid = vfid;
 204         res->bar0 = pci_dev->mem_resource[0].addr;
 205         res->bar2 = pci_dev->mem_resource[2].addr;
 206         res->bar4 = pci_dev->mem_resource[4].addr;
 207         res->domain = id->domain;
 208
 209         sdev.total_ssowvfs++;
 210         rte_wmb();
 211         mbox_log_dbg("Domain=%d hws=%d total_ssowvfs=%d", res->domain,
 212                         res->vfid, sdev.total_ssowvfs);
 213         return 0;
 214 }
 215
 216 static const struct rte_pci_id pci_ssowvf_map[] = {
 217         {
 218                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
 219                                 PCI_DEVICE_ID_OCTEONTX_SSOWS_VF)
 220         },
 221         {
 222                 .vendor_id = 0,
 223         },
 224 };
 225
 226 static struct rte_pci_driver pci_ssowvf = {
 227         .id_table = pci_ssowvf_map,
 228         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 229         .probe = ssowvf_probe,
 230 };
 231
 232 RTE_PMD_REGISTER_PCI(octeontx_ssowvf, pci_ssowvf);
 233
 234 /* SSOVF pcie device aka event queue probe */
 235
 236 static int
 237 ssovf_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
 238 {
 239         uint64_t val;
 240         uint16_t vfid;
 241         uint8_t *idreg;
 242         struct ssovf_res *res;
 243
 244         RTE_SET_USED(pci_drv);
 245
 246         /* For secondary processes, the primary has done all the work */
 247         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 248                 return 0;
 249
 250         if (pci_dev->mem_resource[0].addr == NULL ||
 251                         pci_dev->mem_resource[2].addr == NULL) {
 252                 mbox_log_err("Empty bars %p %p",
 253                         pci_dev->mem_resource[0].addr,
 254                         pci_dev->mem_resource[2].addr);
 255                 return -ENODEV;
 256         }
 257         idreg = pci_dev->mem_resource[0].addr;
 258         idreg += SSO_VHGRP_AQ_THR;
 259         val = rte_read64(idreg);
 260
 261         /* Write back the default value of aq_thr */
 262         rte_write64((1ULL << 33) - 1, idreg);
 263         vfid = (val >> 16) & 0xffff;
 264         if (vfid >= SSO_MAX_VHGRP) {
 265                 mbox_log_err("Invalid vfid (%d/%d)", vfid, SSO_MAX_VHGRP);
 266                 return -EINVAL;
 267         }
 268
 269         res = &sdev.grp[vfid];
 270         res->vfid = vfid;
 271         res->bar0 = pci_dev->mem_resource[0].addr;
 272         res->bar2 = pci_dev->mem_resource[2].addr;
 273         res->domain = val & 0xffff;
 274
 275         sdev.total_ssovfs++;
 276         rte_wmb();
 277         mbox_log_dbg("Domain=%d group=%d total_ssovfs=%d", res->domain,
 278                         res->vfid, sdev.total_ssovfs);
 279         return 0;
 280 }
 281
 282 static const struct rte_pci_id pci_ssovf_map[] = {
 283         {
 284                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
 285                                 PCI_DEVICE_ID_OCTEONTX_SSOGRP_VF)
 286         },
 287         {
 288                 .vendor_id = 0,
 289         },
 290 };
 291
 292 static struct rte_pci_driver pci_ssovf = {
 293         .id_table = pci_ssovf_map,
 294         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 295         .probe = ssovf_probe,
 296 };
 297
 298 RTE_PMD_REGISTER_PCI(octeontx_ssovf, pci_ssovf);