drivers/raw/ifpga/rte_pmd_ifpga.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2021 Intel Corporation
   3  */
   4
   5 #include <rte_pci.h>
   6 #include <rte_bus_pci.h>
   7 #include <rte_rawdev.h>
   8 #include <rte_rawdev_pmd.h>
   9 #include "rte_pmd_ifpga.h"
  10 #include "ifpga_rawdev.h"
  11 #include "base/ifpga_api.h"
  12 #include "base/ifpga_sec_mgr.h"
  13
  14
  15 int
  16 rte_pmd_ifpga_get_dev_id(const char *pci_addr, uint16_t *dev_id)
  17 {
  18         struct rte_pci_addr addr;
  19         struct rte_rawdev *rdev = NULL;
  20         char rdev_name[RTE_RAWDEV_NAME_MAX_LEN] = {0};
  21
  22         if (!pci_addr || !dev_id) {
  23                 IFPGA_RAWDEV_PMD_ERR("Input parameter is invalid.");
  24                 return -EINVAL;
  25         }
  26
  27         if (strnlen(pci_addr, PCI_PRI_STR_SIZE) == PCI_PRI_STR_SIZE) {
  28                 IFPGA_RAWDEV_PMD_ERR("PCI address is too long.");
  29                 return -EINVAL;
  30         }
  31
  32         if (rte_pci_addr_parse(pci_addr, &addr)) {
  33                 IFPGA_RAWDEV_PMD_ERR("PCI address %s is invalid.", pci_addr);
  34                 return -EINVAL;
  35         }
  36
  37         snprintf(rdev_name, RTE_RAWDEV_NAME_MAX_LEN, "IFPGA:%02x:%02x.%x",
  38                 addr.bus, addr.devid, addr.function);
  39         rdev = rte_rawdev_pmd_get_named_dev(rdev_name);
  40         if (!rdev) {
  41                 IFPGA_RAWDEV_PMD_DEBUG("%s is not probed by ifpga driver.",
  42                         pci_addr);
  43                 return -ENODEV;
  44         }
  45         *dev_id = rdev->dev_id;
  46
  47         return 0;
  48 }
  49
  50 static struct rte_rawdev *
  51 get_rte_rawdev(uint16_t dev_id)
  52 {
  53         struct rte_rawdev *dev = NULL;
  54
  55         if (dev_id >= RTE_RAWDEV_MAX_DEVS)
  56                 return NULL;
  57
  58         dev = &rte_rawdevs[dev_id];
  59         if (dev->attached == RTE_RAWDEV_ATTACHED)
  60                 return dev;
  61
  62         return NULL;
  63 }
  64
  65 static struct opae_adapter *
  66 get_opae_adapter(uint16_t dev_id)
  67 {
  68         struct rte_rawdev *dev = NULL;
  69         struct opae_adapter *adapter = NULL;
  70
  71         dev = get_rte_rawdev(dev_id);
  72         if (!dev) {
  73                 IFPGA_RAWDEV_PMD_ERR("Device ID %u is invalid.", dev_id);
  74                 return NULL;
  75         }
  76
  77         adapter = ifpga_rawdev_get_priv(dev);
  78         if (!adapter) {
  79                 IFPGA_RAWDEV_PMD_ERR("Adapter is not registered.");
  80                 return NULL;
  81         }
  82
  83         return adapter;
  84 }
  85
  86 static opae_share_data *
  87 get_share_data(struct opae_adapter *adapter)
  88 {
  89         opae_share_data *sd = NULL;
  90
  91         if (!adapter)
  92                 return NULL;
  93
  94         sd = (opae_share_data *)adapter->shm.ptr;
  95         if (!sd) {
  96                 IFPGA_RAWDEV_PMD_ERR("Share data is not initialized.");
  97                 return NULL;
  98         }
  99
 100         return sd;
 101 }
 102
 103 int
 104 rte_pmd_ifpga_get_rsu_status(uint16_t dev_id, uint32_t *stat, uint32_t *prog)
 105 {
 106         struct opae_adapter *adapter = NULL;
 107         opae_share_data *sd = NULL;
 108
 109         adapter = get_opae_adapter(dev_id);
 110         if (!adapter)
 111                 return -ENODEV;
 112
 113         sd = get_share_data(adapter);
 114         if (!sd)
 115                 return -ENOMEM;
 116
 117         if (stat)
 118                 *stat = IFPGA_RSU_GET_STAT(sd->rsu_stat);
 119         if (prog)
 120                 *prog = IFPGA_RSU_GET_PROG(sd->rsu_stat);
 121
 122         return 0;
 123 }
 124
 125 static int
 126 ifpga_is_rebooting(struct opae_adapter *adapter)
 127 {
 128         opae_share_data *sd = NULL;
 129
 130         sd = get_share_data(adapter);
 131         if (!sd)
 132                 return 1;
 133
 134         if (IFPGA_RSU_GET_STAT(sd->rsu_stat) == IFPGA_RSU_REBOOT) {
 135                 IFPGA_RAWDEV_PMD_WARN("Reboot is in progress.");
 136                 return 1;
 137         }
 138
 139         return 0;
 140 }
 141
 142 static int
 143 get_common_property(struct opae_adapter *adapter,
 144         rte_pmd_ifpga_common_prop *prop)
 145 {
 146         struct ifpga_fme_hw *fme = NULL;
 147         struct opae_board_info *info = NULL;
 148         struct feature_prop fp;
 149         struct uuid pr_id;
 150         int ret = 0;
 151
 152         if (!adapter || !prop)
 153                 return -EINVAL;
 154
 155         if (!adapter->mgr || !adapter->mgr->data) {
 156                 IFPGA_RAWDEV_PMD_ERR("Manager is not registered.");
 157                 return -ENODEV;
 158         }
 159
 160         fme = adapter->mgr->data;
 161         fp.feature_id = FME_FEATURE_ID_HEADER;
 162         fp.prop_id = FME_HDR_PROP_PORTS_NUM;
 163         ret = ifpga_get_prop(fme->parent, FEATURE_FIU_ID_FME, 0, &fp);
 164         if (ret) {
 165                 IFPGA_RAWDEV_PMD_ERR("Failed to get port number.");
 166                 return ret;
 167         }
 168         prop->num_ports = fp.data;
 169
 170         fp.prop_id = FME_HDR_PROP_BITSTREAM_ID;
 171         ret = ifpga_get_prop(fme->parent, FEATURE_FIU_ID_FME, 0, &fp);
 172         if (ret) {
 173                 IFPGA_RAWDEV_PMD_ERR("Failed to get bitstream ID.");
 174                 return ret;
 175         }
 176         prop->bitstream_id = fp.data;
 177
 178         fp.prop_id = FME_HDR_PROP_BITSTREAM_METADATA;
 179         ret = ifpga_get_prop(fme->parent, FEATURE_FIU_ID_FME, 0, &fp);
 180         if (ret) {
 181                 IFPGA_RAWDEV_PMD_ERR("Failed to get bitstream metadata.");
 182                 return ret;
 183         }
 184         prop->bitstream_metadata = fp.data;
 185
 186         ret = opae_mgr_get_uuid(adapter->mgr, &pr_id);
 187         if (ret) {
 188                 IFPGA_RAWDEV_PMD_ERR("Failed to get PR ID.");
 189                 return ret;
 190         }
 191         memcpy(prop->pr_id.b, pr_id.b, sizeof(rte_pmd_ifpga_uuid));
 192
 193         ret = opae_mgr_get_board_info(adapter->mgr, &info);
 194         if (ret) {
 195                 IFPGA_RAWDEV_PMD_ERR("Failed to get board info.");
 196                 return ret;
 197         }
 198         prop->boot_page = info->boot_page;
 199         prop->bmc_version = info->max10_version;
 200         prop->bmc_nios_version = info->nios_fw_version;
 201
 202         return 0;
 203 }
 204
 205 static int
 206 get_port_property(struct opae_adapter *adapter, uint16_t port,
 207         rte_pmd_ifpga_port_prop *prop)
 208 {
 209         struct ifpga_fme_hw *fme = NULL;
 210         struct feature_prop fp;
 211         struct opae_accelerator *acc = NULL;
 212         struct uuid afu_id;
 213         int ret = 0;
 214
 215         if (!adapter || !prop)
 216                 return -EINVAL;
 217
 218         if (!adapter->mgr || !adapter->mgr->data) {
 219                 IFPGA_RAWDEV_PMD_ERR("Manager is not registered.");
 220                 return -ENODEV;
 221         }
 222
 223         fme = adapter->mgr->data;
 224         fp.feature_id = FME_FEATURE_ID_HEADER;
 225         fp.prop_id = FME_HDR_PROP_PORT_TYPE;
 226         fp.data = port;
 227         fp.data <<= 32;
 228         ret = ifpga_get_prop(fme->parent, FEATURE_FIU_ID_FME, 0, &fp);
 229         if (ret)
 230                 return ret;
 231         prop->type = fp.data & 0xffffffff;
 232
 233         if (prop->type == 0) {
 234                 acc = opae_adapter_get_acc(adapter, port);
 235                 ret = opae_acc_get_uuid(acc, &afu_id);
 236                 if (ret) {
 237                         IFPGA_RAWDEV_PMD_ERR("Failed to get port%u AFU ID.",
 238                                 port);
 239                         return ret;
 240                 }
 241                 memcpy(prop->afu_id.b, afu_id.b, sizeof(rte_pmd_ifpga_uuid));
 242         }
 243
 244         return 0;
 245 }
 246
 247 int
 248 rte_pmd_ifpga_get_property(uint16_t dev_id, rte_pmd_ifpga_prop *prop)
 249 {
 250         struct opae_adapter *adapter = NULL;
 251         uint32_t i = 0;
 252         int ret = 0;
 253
 254         adapter = get_opae_adapter(dev_id);
 255         if (!adapter)
 256                 return -ENODEV;
 257
 258         opae_adapter_lock(adapter, -1);
 259         if (ifpga_is_rebooting(adapter)) {
 260                 ret = -EBUSY;
 261                 goto unlock_dev;
 262         }
 263
 264         ret = get_common_property(adapter, &prop->common);
 265         if (ret) {
 266                 ret = -EIO;
 267                 goto unlock_dev;
 268         }
 269
 270         for (i = 0; i < prop->common.num_ports; i++) {
 271                 ret = get_port_property(adapter, i, &prop->port[i]);
 272                 if (ret) {
 273                         ret = -EIO;
 274                         break;
 275                 }
 276         }
 277
 278 unlock_dev:
 279         opae_adapter_unlock(adapter);
 280         return ret;
 281 }
 282
 283 int
 284 rte_pmd_ifpga_get_phy_info(uint16_t dev_id, rte_pmd_ifpga_phy_info *info)
 285 {
 286         struct opae_adapter *adapter = NULL;
 287         struct opae_retimer_info rtm_info;
 288         struct opae_retimer_status rtm_status;
 289         int ret = 0;
 290
 291         adapter = get_opae_adapter(dev_id);
 292         if (!adapter)
 293                 return -ENODEV;
 294
 295         opae_adapter_lock(adapter, -1);
 296         if (ifpga_is_rebooting(adapter)) {
 297                 ret = -EBUSY;
 298                 goto unlock_dev;
 299         }
 300
 301         ret = opae_manager_get_retimer_info(adapter->mgr, &rtm_info);
 302         if (ret) {
 303                 IFPGA_RAWDEV_PMD_ERR("Failed to get retimer info.");
 304                 ret = -EIO;
 305                 goto unlock_dev;
 306         }
 307         info->num_retimers = rtm_info.nums_retimer;
 308
 309         ret = opae_manager_get_retimer_status(adapter->mgr, &rtm_status);
 310         if (ret) {
 311                 IFPGA_RAWDEV_PMD_ERR("Failed to get retimer status.");
 312                 ret = -EIO;
 313                 goto unlock_dev;
 314         }
 315         info->link_speed = rtm_status.speed;
 316         info->link_status = rtm_status.line_link_bitmap;
 317
 318 unlock_dev:
 319         opae_adapter_unlock(adapter);
 320         return ret;
 321 }
 322
 323 int
 324 rte_pmd_ifpga_update_flash(uint16_t dev_id, const char *image,
 325         uint64_t *status)
 326 {
 327         struct opae_adapter *adapter = NULL;
 328
 329         adapter = get_opae_adapter(dev_id);
 330         if (!adapter)
 331                 return -ENODEV;
 332
 333         return opae_mgr_update_flash(adapter->mgr, image, status);
 334 }
 335
 336 int
 337 rte_pmd_ifpga_stop_update(uint16_t dev_id, int force)
 338 {
 339         struct opae_adapter *adapter = NULL;
 340
 341         adapter = get_opae_adapter(dev_id);
 342         if (!adapter)
 343                 return -ENODEV;
 344
 345         return opae_mgr_stop_flash_update(adapter->mgr, force);
 346 }
 347
 348 int
 349 rte_pmd_ifpga_reboot_try(uint16_t dev_id)
 350 {
 351         struct opae_adapter *adapter = NULL;
 352         opae_share_data *sd = NULL;
 353
 354         adapter = get_opae_adapter(dev_id);
 355         if (!adapter)
 356                 return -ENODEV;
 357
 358         sd = get_share_data(adapter);
 359         if (!sd)
 360                 return -ENOMEM;
 361
 362         opae_adapter_lock(adapter, -1);
 363         if (IFPGA_RSU_GET_STAT(sd->rsu_stat) != IFPGA_RSU_IDLE) {
 364                 opae_adapter_unlock(adapter);
 365                 IFPGA_RAWDEV_PMD_WARN("Update or reboot is in progress.");
 366                 return -EBUSY;
 367         }
 368         sd->rsu_stat = IFPGA_RSU_STATUS(IFPGA_RSU_REBOOT, 0);
 369         opae_adapter_unlock(adapter);
 370
 371         return 0;
 372 }
 373
 374 int
 375 rte_pmd_ifpga_reload(uint16_t dev_id, int type, int page)
 376 {
 377         struct opae_adapter *adapter = NULL;
 378
 379         adapter = get_opae_adapter(dev_id);
 380         if (!adapter)
 381                 return -ENODEV;
 382
 383         return opae_mgr_reload(adapter->mgr, type, page);
 384 }