drivers/raw/ioat/ioat_rawdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <rte_cycles.h>
   6 #include <rte_bus_pci.h>
   7 #include <rte_rawdev_pmd.h>
   8
   9 #include "rte_ioat_rawdev.h"
  10
  11 /* Dynamic log type identifier */
  12 int ioat_pmd_logtype;
  13
  14 static struct rte_pci_driver ioat_pmd_drv;
  15
  16 #define IOAT_VENDOR_ID          0x8086
  17 #define IOAT_DEVICE_ID_SKX      0x2021
  18 #define IOAT_DEVICE_ID_BDX0     0x6f20
  19 #define IOAT_DEVICE_ID_BDX1     0x6f21
  20 #define IOAT_DEVICE_ID_BDX2     0x6f22
  21 #define IOAT_DEVICE_ID_BDX3     0x6f23
  22 #define IOAT_DEVICE_ID_BDX4     0x6f24
  23 #define IOAT_DEVICE_ID_BDX5     0x6f25
  24 #define IOAT_DEVICE_ID_BDX6     0x6f26
  25 #define IOAT_DEVICE_ID_BDX7     0x6f27
  26 #define IOAT_DEVICE_ID_BDXE     0x6f2E
  27 #define IOAT_DEVICE_ID_BDXF     0x6f2F
  28
  29 #define IOAT_PMD_LOG(level, fmt, args...) rte_log(RTE_LOG_ ## level, \
  30         ioat_pmd_logtype, "%s(): " fmt "\n", __func__, ##args)
  31
  32 #define IOAT_PMD_DEBUG(fmt, args...)  IOAT_PMD_LOG(DEBUG, fmt, ## args)
  33 #define IOAT_PMD_INFO(fmt, args...)   IOAT_PMD_LOG(INFO, fmt, ## args)
  34 #define IOAT_PMD_ERR(fmt, args...)    IOAT_PMD_LOG(ERR, fmt, ## args)
  35 #define IOAT_PMD_WARN(fmt, args...)   IOAT_PMD_LOG(WARNING, fmt, ## args)
  36
  37 static void
  38 ioat_dev_info_get(struct rte_rawdev *dev, rte_rawdev_obj_t dev_info)
  39 {
  40         struct rte_ioat_rawdev_config *cfg = dev_info;
  41         struct rte_ioat_rawdev *ioat = dev->dev_private;
  42
  43         if (cfg != NULL)
  44                 cfg->ring_size = ioat->ring_size;
  45 }
  46
  47 static int
  48 ioat_rawdev_create(const char *name, struct rte_pci_device *dev)
  49 {
  50         static const struct rte_rawdev_ops ioat_rawdev_ops = {
  51                         .dev_info_get = ioat_dev_info_get,
  52         };
  53
  54         struct rte_rawdev *rawdev = NULL;
  55         struct rte_ioat_rawdev *ioat = NULL;
  56         const struct rte_memzone *mz = NULL;
  57         char mz_name[RTE_MEMZONE_NAMESIZE];
  58         int ret = 0;
  59         int retry = 0;
  60
  61         if (!name) {
  62                 IOAT_PMD_ERR("Invalid name of the device!");
  63                 ret = -EINVAL;
  64                 goto cleanup;
  65         }
  66
  67         /* Allocate device structure */
  68         rawdev = rte_rawdev_pmd_allocate(name, sizeof(struct rte_ioat_rawdev),
  69                                          dev->device.numa_node);
  70         if (rawdev == NULL) {
  71                 IOAT_PMD_ERR("Unable to allocate raw device");
  72                 ret = -ENOMEM;
  73                 goto cleanup;
  74         }
  75
  76         snprintf(mz_name, sizeof(mz_name), "rawdev%u_private", rawdev->dev_id);
  77         mz = rte_memzone_reserve(mz_name, sizeof(struct rte_ioat_rawdev),
  78                         dev->device.numa_node, RTE_MEMZONE_IOVA_CONTIG);
  79         if (mz == NULL) {
  80                 IOAT_PMD_ERR("Unable to reserve memzone for private data\n");
  81                 ret = -ENOMEM;
  82                 goto cleanup;
  83         }
  84
  85         rawdev->dev_private = mz->addr;
  86         rawdev->dev_ops = &ioat_rawdev_ops;
  87         rawdev->device = &dev->device;
  88         rawdev->driver_name = dev->device.driver->name;
  89
  90         ioat = rawdev->dev_private;
  91         ioat->rawdev = rawdev;
  92         ioat->mz = mz;
  93         ioat->regs = dev->mem_resource[0].addr;
  94         ioat->ring_size = 0;
  95         ioat->desc_ring = NULL;
  96         ioat->status_addr = ioat->mz->iova +
  97                         offsetof(struct rte_ioat_rawdev, status);
  98
  99         /* do device initialization - reset and set error behaviour */
 100         if (ioat->regs->chancnt != 1)
 101                 IOAT_PMD_ERR("%s: Channel count == %d\n", __func__,
 102                                 ioat->regs->chancnt);
 103
 104         if (ioat->regs->chanctrl & 0x100) { /* locked by someone else */
 105                 IOAT_PMD_WARN("%s: Channel appears locked\n", __func__);
 106                 ioat->regs->chanctrl = 0;
 107         }
 108
 109         ioat->regs->chancmd = RTE_IOAT_CHANCMD_SUSPEND;
 110         rte_delay_ms(1);
 111         ioat->regs->chancmd = RTE_IOAT_CHANCMD_RESET;
 112         rte_delay_ms(1);
 113         while (ioat->regs->chancmd & RTE_IOAT_CHANCMD_RESET) {
 114                 ioat->regs->chainaddr = 0;
 115                 rte_delay_ms(1);
 116                 if (++retry >= 200) {
 117                         IOAT_PMD_ERR("%s: cannot reset device. CHANCMD=0x%"PRIx8", CHANSTS=0x%"PRIx64", CHANERR=0x%"PRIx32"\n",
 118                                         __func__,
 119                                         ioat->regs->chancmd,
 120                                         ioat->regs->chansts,
 121                                         ioat->regs->chanerr);
 122                         ret = -EIO;
 123                 }
 124         }
 125         ioat->regs->chanctrl = RTE_IOAT_CHANCTRL_ANY_ERR_ABORT_EN |
 126                         RTE_IOAT_CHANCTRL_ERR_COMPLETION_EN;
 127
 128         return 0;
 129
 130 cleanup:
 131         if (rawdev)
 132                 rte_rawdev_pmd_release(rawdev);
 133
 134         return ret;
 135 }
 136
 137 static int
 138 ioat_rawdev_destroy(const char *name)
 139 {
 140         int ret;
 141         struct rte_rawdev *rdev;
 142
 143         if (!name) {
 144                 IOAT_PMD_ERR("Invalid device name");
 145                 return -EINVAL;
 146         }
 147
 148         rdev = rte_rawdev_pmd_get_named_dev(name);
 149         if (!rdev) {
 150                 IOAT_PMD_ERR("Invalid device name (%s)", name);
 151                 return -EINVAL;
 152         }
 153
 154         if (rdev->dev_private != NULL) {
 155                 struct rte_ioat_rawdev *ioat = rdev->dev_private;
 156                 rdev->dev_private = NULL;
 157                 rte_memzone_free(ioat->mz);
 158         }
 159
 160         /* rte_rawdev_close is called by pmd_release */
 161         ret = rte_rawdev_pmd_release(rdev);
 162         if (ret)
 163                 IOAT_PMD_DEBUG("Device cleanup failed");
 164
 165         return 0;
 166 }
 167
 168 static int
 169 ioat_rawdev_probe(struct rte_pci_driver *drv, struct rte_pci_device *dev)
 170 {
 171         char name[32];
 172         int ret = 0;
 173
 174
 175         rte_pci_device_name(&dev->addr, name, sizeof(name));
 176         IOAT_PMD_INFO("Init %s on NUMA node %d", name, dev->device.numa_node);
 177
 178         dev->device.driver = &drv->driver;
 179         ret = ioat_rawdev_create(name, dev);
 180         return ret;
 181 }
 182
 183 static int
 184 ioat_rawdev_remove(struct rte_pci_device *dev)
 185 {
 186         char name[32];
 187         int ret;
 188
 189         rte_pci_device_name(&dev->addr, name, sizeof(name));
 190
 191         IOAT_PMD_INFO("Closing %s on NUMA node %d",
 192                         name, dev->device.numa_node);
 193
 194         ret = ioat_rawdev_destroy(name);
 195         return ret;
 196 }
 197
 198 static const struct rte_pci_id pci_id_ioat_map[] = {
 199         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_SKX) },
 200         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX0) },
 201         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX1) },
 202         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX2) },
 203         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX3) },
 204         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX4) },
 205         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX5) },
 206         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX6) },
 207         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDX7) },
 208         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDXE) },
 209         { RTE_PCI_DEVICE(IOAT_VENDOR_ID, IOAT_DEVICE_ID_BDXF) },
 210         { .vendor_id = 0, /* sentinel */ },
 211 };
 212
 213 static struct rte_pci_driver ioat_pmd_drv = {
 214         .id_table = pci_id_ioat_map,
 215         .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC |
 216                      RTE_PCI_DRV_IOVA_AS_VA,
 217         .probe = ioat_rawdev_probe,
 218         .remove = ioat_rawdev_remove,
 219 };
 220
 221 RTE_PMD_REGISTER_PCI(IOAT_PMD_RAWDEV_NAME, ioat_pmd_drv);
 222 RTE_PMD_REGISTER_PCI_TABLE(IOAT_PMD_RAWDEV_NAME, pci_id_ioat_map);
 223 RTE_PMD_REGISTER_KMOD_DEP(IOAT_PMD_RAWDEV_NAME, "* igb_uio | uio_pci_generic");
 224
 225 RTE_INIT(ioat_pmd_init_log)
 226 {
 227         ioat_pmd_logtype = rte_log_register(IOAT_PMD_LOG_NAME);
 228         if (ioat_pmd_logtype >= 0)
 229                 rte_log_set_level(ioat_pmd_logtype, RTE_LOG_INFO);
 230 }