drivers/raw/ifpga_rawdev/ifpga_rawdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2018 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <dirent.h>
   7 #include <sys/stat.h>
   8 #include <unistd.h>
   9 #include <sys/types.h>
  10 #include <fcntl.h>
  11 #include <rte_log.h>
  12 #include <rte_bus.h>
  13 #include <rte_eal_memconfig.h>
  14 #include <rte_malloc.h>
  15 #include <rte_devargs.h>
  16 #include <rte_memcpy.h>
  17 #include <rte_pci.h>
  18 #include <rte_bus_pci.h>
  19 #include <rte_kvargs.h>
  20 #include <rte_alarm.h>
  21
  22 #include <rte_errno.h>
  23 #include <rte_per_lcore.h>
  24 #include <rte_memory.h>
  25 #include <rte_memzone.h>
  26 #include <rte_eal.h>
  27 #include <rte_common.h>
  28 #include <rte_bus_vdev.h>
  29
  30 #include "base/opae_hw_api.h"
  31 #include "rte_rawdev.h"
  32 #include "rte_rawdev_pmd.h"
  33 #include "rte_bus_ifpga.h"
  34 #include "ifpga_common.h"
  35 #include "ifpga_logs.h"
  36 #include "ifpga_rawdev.h"
  37
  38 int ifpga_rawdev_logtype;
  39
  40 #define PCI_VENDOR_ID_INTEL          0x8086
  41 /* PCI Device ID */
  42 #define PCIE_DEVICE_ID_PF_INT_5_X    0xBCBD
  43 #define PCIE_DEVICE_ID_PF_INT_6_X    0xBCC0
  44 #define PCIE_DEVICE_ID_PF_DSC_1_X    0x09C4
  45 /* VF Device */
  46 #define PCIE_DEVICE_ID_VF_INT_5_X    0xBCBF
  47 #define PCIE_DEVICE_ID_VF_INT_6_X    0xBCC1
  48 #define PCIE_DEVICE_ID_VF_DSC_1_X    0x09C5
  49 #define RTE_MAX_RAW_DEVICE           10
  50
  51 static const struct rte_pci_id pci_ifpga_map[] = {
  52         { RTE_PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIE_DEVICE_ID_PF_INT_5_X) },
  53         { RTE_PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIE_DEVICE_ID_VF_INT_5_X) },
  54         { RTE_PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIE_DEVICE_ID_PF_INT_6_X) },
  55         { RTE_PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIE_DEVICE_ID_VF_INT_6_X) },
  56         { RTE_PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIE_DEVICE_ID_PF_DSC_1_X) },
  57         { RTE_PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCIE_DEVICE_ID_VF_DSC_1_X) },
  58         { .vendor_id = 0, /* sentinel */ },
  59 };
  60
  61 static int
  62 ifpga_fill_afu_dev(struct opae_accelerator *acc,
  63                 struct rte_afu_device *afu_dev)
  64 {
  65         struct rte_mem_resource *res = afu_dev->mem_resource;
  66         struct opae_acc_region_info region_info;
  67         struct opae_acc_info info;
  68         unsigned long i;
  69         int ret;
  70
  71         ret = opae_acc_get_info(acc, &info);
  72         if (ret)
  73                 return ret;
  74
  75         if (info.num_regions > PCI_MAX_RESOURCE)
  76                 return -EFAULT;
  77
  78         afu_dev->num_region = info.num_regions;
  79
  80         for (i = 0; i < info.num_regions; i++) {
  81                 region_info.index = i;
  82                 ret = opae_acc_get_region_info(acc, &region_info);
  83                 if (ret)
  84                         return ret;
  85
  86                 if ((region_info.flags & ACC_REGION_MMIO) &&
  87                     (region_info.flags & ACC_REGION_READ) &&
  88                     (region_info.flags & ACC_REGION_WRITE)) {
  89                         res[i].phys_addr = region_info.phys_addr;
  90                         res[i].len = region_info.len;
  91                         res[i].addr = region_info.addr;
  92                 } else
  93                         return -EFAULT;
  94         }
  95
  96         return 0;
  97 }
  98
  99 static void
 100 ifpga_rawdev_info_get(struct rte_rawdev *dev,
 101                                      rte_rawdev_obj_t dev_info)
 102 {
 103         struct opae_adapter *adapter;
 104         struct opae_accelerator *acc;
 105         struct rte_afu_device *afu_dev;
 106
 107         IFPGA_RAWDEV_PMD_FUNC_TRACE();
 108
 109         if (!dev_info) {
 110                 IFPGA_RAWDEV_PMD_ERR("Invalid request");
 111                 return;
 112         }
 113
 114         adapter = ifpga_rawdev_get_priv(dev);
 115         if (!adapter)
 116                 return;
 117
 118         afu_dev = dev_info;
 119         afu_dev->rawdev = dev;
 120
 121         /* find opae_accelerator and fill info into afu_device */
 122         opae_adapter_for_each_acc(adapter, acc) {
 123                 if (acc->index != afu_dev->id.port)
 124                         continue;
 125
 126                 if (ifpga_fill_afu_dev(acc, afu_dev)) {
 127                         IFPGA_RAWDEV_PMD_ERR("cannot get info\n");
 128                         return;
 129                 }
 130         }
 131 }
 132
 133 static int
 134 ifpga_rawdev_configure(const struct rte_rawdev *dev,
 135                 rte_rawdev_obj_t config)
 136 {
 137         IFPGA_RAWDEV_PMD_FUNC_TRACE();
 138
 139         RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
 140
 141         return config ? 0 : 1;
 142 }
 143
 144 static int
 145 ifpga_rawdev_start(struct rte_rawdev *dev)
 146 {
 147         int ret = 0;
 148         struct opae_adapter *adapter;
 149
 150         IFPGA_RAWDEV_PMD_FUNC_TRACE();
 151
 152         RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
 153
 154         adapter = ifpga_rawdev_get_priv(dev);
 155         if (!adapter)
 156                 return -ENODEV;
 157
 158         return ret;
 159 }
 160
 161 static void
 162 ifpga_rawdev_stop(struct rte_rawdev *dev)
 163 {
 164         dev->started = 0;
 165 }
 166
 167 static int
 168 ifpga_rawdev_close(struct rte_rawdev *dev)
 169 {
 170         return dev ? 0:1;
 171 }
 172
 173 static int
 174 ifpga_rawdev_reset(struct rte_rawdev *dev)
 175 {
 176         return dev ? 0:1;
 177 }
 178
 179 static int
 180 fpga_pr(struct rte_rawdev *raw_dev, u32 port_id, u64 *buffer, u32 size,
 181                         u64 *status)
 182 {
 183
 184         struct opae_adapter *adapter;
 185         struct opae_manager *mgr;
 186         struct opae_accelerator *acc;
 187         struct opae_bridge *br;
 188         int ret;
 189
 190         adapter = ifpga_rawdev_get_priv(raw_dev);
 191         if (!adapter)
 192                 return -ENODEV;
 193
 194         mgr = opae_adapter_get_mgr(adapter);
 195         if (!mgr)
 196                 return -ENODEV;
 197
 198         acc = opae_adapter_get_acc(adapter, port_id);
 199         if (!acc)
 200                 return -ENODEV;
 201
 202         br = opae_acc_get_br(acc);
 203         if (!br)
 204                 return -ENODEV;
 205
 206         ret = opae_manager_flash(mgr, port_id, buffer, size, status);
 207         if (ret) {
 208                 IFPGA_RAWDEV_PMD_ERR("%s pr error %d\n", __func__, ret);
 209                 return ret;
 210         }
 211
 212         ret = opae_bridge_reset(br);
 213         if (ret) {
 214                 IFPGA_RAWDEV_PMD_ERR("%s reset port:%d error %d\n",
 215                                 __func__, port_id, ret);
 216                 return ret;
 217         }
 218
 219         return ret;
 220 }
 221
 222 static int
 223 rte_fpga_do_pr(struct rte_rawdev *rawdev, int port_id,
 224                 const char *file_name)
 225 {
 226         struct stat file_stat;
 227         int file_fd;
 228         int ret = 0;
 229         ssize_t buffer_size;
 230         void *buffer;
 231         u64 pr_error;
 232
 233         if (!file_name)
 234                 return -EINVAL;
 235
 236         file_fd = open(file_name, O_RDONLY);
 237         if (file_fd < 0) {
 238                 IFPGA_RAWDEV_PMD_ERR("%s: open file error: %s\n",
 239                                 __func__, file_name);
 240                 IFPGA_RAWDEV_PMD_ERR("Message : %s\n", strerror(errno));
 241                 return -EINVAL;
 242         }
 243         ret = stat(file_name, &file_stat);
 244         if (ret) {
 245                 IFPGA_RAWDEV_PMD_ERR("stat on bitstream file failed: %s\n",
 246                                 file_name);
 247                 ret = -EINVAL;
 248                 goto close_fd;
 249         }
 250         buffer_size = file_stat.st_size;
 251         IFPGA_RAWDEV_PMD_INFO("bitstream file size: %zu\n", buffer_size);
 252         buffer = rte_malloc(NULL, buffer_size, 0);
 253         if (!buffer) {
 254                 ret = -ENOMEM;
 255                 goto close_fd;
 256         }
 257
 258         /*read the raw data*/
 259         if (buffer_size != read(file_fd, (void *)buffer, buffer_size)) {
 260                 ret = -EINVAL;
 261                 goto free_buffer;
 262         }
 263
 264         /*do PR now*/
 265         ret = fpga_pr(rawdev, port_id, buffer, buffer_size, &pr_error);
 266         IFPGA_RAWDEV_PMD_INFO("downloading to device port %d....%s.\n", port_id,
 267                 ret ? "failed" : "success");
 268         if (ret) {
 269                 ret = -EINVAL;
 270                 goto free_buffer;
 271         }
 272
 273 free_buffer:
 274         if (buffer)
 275                 rte_free(buffer);
 276 close_fd:
 277         close(file_fd);
 278         file_fd = 0;
 279         return ret;
 280 }
 281
 282 static int
 283 ifpga_rawdev_pr(struct rte_rawdev *dev,
 284         rte_rawdev_obj_t pr_conf)
 285 {
 286         struct opae_adapter *adapter;
 287         struct rte_afu_pr_conf *afu_pr_conf;
 288         int ret;
 289         struct uuid uuid;
 290         struct opae_accelerator *acc;
 291
 292         IFPGA_RAWDEV_PMD_FUNC_TRACE();
 293
 294         adapter = ifpga_rawdev_get_priv(dev);
 295         if (!adapter)
 296                 return -ENODEV;
 297
 298         if (!pr_conf)
 299                 return -EINVAL;
 300
 301         afu_pr_conf = pr_conf;
 302
 303         if (afu_pr_conf->pr_enable) {
 304                 ret = rte_fpga_do_pr(dev,
 305                                 afu_pr_conf->afu_id.port,
 306                                 afu_pr_conf->bs_path);
 307                 if (ret) {
 308                         IFPGA_RAWDEV_PMD_ERR("do pr error %d\n", ret);
 309                         return ret;
 310                 }
 311         }
 312
 313         acc = opae_adapter_get_acc(adapter, afu_pr_conf->afu_id.port);
 314         if (!acc)
 315                 return -ENODEV;
 316
 317         ret = opae_acc_get_uuid(acc, &uuid);
 318         if (ret)
 319                 return ret;
 320
 321         memcpy(&afu_pr_conf->afu_id.uuid.uuid_low, uuid.b, sizeof(u64));
 322         memcpy(&afu_pr_conf->afu_id.uuid.uuid_high, uuid.b + 8, sizeof(u64));
 323
 324         IFPGA_RAWDEV_PMD_INFO("%s: uuid_l=0x%lx, uuid_h=0x%lx\n", __func__,
 325                 (unsigned long)afu_pr_conf->afu_id.uuid.uuid_low,
 326                 (unsigned long)afu_pr_conf->afu_id.uuid.uuid_high);
 327
 328         return 0;
 329 }
 330
 331 static const struct rte_rawdev_ops ifpga_rawdev_ops = {
 332         .dev_info_get = ifpga_rawdev_info_get,
 333         .dev_configure = ifpga_rawdev_configure,
 334         .dev_start = ifpga_rawdev_start,
 335         .dev_stop = ifpga_rawdev_stop,
 336         .dev_close = ifpga_rawdev_close,
 337         .dev_reset = ifpga_rawdev_reset,
 338
 339         .queue_def_conf = NULL,
 340         .queue_setup = NULL,
 341         .queue_release = NULL,
 342
 343         .attr_get = NULL,
 344         .attr_set = NULL,
 345
 346         .enqueue_bufs = NULL,
 347         .dequeue_bufs = NULL,
 348
 349         .dump = NULL,
 350
 351         .xstats_get = NULL,
 352         .xstats_get_names = NULL,
 353         .xstats_get_by_name = NULL,
 354         .xstats_reset = NULL,
 355
 356         .firmware_status_get = NULL,
 357         .firmware_version_get = NULL,
 358         .firmware_load = ifpga_rawdev_pr,
 359         .firmware_unload = NULL,
 360
 361         .dev_selftest = NULL,
 362 };
 363
 364 static int
 365 ifpga_rawdev_create(struct rte_pci_device *pci_dev,
 366                         int socket_id)
 367 {
 368         int ret = 0;
 369         struct rte_rawdev *rawdev = NULL;
 370         struct opae_adapter *adapter = NULL;
 371         struct opae_manager *mgr = NULL;
 372         struct opae_adapter_data_pci *data = NULL;
 373         char name[RTE_RAWDEV_NAME_MAX_LEN];
 374         int i;
 375
 376         if (!pci_dev) {
 377                 IFPGA_RAWDEV_PMD_ERR("Invalid pci_dev of the device!");
 378                 ret = -EINVAL;
 379                 goto cleanup;
 380         }
 381
 382         memset(name, 0, sizeof(name));
 383         snprintf(name, RTE_RAWDEV_NAME_MAX_LEN, "IFPGA:%x:%02x.%x",
 384                 pci_dev->addr.bus, pci_dev->addr.devid, pci_dev->addr.function);
 385
 386         IFPGA_RAWDEV_PMD_INFO("Init %s on NUMA node %d", name, rte_socket_id());
 387
 388         /* Allocate device structure */
 389         rawdev = rte_rawdev_pmd_allocate(name, sizeof(struct opae_adapter),
 390                                          socket_id);
 391         if (rawdev == NULL) {
 392                 IFPGA_RAWDEV_PMD_ERR("Unable to allocate rawdevice");
 393                 ret = -EINVAL;
 394                 goto cleanup;
 395         }
 396
 397         /* alloc OPAE_FPGA_PCI data to register to OPAE hardware level API */
 398         data = opae_adapter_data_alloc(OPAE_FPGA_PCI);
 399         if (!data) {
 400                 ret = -ENOMEM;
 401                 goto cleanup;
 402         }
 403
 404         /* init opae_adapter_data_pci for device specific information */
 405         for (i = 0; i < PCI_MAX_RESOURCE; i++) {
 406                 data->region[i].phys_addr = pci_dev->mem_resource[i].phys_addr;
 407                 data->region[i].len = pci_dev->mem_resource[i].len;
 408                 data->region[i].addr = pci_dev->mem_resource[i].addr;
 409         }
 410         data->device_id = pci_dev->id.device_id;
 411         data->vendor_id = pci_dev->id.vendor_id;
 412
 413         adapter = rawdev->dev_private;
 414         /* create a opae_adapter based on above device data */
 415         ret = opae_adapter_init(adapter, pci_dev->device.name, data);
 416         if (ret) {
 417                 ret = -ENOMEM;
 418                 goto free_adapter_data;
 419         }
 420
 421         rawdev->dev_ops = &ifpga_rawdev_ops;
 422         rawdev->device = &pci_dev->device;
 423         rawdev->driver_name = pci_dev->device.driver->name;
 424
 425         /* must enumerate the adapter before use it */
 426         ret = opae_adapter_enumerate(adapter);
 427         if (ret)
 428                 goto free_adapter_data;
 429
 430         /* get opae_manager to rawdev */
 431         mgr = opae_adapter_get_mgr(adapter);
 432         if (mgr) {
 433                 /* PF function */
 434                 IFPGA_RAWDEV_PMD_INFO("this is a PF function");
 435         }
 436
 437         return ret;
 438
 439 free_adapter_data:
 440         if (data)
 441                 opae_adapter_data_free(data);
 442 cleanup:
 443         if (rawdev)
 444                 rte_rawdev_pmd_release(rawdev);
 445
 446         return ret;
 447 }
 448
 449 static int
 450 ifpga_rawdev_destroy(struct rte_pci_device *pci_dev)
 451 {
 452         int ret;
 453         struct rte_rawdev *rawdev;
 454         char name[RTE_RAWDEV_NAME_MAX_LEN];
 455         struct opae_adapter *adapter;
 456
 457         if (!pci_dev) {
 458                 IFPGA_RAWDEV_PMD_ERR("Invalid pci_dev of the device!");
 459                 ret = -EINVAL;
 460                 return ret;
 461         }
 462
 463         memset(name, 0, sizeof(name));
 464         snprintf(name, RTE_RAWDEV_NAME_MAX_LEN, "IFPGA:%x:%02x.%x",
 465                 pci_dev->addr.bus, pci_dev->addr.devid, pci_dev->addr.function);
 466
 467         IFPGA_RAWDEV_PMD_INFO("Closing %s on NUMA node %d",
 468                 name, rte_socket_id());
 469
 470         rawdev = rte_rawdev_pmd_get_named_dev(name);
 471         if (!rawdev) {
 472                 IFPGA_RAWDEV_PMD_ERR("Invalid device name (%s)", name);
 473                 return -EINVAL;
 474         }
 475
 476         adapter = ifpga_rawdev_get_priv(rawdev);
 477         if (!adapter)
 478                 return -ENODEV;
 479
 480         opae_adapter_data_free(adapter->data);
 481         opae_adapter_free(adapter);
 482
 483         /* rte_rawdev_close is called by pmd_release */
 484         ret = rte_rawdev_pmd_release(rawdev);
 485         if (ret)
 486                 IFPGA_RAWDEV_PMD_DEBUG("Device cleanup failed");
 487
 488         return ret;
 489 }
 490
 491 static int
 492 ifpga_rawdev_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
 493         struct rte_pci_device *pci_dev)
 494 {
 495
 496         IFPGA_RAWDEV_PMD_FUNC_TRACE();
 497         return ifpga_rawdev_create(pci_dev, rte_socket_id());
 498 }
 499
 500 static int
 501 ifpga_rawdev_pci_remove(struct rte_pci_device *pci_dev)
 502 {
 503         return ifpga_rawdev_destroy(pci_dev);
 504 }
 505
 506 static struct rte_pci_driver rte_ifpga_rawdev_pmd = {
 507         .id_table  = pci_ifpga_map,
 508         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 509         .probe     = ifpga_rawdev_pci_probe,
 510         .remove    = ifpga_rawdev_pci_remove,
 511 };
 512
 513 RTE_PMD_REGISTER_PCI(ifpga_rawdev_pci_driver, rte_ifpga_rawdev_pmd);
 514 RTE_PMD_REGISTER_PCI_TABLE(ifpga_rawdev_pci_driver, rte_ifpga_rawdev_pmd);
 515 RTE_PMD_REGISTER_KMOD_DEP(ifpga_rawdev_pci_driver, "* igb_uio | uio_pci_generic | vfio-pci");
 516
 517 RTE_INIT(ifpga_rawdev_init_log)
 518 {
 519         ifpga_rawdev_logtype = rte_log_register("driver.raw.init");
 520         if (ifpga_rawdev_logtype >= 0)
 521                 rte_log_set_level(ifpga_rawdev_logtype, RTE_LOG_NOTICE);
 522 }
 523
 524 static const char * const valid_args[] = {
 525 #define IFPGA_ARG_NAME         "ifpga"
 526         IFPGA_ARG_NAME,
 527 #define IFPGA_ARG_PORT         "port"
 528         IFPGA_ARG_PORT,
 529 #define IFPGA_AFU_BTS          "afu_bts"
 530         IFPGA_AFU_BTS,
 531         NULL
 532 };
 533
 534 static int
 535 ifpga_cfg_probe(struct rte_vdev_device *dev)
 536 {
 537         struct rte_devargs *devargs;
 538         struct rte_kvargs *kvlist = NULL;
 539         int port;
 540         char *name = NULL;
 541         char dev_name[RTE_RAWDEV_NAME_MAX_LEN];
 542         int ret = -1;
 543
 544         devargs = dev->device.devargs;
 545
 546         kvlist = rte_kvargs_parse(devargs->args, valid_args);
 547         if (!kvlist) {
 548                 IFPGA_RAWDEV_PMD_LOG(ERR, "error when parsing param");
 549                 goto end;
 550         }
 551
 552         if (rte_kvargs_count(kvlist, IFPGA_ARG_NAME) == 1) {
 553                 if (rte_kvargs_process(kvlist, IFPGA_ARG_NAME,
 554                                        &rte_ifpga_get_string_arg, &name) < 0) {
 555                         IFPGA_RAWDEV_PMD_ERR("error to parse %s",
 556                                      IFPGA_ARG_NAME);
 557                         goto end;
 558                 }
 559         } else {
 560                 IFPGA_RAWDEV_PMD_ERR("arg %s is mandatory for ifpga bus",
 561                           IFPGA_ARG_NAME);
 562                 goto end;
 563         }
 564
 565         if (rte_kvargs_count(kvlist, IFPGA_ARG_PORT) == 1) {
 566                 if (rte_kvargs_process(kvlist,
 567                         IFPGA_ARG_PORT,
 568                         &rte_ifpga_get_integer32_arg,
 569                         &port) < 0) {
 570                         IFPGA_RAWDEV_PMD_ERR("error to parse %s",
 571                                 IFPGA_ARG_PORT);
 572                         goto end;
 573                 }
 574         } else {
 575                 IFPGA_RAWDEV_PMD_ERR("arg %s is mandatory for ifpga bus",
 576                           IFPGA_ARG_PORT);
 577                 goto end;
 578         }
 579
 580         memset(dev_name, 0, sizeof(dev_name));
 581         snprintf(dev_name, RTE_RAWDEV_NAME_MAX_LEN, "%d|%s",
 582         port, name);
 583
 584         ret = rte_eal_hotplug_add(RTE_STR(IFPGA_BUS_NAME),
 585                         dev_name, devargs->args);
 586 end:
 587         if (kvlist)
 588                 rte_kvargs_free(kvlist);
 589         if (name)
 590                 free(name);
 591
 592         return ret;
 593 }
 594
 595 static int
 596 ifpga_cfg_remove(struct rte_vdev_device *vdev)
 597 {
 598         IFPGA_RAWDEV_PMD_INFO("Remove ifpga_cfg %p",
 599                 vdev);
 600
 601         return 0;
 602 }
 603
 604 static struct rte_vdev_driver ifpga_cfg_driver = {
 605         .probe = ifpga_cfg_probe,
 606         .remove = ifpga_cfg_remove,
 607 };
 608
 609 RTE_PMD_REGISTER_VDEV(ifpga_rawdev_cfg, ifpga_cfg_driver);
 610 RTE_PMD_REGISTER_ALIAS(ifpga_rawdev_cfg, ifpga_cfg);
 611 RTE_PMD_REGISTER_PARAM_STRING(ifpga_rawdev_cfg,
 612         "ifpga=<string> "
 613         "port=<int> "
 614         "afu_bts=<path>");
 615