drivers/net/nfp/nfp_nspu.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <unistd.h>
   5 #include <sys/types.h>
   6 #include <sys/file.h>
   7 #include <sys/stat.h>
   8 #include <fcntl.h>
   9
  10 #include <rte_log.h>
  11 #include <rte_byteorder.h>
  12
  13 #include "nfp_nfpu.h"
  14
  15 #define CFG_EXP_BAR_ADDR_SZ     1
  16 #define CFG_EXP_BAR_MAP_TYPE    1
  17
  18 #define EXP_BAR_TARGET_SHIFT     23
  19 #define EXP_BAR_LENGTH_SHIFT     27 /* 0=32, 1=64 bit increment */
  20 #define EXP_BAR_MAP_TYPE_SHIFT   29 /* Bulk BAR map */
  21
  22 /* NFP target for NSP access */
  23 #define NFP_NSP_TARGET   7
  24
  25 /* Expansion BARs for mapping PF vnic BARs */
  26 #define NFP_NET_PF_CFG_EXP_BAR          6
  27 #define NFP_NET_PF_HW_QUEUES_EXP_BAR    5
  28
  29 /*
  30  * This is an NFP internal address used for configuring properly an NFP
  31  * expansion BAR.
  32  */
  33 #define MEM_CMD_BASE_ADDR       0x8100000000
  34
  35 /* NSP interface registers */
  36 #define NSP_BASE                (MEM_CMD_BASE_ADDR + 0x22100)
  37 #define NSP_STATUS              0x00
  38 #define NSP_COMMAND             0x08
  39 #define NSP_BUFFER              0x10
  40 #define NSP_DEFAULT_BUF         0x18
  41 #define NSP_DEFAULT_BUF_CFG  0x20
  42
  43 #define NSP_MAGIC                0xab10
  44 #define NSP_STATUS_MAGIC(x)      (((x) >> 48) & 0xffff)
  45 #define NSP_STATUS_MAJOR(x)      (int)(((x) >> 44) & 0xf)
  46 #define NSP_STATUS_MINOR(x)      (int)(((x) >> 32) & 0xfff)
  47
  48 /* NSP commands */
  49 #define NSP_CMD_RESET                   1
  50 #define NSP_CMD_FW_LOAD                 6
  51 #define NSP_CMD_READ_ETH_TABLE          7
  52 #define NSP_CMD_WRITE_ETH_TABLE         8
  53 #define NSP_CMD_GET_SYMBOL             14
  54
  55 #define NSP_BUFFER_CFG_SIZE_MASK        (0xff)
  56
  57 #define NSP_REG_ADDR(d, off, reg) ((uint8_t *)(d)->mem_base + (off) + (reg))
  58 #define NSP_REG_VAL(p) (*(uint64_t *)(p))
  59
  60 /*
  61  * An NFP expansion BAR is configured for allowing access to a specific NFP
  62  * target:
  63  *
  64  *  IN:
  65  *      desc: struct with basic NSP addresses to work with
  66  *      expbar: NFP PF expansion BAR index to configure
  67  *      tgt: NFP target to configure access
  68  *      addr: NFP target address
  69  *
  70  *  OUT:
  71  *      pcie_offset: NFP PCI BAR offset to work with
  72  */
  73 static void
  74 nfp_nspu_mem_bar_cfg(nspu_desc_t *desc, int expbar, int tgt,
  75                      uint64_t addr, uint64_t *pcie_offset)
  76 {
  77         uint64_t x, y, barsz;
  78         uint32_t *expbar_ptr;
  79
  80         barsz = desc->barsz;
  81
  82         /*
  83          * NFP CPP address to configure. This comes from NFP 6000
  84          * datasheet document based on Bulk mapping.
  85          */
  86         x = (addr >> (barsz - 3)) << (21 - (40 - (barsz - 3)));
  87         x |= CFG_EXP_BAR_MAP_TYPE << EXP_BAR_MAP_TYPE_SHIFT;
  88         x |= CFG_EXP_BAR_ADDR_SZ << EXP_BAR_LENGTH_SHIFT;
  89         x |= tgt << EXP_BAR_TARGET_SHIFT;
  90
  91         /* Getting expansion bar configuration register address */
  92         expbar_ptr = (uint32_t *)desc->cfg_base;
  93         /* Each physical PCI BAR has 8 NFP expansion BARs */
  94         expbar_ptr += (desc->pcie_bar * 8) + expbar;
  95
  96         /* Writing to the expansion BAR register */
  97         *expbar_ptr = (uint32_t)x;
  98
  99         /* Getting the pcie offset to work with from userspace */
 100         y = addr & ((uint64_t)(1 << (barsz - 3)) - 1);
 101         *pcie_offset = y;
 102 }
 103
 104 /*
 105  * Configuring an expansion bar for accessing NSP userspace interface. This
 106  * function configures always the same expansion bar, which implies access to
 107  * previously configured NFP target is lost.
 108  */
 109 static void
 110 nspu_xlate(nspu_desc_t *desc, uint64_t addr, uint64_t *pcie_offset)
 111 {
 112         nfp_nspu_mem_bar_cfg(desc, desc->exp_bar, NFP_NSP_TARGET, addr,
 113                              pcie_offset);
 114 }
 115
 116 int
 117 nfp_nsp_get_abi_version(nspu_desc_t *desc, int *major, int *minor)
 118 {
 119         uint64_t pcie_offset;
 120         uint64_t nsp_reg;
 121
 122         nspu_xlate(desc, NSP_BASE, &pcie_offset);
 123         nsp_reg = NSP_REG_VAL(NSP_REG_ADDR(desc, pcie_offset, NSP_STATUS));
 124
 125         if (NSP_STATUS_MAGIC(nsp_reg) != NSP_MAGIC)
 126                 return -1;
 127
 128         *major = NSP_STATUS_MAJOR(nsp_reg);
 129         *minor = NSP_STATUS_MINOR(nsp_reg);
 130
 131         return 0;
 132 }
 133
 134 int
 135 nfp_nspu_init(nspu_desc_t *desc, int nfp, int pcie_bar, size_t pcie_barsz,
 136               int exp_bar, void *exp_bar_cfg_base, void *exp_bar_mmap)
 137 {
 138         uint64_t offset, buffaddr;
 139         uint64_t nsp_reg;
 140
 141         desc->nfp = nfp;
 142         desc->pcie_bar = pcie_bar;
 143         desc->exp_bar = exp_bar;
 144         desc->barsz = pcie_barsz;
 145         desc->windowsz = 1 << (desc->barsz - 3);
 146         desc->cfg_base = exp_bar_cfg_base;
 147         desc->mem_base = exp_bar_mmap;
 148
 149         nspu_xlate(desc, NSP_BASE, &offset);
 150
 151         /*
 152          * Other NSPU clients can use other buffers. Let's tell NSPU we use the
 153          * default buffer.
 154          */
 155         buffaddr = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_DEFAULT_BUF));
 156         NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_BUFFER)) = buffaddr;
 157
 158         /* NFP internal addresses are 40 bits. Clean all other bits here */
 159         buffaddr = buffaddr & (((uint64_t)1 << 40) - 1);
 160         desc->bufaddr = buffaddr;
 161
 162         /* Lets get information about the buffer */
 163         nsp_reg = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_DEFAULT_BUF_CFG));
 164
 165         /* Buffer size comes in MBs. Coversion to bytes */
 166         desc->buf_size = ((size_t)nsp_reg & NSP_BUFFER_CFG_SIZE_MASK) << 20;
 167
 168         return 0;
 169 }
 170
 171 #define NSPU_NFP_BUF(addr, base, off) \
 172         (*(uint64_t *)((uint8_t *)(addr)->mem_base + ((base) | (off))))
 173
 174 #define NSPU_HOST_BUF(base, off) (*(uint64_t *)((uint8_t *)(base) + (off)))
 175
 176 static int
 177 nspu_buff_write(nspu_desc_t *desc, void *buffer, size_t size)
 178 {
 179         uint64_t pcie_offset, pcie_window_base, pcie_window_offset;
 180         uint64_t windowsz = desc->windowsz;
 181         uint64_t buffaddr, j, i = 0;
 182         int ret = 0;
 183
 184         if (size > desc->buf_size)
 185                 return -1;
 186
 187         buffaddr = desc->bufaddr;
 188         windowsz = desc->windowsz;
 189
 190         while (i < size) {
 191                 /* Expansion bar reconfiguration per window size */
 192                 nspu_xlate(desc, buffaddr + i, &pcie_offset);
 193                 pcie_window_base = pcie_offset & (~(windowsz - 1));
 194                 pcie_window_offset = pcie_offset & (windowsz - 1);
 195                 for (j = pcie_window_offset; ((j < windowsz) && (i < size));
 196                      j += 8) {
 197                         NSPU_NFP_BUF(desc, pcie_window_base, j) =
 198                                 NSPU_HOST_BUF(buffer, i);
 199                         i += 8;
 200                 }
 201         }
 202
 203         return ret;
 204 }
 205
 206 static int
 207 nspu_buff_read(nspu_desc_t *desc, void *buffer, size_t size)
 208 {
 209         uint64_t pcie_offset, pcie_window_base, pcie_window_offset;
 210         uint64_t windowsz, i = 0, j;
 211         uint64_t buffaddr;
 212         int ret = 0;
 213
 214         if (size > desc->buf_size)
 215                 return -1;
 216
 217         buffaddr = desc->bufaddr;
 218         windowsz = desc->windowsz;
 219
 220         while (i < size) {
 221                 /* Expansion bar reconfiguration per window size */
 222                 nspu_xlate(desc, buffaddr + i, &pcie_offset);
 223                 pcie_window_base = pcie_offset & (~(windowsz - 1));
 224                 pcie_window_offset = pcie_offset & (windowsz - 1);
 225                 for (j = pcie_window_offset; ((j < windowsz) && (i < size));
 226                      j += 8) {
 227                         NSPU_HOST_BUF(buffer, i) =
 228                                 NSPU_NFP_BUF(desc, pcie_window_base, j);
 229                         i += 8;
 230                 }
 231         }
 232
 233         return ret;
 234 }
 235
 236 static int
 237 nspu_command(nspu_desc_t *desc, uint16_t cmd, int read, int write,
 238                  void *buffer, size_t rsize, size_t wsize)
 239 {
 240         uint64_t status, cmd_reg;
 241         uint64_t offset;
 242         int retry = 0;
 243         int retries = 120;
 244         int ret = 0;
 245
 246         /* Same expansion BAR is used for different things */
 247         nspu_xlate(desc, NSP_BASE, &offset);
 248
 249         status = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_STATUS));
 250
 251         while ((status & 0x1) && (retry < retries)) {
 252                 status = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_STATUS));
 253                 retry++;
 254                 sleep(1);
 255         }
 256
 257         if (retry == retries)
 258                 return -1;
 259
 260         if (write) {
 261                 ret = nspu_buff_write(desc, buffer, wsize);
 262                 if (ret)
 263                         return ret;
 264
 265                 /* Expansion BAR changes when writing the buffer */
 266                 nspu_xlate(desc, NSP_BASE, &offset);
 267         }
 268
 269         NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_COMMAND)) =
 270                 (uint64_t)wsize << 32 | (uint64_t)cmd << 16 | 1;
 271
 272         retry = 0;
 273
 274         cmd_reg = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_COMMAND));
 275         while ((cmd_reg & 0x1) && (retry < retries)) {
 276                 cmd_reg = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_COMMAND));
 277                 retry++;
 278                 sleep(1);
 279         }
 280         if (retry == retries)
 281                 return -1;
 282
 283         retry = 0;
 284         status = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_STATUS));
 285         while ((status & 0x1) && (retry < retries)) {
 286                 status = NSP_REG_VAL(NSP_REG_ADDR(desc, offset, NSP_STATUS));
 287                 retry++;
 288                 sleep(1);
 289         }
 290
 291         if (retry == retries)
 292                 return -1;
 293
 294         ret = status & (0xff << 8);
 295         if (ret)
 296                 return ret;
 297
 298         if (read) {
 299                 ret = nspu_buff_read(desc, buffer, rsize);
 300                 if (ret)
 301                         return ret;
 302         }
 303
 304         return ret;
 305 }
 306
 307 static int
 308 nfp_fw_reset(nspu_desc_t *nspu_desc)
 309 {
 310         int res;
 311
 312         res = nspu_command(nspu_desc, NSP_CMD_RESET, 0, 0, 0, 0, 0);
 313
 314         if (res < 0)
 315                 RTE_LOG(INFO, PMD, "fw reset failed: error %d", res);
 316
 317         return res;
 318 }
 319
 320 #define DEFAULT_FW_PATH       "/lib/firmware/netronome"
 321 #define DEFAULT_FW_FILENAME   "nic_dpdk_default.nffw"
 322
 323 static int
 324 nfp_fw_upload(nspu_desc_t *nspu_desc)
 325 {
 326         int fw_f;
 327         char *fw_buf;
 328         char filename[100];
 329         struct stat file_stat;
 330         off_t fsize, bytes;
 331         ssize_t size;
 332         int ret;
 333
 334         size = nspu_desc->buf_size;
 335
 336         sprintf(filename, "%s/%s", DEFAULT_FW_PATH, DEFAULT_FW_FILENAME);
 337         fw_f = open(filename, O_RDONLY);
 338         if (fw_f < 0) {
 339                 RTE_LOG(INFO, PMD, "Firmware file %s/%s not found.",
 340                         DEFAULT_FW_PATH, DEFAULT_FW_FILENAME);
 341                 return -ENOENT;
 342         }
 343
 344         fstat(fw_f, &file_stat);
 345
 346         fsize = file_stat.st_size;
 347         RTE_LOG(DEBUG, PMD, "Firmware file with size: %" PRIu64 "\n",
 348                             (uint64_t)fsize);
 349
 350         if (fsize > (off_t)size) {
 351                 RTE_LOG(INFO, PMD, "fw file too big: %" PRIu64
 352                                    " bytes (%" PRIu64 " max)",
 353                                   (uint64_t)fsize, (uint64_t)size);
 354                 return -EINVAL;
 355         }
 356
 357         fw_buf = malloc((size_t)size);
 358         if (!fw_buf) {
 359                 RTE_LOG(INFO, PMD, "malloc failed for fw buffer");
 360                 return -ENOMEM;
 361         }
 362         memset(fw_buf, 0, size);
 363
 364         bytes = read(fw_f, fw_buf, fsize);
 365         if (bytes != fsize) {
 366                 RTE_LOG(INFO, PMD, "Reading fw to buffer failed.\n"
 367                                    "Just %" PRIu64 " of %" PRIu64 " bytes read.",
 368                                    (uint64_t)bytes, (uint64_t)fsize);
 369                 free(fw_buf);
 370                 return -EIO;
 371         }
 372
 373         ret = nspu_command(nspu_desc, NSP_CMD_FW_LOAD, 0, 1, fw_buf, 0, bytes);
 374
 375         free(fw_buf);
 376
 377         return ret;
 378 }
 379
 380 /* Firmware symbol descriptor size */
 381 #define NFP_SYM_DESC_LEN 40
 382
 383 #define SYMBOL_DATA(b, off)     (*(int64_t *)((b) + (off)))
 384 #define SYMBOL_UDATA(b, off)     (*(uint64_t *)((b) + (off)))
 385
 386 /* Firmware symbols contain information about how to access what they
 387  * represent. It can be as simple as an numeric variable declared at a
 388  * specific NFP memory, but it can also be more complex structures and
 389  * related to specific hardware functionalities or components. Target,
 390  * domain and address allow to create the BAR window for accessing such
 391  * hw object and size defines the length to map.
 392  *
 393  * A vNIC is a network interface implemented inside the NFP and using a
 394  * subset of device PCI BARs. Specific firmware symbols allow to map those
 395  * vNIC bars by host drivers like the NFP PMD.
 396  *
 397  * Accessing what the symbol represents implies to map the access through
 398  * a PCI BAR window. NFP expansion BARs are used in this regard through
 399  * the NSPU interface.
 400  */
 401 static int
 402 nfp_nspu_set_bar_from_symbl(nspu_desc_t *desc, const char *symbl,
 403                             uint32_t expbar, uint64_t *pcie_offset,
 404                             ssize_t *size)
 405 {
 406         int64_t type;
 407         int64_t target;
 408         int64_t domain;
 409         uint64_t addr;
 410         char *sym_buf;
 411         int ret = 0;
 412
 413         sym_buf = malloc(desc->buf_size);
 414         strncpy(sym_buf, symbl, strlen(symbl));
 415         ret = nspu_command(desc, NSP_CMD_GET_SYMBOL, 1, 1, sym_buf,
 416                            NFP_SYM_DESC_LEN, strlen(symbl));
 417         if (ret) {
 418                 RTE_LOG(DEBUG, PMD, "symbol resolution (%s) failed\n", symbl);
 419                 goto clean;
 420         }
 421
 422         /* Reading symbol information */
 423         type = SYMBOL_DATA(sym_buf, 0);
 424         target = SYMBOL_DATA(sym_buf, 8);
 425         domain =  SYMBOL_DATA(sym_buf, 16);
 426         addr = SYMBOL_UDATA(sym_buf, 24);
 427         *size = (ssize_t)SYMBOL_UDATA(sym_buf, 32);
 428
 429         if (type != 1) {
 430                 RTE_LOG(INFO, PMD, "wrong symbol type\n");
 431                 ret = -EINVAL;
 432                 goto clean;
 433         }
 434         if (!(target == 7 || target == -7)) {
 435                 RTE_LOG(INFO, PMD, "wrong symbol target\n");
 436                 ret = -EINVAL;
 437                 goto clean;
 438         }
 439         if (domain == 8 || domain == 9) {
 440                 RTE_LOG(INFO, PMD, "wrong symbol domain\n");
 441                 ret = -EINVAL;
 442                 goto clean;
 443         }
 444
 445         /* Adjusting address based on symbol location */
 446         if ((domain >= 24) && (domain < 28) && (target == 7)) {
 447                 addr = 1ULL << 37 | addr | ((uint64_t)domain & 0x3) << 35;
 448         } else {
 449                 addr = 1ULL << 39 | addr | ((uint64_t)domain & 0x3f) << 32;
 450                 if (target == -7)
 451                         target = 7;
 452         }
 453
 454         /* Configuring NFP expansion bar for mapping specific PCI BAR window */
 455         nfp_nspu_mem_bar_cfg(desc, expbar, target, addr, pcie_offset);
 456
 457         /* This is the PCI BAR offset to use by the host */
 458         *pcie_offset |= ((expbar & 0x7) << (desc->barsz - 3));
 459
 460 clean:
 461         free(sym_buf);
 462         return ret;
 463 }
 464
 465 int
 466 nfp_nsp_fw_setup(nspu_desc_t *desc, const char *sym, uint64_t *pcie_offset)
 467 {
 468         ssize_t bar0_sym_size;
 469
 470         /* If the symbol resolution works, it implies a firmware app
 471          * is already there.
 472          */
 473         if (!nfp_nspu_set_bar_from_symbl(desc, sym, NFP_NET_PF_CFG_EXP_BAR,
 474                                          pcie_offset, &bar0_sym_size))
 475                 return 0;
 476
 477         /* No firmware app detected or not the right one */
 478         RTE_LOG(INFO, PMD, "No firmware detected. Resetting NFP...\n");
 479         if (nfp_fw_reset(desc) < 0) {
 480                 RTE_LOG(ERR, PMD, "nfp fw reset failed\n");
 481                 return -ENODEV;
 482         }
 483
 484         RTE_LOG(INFO, PMD, "Reset done.\n");
 485         RTE_LOG(INFO, PMD, "Uploading firmware...\n");
 486
 487         if (nfp_fw_upload(desc) < 0) {
 488                 RTE_LOG(ERR, PMD, "nfp fw upload failed\n");
 489                 return -ENODEV;
 490         }
 491
 492         RTE_LOG(INFO, PMD, "Done.\n");
 493
 494         /* Now the symbol should be there */
 495         if (nfp_nspu_set_bar_from_symbl(desc, sym, NFP_NET_PF_CFG_EXP_BAR,
 496                                         pcie_offset, &bar0_sym_size)) {
 497                 RTE_LOG(ERR, PMD, "nfp PF BAR symbol resolution failed\n");
 498                 return -ENODEV;
 499         }
 500
 501         return 0;
 502 }
 503
 504 int
 505 nfp_nsp_map_ctrl_bar(nspu_desc_t *desc, uint64_t *pcie_offset)
 506 {
 507         ssize_t bar0_sym_size;
 508
 509         if (nfp_nspu_set_bar_from_symbl(desc, "_pf0_net_bar0",
 510                                         NFP_NET_PF_CFG_EXP_BAR,
 511                                         pcie_offset, &bar0_sym_size))
 512                 return -ENODEV;
 513
 514         return 0;
 515 }
 516
 517 /*
 518  * This is a hardcoded fixed NFP internal CPP bus address for the hw queues unit
 519  * inside the PCIE island.
 520  */
 521 #define NFP_CPP_PCIE_QUEUES ((uint64_t)(1ULL << 39) |  0x80000 | \
 522                              ((uint64_t)0x4 & 0x3f) << 32)
 523
 524 /* Configure a specific NFP expansion bar for accessing the vNIC rx/tx BARs */
 525 void
 526 nfp_nsp_map_queues_bar(nspu_desc_t *desc, uint64_t *pcie_offset)
 527 {
 528         nfp_nspu_mem_bar_cfg(desc, NFP_NET_PF_HW_QUEUES_EXP_BAR, 0,
 529                              NFP_CPP_PCIE_QUEUES, pcie_offset);
 530
 531         /* This is the pcie offset to use by the host */
 532         *pcie_offset |= ((NFP_NET_PF_HW_QUEUES_EXP_BAR & 0x7) << (27 - 3));
 533 }
 534
 535 int
 536 nfp_nsp_eth_config(nspu_desc_t *desc, int port, int up)
 537 {
 538         union eth_table_entry *entries, *entry;
 539         int modified;
 540         int ret, idx;
 541         int i;
 542
 543         idx = port;
 544
 545         RTE_LOG(INFO, PMD, "Hw ethernet port %d configure...\n", port);
 546         rte_spinlock_lock(&desc->nsp_lock);
 547         entries = malloc(NSP_ETH_TABLE_SIZE);
 548         if (!entries) {
 549                 rte_spinlock_unlock(&desc->nsp_lock);
 550                 return -ENOMEM;
 551         }
 552
 553         ret = nspu_command(desc, NSP_CMD_READ_ETH_TABLE, 1, 0, entries,
 554                            NSP_ETH_TABLE_SIZE, 0);
 555         if (ret) {
 556                 rte_spinlock_unlock(&desc->nsp_lock);
 557                 return ret;
 558         }
 559
 560         entry = entries;
 561
 562         for (i = 0; i < NSP_ETH_MAX_COUNT; i++) {
 563                 /* ports in use do not appear sequentially in the table */
 564                 if (!(entry->port & NSP_ETH_PORT_LANES_MASK)) {
 565                         /* entry not in use */
 566                         entry++;
 567                         continue;
 568                 }
 569                 if (idx == 0)
 570                         break;
 571                 idx--;
 572                 entry++;
 573         }
 574
 575         if (i == NSP_ETH_MAX_COUNT) {
 576                 rte_spinlock_unlock(&desc->nsp_lock);
 577                 return -EINVAL;
 578         }
 579
 580         if (up && !(entry->state & NSP_ETH_STATE_CONFIGURED)) {
 581                 entry->control |= NSP_ETH_STATE_CONFIGURED;
 582                 modified = 1;
 583         }
 584
 585         if (!up && (entry->state & NSP_ETH_STATE_CONFIGURED)) {
 586                 entry->control &= ~NSP_ETH_STATE_CONFIGURED;
 587                 modified = 1;
 588         }
 589
 590         if (modified) {
 591                 ret = nspu_command(desc, NSP_CMD_WRITE_ETH_TABLE, 0, 1, entries,
 592                                    0, NSP_ETH_TABLE_SIZE);
 593                 if (!ret)
 594                         RTE_LOG(INFO, PMD,
 595                                 "Hw ethernet port %d configure done\n", port);
 596                 else
 597                         RTE_LOG(INFO, PMD,
 598                                 "Hw ethernet port %d configure failed\n", port);
 599         }
 600         rte_spinlock_unlock(&desc->nsp_lock);
 601         return ret;
 602 }
 603
 604 int
 605 nfp_nsp_eth_read_table(nspu_desc_t *desc, union eth_table_entry **table)
 606 {
 607         int ret;
 608
 609         RTE_LOG(INFO, PMD, "Reading hw ethernet table...\n");
 610         /* port 0 allocates the eth table and read it using NSPU */
 611         *table = malloc(NSP_ETH_TABLE_SIZE);
 612         if (!table)
 613                 return -ENOMEM;
 614
 615         ret = nspu_command(desc, NSP_CMD_READ_ETH_TABLE, 1, 0, *table,
 616                            NSP_ETH_TABLE_SIZE, 0);
 617         if (ret)
 618                 return ret;
 619
 620         RTE_LOG(INFO, PMD, "Done\n");
 621
 622         return 0;
 623 }