ceph/src/spdk/dpdk/drivers/bus/ifpga/ifpga_bus.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2018 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <inttypes.h>
   7 #include <stdint.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <sys/queue.h>
  11 #include <sys/mman.h>
  12 #include <sys/types.h>
  13 #include <unistd.h>
  14 #include <fcntl.h>
  15
  16 #include <rte_errno.h>
  17 #include <rte_bus.h>
  18 #include <rte_per_lcore.h>
  19 #include <rte_memory.h>
  20 #include <rte_memzone.h>
  21 #include <rte_eal.h>
  22 #include <rte_common.h>
  23 #include <rte_devargs.h>
  24 #include <rte_kvargs.h>
  25 #include <rte_alarm.h>
  26 #include <rte_string_fns.h>
  27
  28 #include "rte_rawdev.h"
  29 #include "rte_rawdev_pmd.h"
  30 #include "rte_bus_ifpga.h"
  31 #include "ifpga_logs.h"
  32 #include "ifpga_common.h"
  33
  34 int ifpga_bus_logtype;
  35
  36 /* Forward declaration to access Intel FPGA bus
  37  * on which iFPGA devices are connected
  38  */
  39 static struct rte_bus rte_ifpga_bus;
  40
  41 static struct ifpga_afu_dev_list ifpga_afu_dev_list =
  42         TAILQ_HEAD_INITIALIZER(ifpga_afu_dev_list);
  43 static struct ifpga_afu_drv_list ifpga_afu_drv_list =
  44         TAILQ_HEAD_INITIALIZER(ifpga_afu_drv_list);
  45
  46
  47 /* register a ifpga bus based driver */
  48 void rte_ifpga_driver_register(struct rte_afu_driver *driver)
  49 {
  50         RTE_VERIFY(driver);
  51
  52         TAILQ_INSERT_TAIL(&ifpga_afu_drv_list, driver, next);
  53 }
  54
  55 /* un-register a fpga bus based driver */
  56 void rte_ifpga_driver_unregister(struct rte_afu_driver *driver)
  57 {
  58         TAILQ_REMOVE(&ifpga_afu_drv_list, driver, next);
  59 }
  60
  61 static struct rte_afu_device *
  62 ifpga_find_afu_dev(const struct rte_rawdev *rdev,
  63         const struct rte_afu_id *afu_id)
  64 {
  65         struct rte_afu_device *afu_dev = NULL;
  66
  67         TAILQ_FOREACH(afu_dev, &ifpga_afu_dev_list, next) {
  68                 if (afu_dev &&
  69                         afu_dev->rawdev == rdev &&
  70                         !ifpga_afu_id_cmp(&afu_dev->id, afu_id))
  71                         return afu_dev;
  72         }
  73         return NULL;
  74 }
  75
  76 struct rte_afu_device *
  77 rte_ifpga_find_afu_by_name(const char *name)
  78 {
  79         struct rte_afu_device *afu_dev = NULL;
  80
  81         TAILQ_FOREACH(afu_dev, &ifpga_afu_dev_list, next) {
  82                 if (afu_dev &&
  83                         !strcmp(afu_dev->device.name, name))
  84                         return afu_dev;
  85         }
  86         return NULL;
  87 }
  88
  89 static const char * const valid_args[] = {
  90 #define IFPGA_ARG_NAME         "ifpga"
  91         IFPGA_ARG_NAME,
  92 #define IFPGA_ARG_PORT         "port"
  93         IFPGA_ARG_PORT,
  94 #define IFPGA_AFU_BTS          "afu_bts"
  95         IFPGA_AFU_BTS,
  96         NULL
  97 };
  98
  99 /*
 100  * Scan the content of the FPGA bus, and the devices in the devices
 101  * list
 102  */
 103 static struct rte_afu_device *
 104 ifpga_scan_one(struct rte_rawdev *rawdev,
 105                 struct rte_devargs *devargs)
 106 {
 107         struct rte_kvargs *kvlist = NULL;
 108         struct rte_afu_device *afu_dev = NULL;
 109         struct rte_afu_pr_conf afu_pr_conf;
 110         int ret = 0;
 111         char *path = NULL;
 112
 113         memset(&afu_pr_conf, 0, sizeof(struct rte_afu_pr_conf));
 114
 115         kvlist = rte_kvargs_parse(devargs->args, valid_args);
 116         if (!kvlist) {
 117                 IFPGA_BUS_ERR("error when parsing param");
 118                 goto end;
 119         }
 120
 121         if (rte_kvargs_count(kvlist, IFPGA_ARG_PORT) == 1) {
 122                 if (rte_kvargs_process(kvlist, IFPGA_ARG_PORT,
 123                 &rte_ifpga_get_integer32_arg, &afu_pr_conf.afu_id.port) < 0) {
 124                         IFPGA_BUS_ERR("error to parse %s",
 125                                      IFPGA_ARG_PORT);
 126                         goto end;
 127                 }
 128         } else {
 129                 IFPGA_BUS_ERR("arg %s is mandatory for ifpga bus",
 130                           IFPGA_ARG_PORT);
 131                 goto end;
 132         }
 133
 134         if (rte_kvargs_count(kvlist, IFPGA_AFU_BTS) == 1) {
 135                 if (rte_kvargs_process(kvlist, IFPGA_AFU_BTS,
 136                                        &rte_ifpga_get_string_arg, &path) < 0) {
 137                         IFPGA_BUS_ERR("Failed to parse %s",
 138                                      IFPGA_AFU_BTS);
 139                         goto end;
 140                 }
 141                 afu_pr_conf.pr_enable = 1;
 142         } else {
 143                 afu_pr_conf.pr_enable = 0;
 144         }
 145
 146         afu_pr_conf.afu_id.uuid.uuid_low = 0;
 147         afu_pr_conf.afu_id.uuid.uuid_high = 0;
 148
 149         if (ifpga_find_afu_dev(rawdev, &afu_pr_conf.afu_id))
 150                 goto end;
 151
 152         afu_dev = calloc(1, sizeof(*afu_dev));
 153         if (!afu_dev)
 154                 goto end;
 155
 156         afu_dev->device.bus = &rte_ifpga_bus;
 157         afu_dev->device.devargs = devargs;
 158         afu_dev->device.numa_node = SOCKET_ID_ANY;
 159         afu_dev->device.name = devargs->name;
 160         afu_dev->rawdev = rawdev;
 161         afu_dev->id.uuid.uuid_low  = 0;
 162         afu_dev->id.uuid.uuid_high = 0;
 163         afu_dev->id.port      = afu_pr_conf.afu_id.port;
 164
 165         if (rawdev->dev_ops && rawdev->dev_ops->dev_info_get)
 166                 rawdev->dev_ops->dev_info_get(rawdev, afu_dev);
 167
 168         if (rawdev->dev_ops &&
 169                 rawdev->dev_ops->dev_start &&
 170                 rawdev->dev_ops->dev_start(rawdev))
 171                 goto end;
 172
 173         strlcpy(afu_pr_conf.bs_path, path, sizeof(afu_pr_conf.bs_path));
 174         if (rawdev->dev_ops &&
 175                 rawdev->dev_ops->firmware_load &&
 176                 rawdev->dev_ops->firmware_load(rawdev,
 177                                 &afu_pr_conf)){
 178                 IFPGA_BUS_ERR("firmware load error %d\n", ret);
 179                 goto end;
 180         }
 181         afu_dev->id.uuid.uuid_low  = afu_pr_conf.afu_id.uuid.uuid_low;
 182         afu_dev->id.uuid.uuid_high = afu_pr_conf.afu_id.uuid.uuid_high;
 183
 184         rte_kvargs_free(kvlist);
 185         free(path);
 186         return afu_dev;
 187
 188 end:
 189         if (kvlist)
 190                 rte_kvargs_free(kvlist);
 191         if (path)
 192                 free(path);
 193         if (afu_dev)
 194                 free(afu_dev);
 195
 196         return NULL;
 197 }
 198
 199 /*
 200  * Scan the content of the FPGA bus, and the devices in the devices
 201  * list
 202  */
 203 static int
 204 ifpga_scan(void)
 205 {
 206         struct rte_devargs *devargs;
 207         struct rte_kvargs *kvlist = NULL;
 208         struct rte_rawdev *rawdev = NULL;
 209         char *name = NULL;
 210         char name1[RTE_RAWDEV_NAME_MAX_LEN];
 211         struct rte_afu_device *afu_dev = NULL;
 212
 213         /* for FPGA devices we scan the devargs_list populated via cmdline */
 214         RTE_EAL_DEVARGS_FOREACH(IFPGA_ARG_NAME, devargs) {
 215                 if (devargs->bus != &rte_ifpga_bus)
 216                         continue;
 217
 218                 kvlist = rte_kvargs_parse(devargs->args, valid_args);
 219                 if (!kvlist) {
 220                         IFPGA_BUS_ERR("error when parsing param");
 221                         goto end;
 222                 }
 223
 224                 if (rte_kvargs_count(kvlist, IFPGA_ARG_NAME) == 1) {
 225                         if (rte_kvargs_process(kvlist, IFPGA_ARG_NAME,
 226                                        &rte_ifpga_get_string_arg, &name) < 0) {
 227                                 IFPGA_BUS_ERR("error to parse %s",
 228                                      IFPGA_ARG_NAME);
 229                                 goto end;
 230                         }
 231                 } else {
 232                         IFPGA_BUS_ERR("arg %s is mandatory for ifpga bus",
 233                           IFPGA_ARG_NAME);
 234                         goto end;
 235                 }
 236
 237                 memset(name1, 0, sizeof(name1));
 238                 snprintf(name1, RTE_RAWDEV_NAME_MAX_LEN, "IFPGA:%s", name);
 239
 240                 rawdev = rte_rawdev_pmd_get_named_dev(name1);
 241                 if (!rawdev)
 242                         goto end;
 243
 244                 afu_dev = ifpga_scan_one(rawdev, devargs);
 245                 if (afu_dev != NULL)
 246                         TAILQ_INSERT_TAIL(&ifpga_afu_dev_list, afu_dev, next);
 247         }
 248
 249 end:
 250         if (kvlist)
 251                 rte_kvargs_free(kvlist);
 252         if (name)
 253                 free(name);
 254
 255         return 0;
 256 }
 257
 258 /*
 259  * Match the AFU Driver and AFU Device using the ID Table
 260  */
 261 static int
 262 rte_afu_match(const struct rte_afu_driver *afu_drv,
 263               const struct rte_afu_device *afu_dev)
 264 {
 265         const struct rte_afu_uuid *id_table;
 266
 267         for (id_table = afu_drv->id_table;
 268                 ((id_table->uuid_low != 0) && (id_table->uuid_high != 0));
 269              id_table++) {
 270                 /* check if device's identifiers match the driver's ones */
 271                 if ((id_table->uuid_low != afu_dev->id.uuid.uuid_low) ||
 272                                 id_table->uuid_high !=
 273                                  afu_dev->id.uuid.uuid_high)
 274                         continue;
 275
 276                 return 1;
 277         }
 278
 279         return 0;
 280 }
 281
 282 static int
 283 ifpga_probe_one_driver(struct rte_afu_driver *drv,
 284                         struct rte_afu_device *afu_dev)
 285 {
 286         int ret;
 287
 288         if (!rte_afu_match(drv, afu_dev))
 289                 /* Match of device and driver failed */
 290                 return 1;
 291
 292         /* reference driver structure */
 293         afu_dev->driver = drv;
 294
 295         /* call the driver probe() function */
 296         ret = drv->probe(afu_dev);
 297         if (ret)
 298                 afu_dev->driver = NULL;
 299         else
 300                 afu_dev->device.driver = &drv->driver;
 301
 302         return ret;
 303 }
 304
 305 static int
 306 ifpga_probe_all_drivers(struct rte_afu_device *afu_dev)
 307 {
 308         struct rte_afu_driver *drv = NULL;
 309         int ret = 0;
 310
 311         if (afu_dev == NULL)
 312                 return -1;
 313
 314         /* Check if a driver is already loaded */
 315         if (rte_dev_is_probed(&afu_dev->device)) {
 316                 IFPGA_BUS_DEBUG("Device %s is already probed\n",
 317                                 rte_ifpga_device_name(afu_dev));
 318                 return -EEXIST;
 319         }
 320
 321         TAILQ_FOREACH(drv, &ifpga_afu_drv_list, next) {
 322                 ret = ifpga_probe_one_driver(drv, afu_dev);
 323                 if (ret < 0)
 324                         /* negative value is an error */
 325                         return ret;
 326                 if (ret > 0)
 327                         /* positive value means driver doesn't support it */
 328                         continue;
 329                 return 0;
 330         }
 331         if ((ret > 0) && (afu_dev->driver == NULL))
 332                 return 0;
 333         else
 334                 return ret;
 335 }
 336
 337 /*
 338  * Scan the content of the Intel FPGA bus, and call the probe() function for
 339  * all registered drivers that have a matching entry in its id_table
 340  * for discovered devices.
 341  */
 342 static int
 343 ifpga_probe(void)
 344 {
 345         struct rte_afu_device *afu_dev = NULL;
 346         int ret = 0;
 347
 348         TAILQ_FOREACH(afu_dev, &ifpga_afu_dev_list, next) {
 349                 ret = ifpga_probe_all_drivers(afu_dev);
 350                 if (ret == -EEXIST)
 351                         continue;
 352                 if (ret < 0)
 353                         IFPGA_BUS_ERR("failed to initialize %s device\n",
 354                                 rte_ifpga_device_name(afu_dev));
 355         }
 356
 357         return ret;
 358 }
 359
 360 static int
 361 ifpga_plug(struct rte_device *dev)
 362 {
 363         return ifpga_probe_all_drivers(RTE_DEV_TO_AFU(dev));
 364 }
 365
 366 static int
 367 ifpga_remove_driver(struct rte_afu_device *afu_dev)
 368 {
 369         const char *name;
 370
 371         name = rte_ifpga_device_name(afu_dev);
 372         if (afu_dev->driver == NULL) {
 373                 IFPGA_BUS_DEBUG("no driver attach to device %s\n", name);
 374                 return 1;
 375         }
 376
 377         return afu_dev->driver->remove(afu_dev);
 378 }
 379
 380 static int
 381 ifpga_unplug(struct rte_device *dev)
 382 {
 383         struct rte_afu_device *afu_dev = NULL;
 384         int ret;
 385
 386         if (dev == NULL)
 387                 return -EINVAL;
 388
 389         afu_dev = RTE_DEV_TO_AFU(dev);
 390         if (!afu_dev)
 391                 return -ENOENT;
 392
 393         ret = ifpga_remove_driver(afu_dev);
 394         if (ret)
 395                 return ret;
 396
 397         TAILQ_REMOVE(&ifpga_afu_dev_list, afu_dev, next);
 398
 399         rte_devargs_remove(dev->devargs);
 400         free(afu_dev);
 401         return 0;
 402
 403 }
 404
 405 static struct rte_device *
 406 ifpga_find_device(const struct rte_device *start,
 407         rte_dev_cmp_t cmp, const void *data)
 408 {
 409         struct rte_afu_device *afu_dev;
 410
 411         TAILQ_FOREACH(afu_dev, &ifpga_afu_dev_list, next) {
 412                 if (start && &afu_dev->device == start) {
 413                         start = NULL;
 414                         continue;
 415                 }
 416                 if (cmp(&afu_dev->device, data) == 0)
 417                         return &afu_dev->device;
 418         }
 419
 420         return NULL;
 421 }
 422 static int
 423 ifpga_parse(const char *name, void *addr)
 424 {
 425         int *out = addr;
 426         struct rte_rawdev *rawdev = NULL;
 427         char rawdev_name[RTE_RAWDEV_NAME_MAX_LEN];
 428         char *c1 = NULL;
 429         char *c2 = NULL;
 430         int port = IFPGA_BUS_DEV_PORT_MAX;
 431         char str_port[8];
 432         int str_port_len = 0;
 433         int ret;
 434
 435         memset(str_port, 0, 8);
 436         c1 = strchr(name, '|');
 437         if (c1 != NULL) {
 438                 str_port_len = c1 - name;
 439                 c2 = c1 + 1;
 440         }
 441
 442         if (str_port_len < 8 &&
 443                 str_port_len > 0) {
 444                 memcpy(str_port, name, str_port_len);
 445                 ret = sscanf(str_port, "%d", &port);
 446                 if (ret == -1)
 447                         return 0;
 448         }
 449
 450         memset(rawdev_name, 0, sizeof(rawdev_name));
 451         snprintf(rawdev_name, RTE_RAWDEV_NAME_MAX_LEN, "IFPGA:%s", c2);
 452         rawdev = rte_rawdev_pmd_get_named_dev(rawdev_name);
 453
 454         if ((port < IFPGA_BUS_DEV_PORT_MAX) &&
 455                 rawdev &&
 456                 (addr != NULL))
 457                 *out = port;
 458
 459         if ((port < IFPGA_BUS_DEV_PORT_MAX) &&
 460                 rawdev)
 461                 return 0;
 462         else
 463                 return 1;
 464 }
 465
 466 static struct rte_bus rte_ifpga_bus = {
 467         .scan        = ifpga_scan,
 468         .probe       = ifpga_probe,
 469         .find_device = ifpga_find_device,
 470         .plug        = ifpga_plug,
 471         .unplug      = ifpga_unplug,
 472         .parse       = ifpga_parse,
 473 };
 474
 475 RTE_REGISTER_BUS(IFPGA_BUS_NAME, rte_ifpga_bus);
 476
 477 RTE_INIT(ifpga_init_log)
 478 {
 479         ifpga_bus_logtype = rte_log_register("bus.ifpga");
 480         if (ifpga_bus_logtype >= 0)
 481                 rte_log_set_level(ifpga_bus_logtype, RTE_LOG_NOTICE);
 482 }