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                 close(fw_f);
 355                 return -EINVAL;
 356         }
 357
 358         fw_buf = malloc((size_t)size);
 359         if (!fw_buf) {
 360                 RTE_LOG(INFO, PMD, "malloc failed for fw buffer");
 361                 close(fw_f);
 362                 return -ENOMEM;
 363         }
 364         memset(fw_buf, 0, size);
 365
 366         bytes = read(fw_f, fw_buf, fsize);
 367         if (bytes != fsize) {
 368                 RTE_LOG(INFO, PMD, "Reading fw to buffer failed.\n"
 369                                    "Just %" PRIu64 " of %" PRIu64 " bytes read.",
 370                                    (uint64_t)bytes, (uint64_t)fsize);
 371                 free(fw_buf);
 372                 close(fw_f);
 373                 return -EIO;
 374         }
 375
 376         ret = nspu_command(nspu_desc, NSP_CMD_FW_LOAD, 0, 1, fw_buf, 0, bytes);
 377
 378         free(fw_buf);
 379         close(fw_f);
 380
 381         return ret;
 382 }
 383
 384 /* Firmware symbol descriptor size */
 385 #define NFP_SYM_DESC_LEN 40
 386
 387 #define SYMBOL_DATA(b, off)     (*(int64_t *)((b) + (off)))
 388 #define SYMBOL_UDATA(b, off)     (*(uint64_t *)((b) + (off)))
 389
 390 /* Firmware symbols contain information about how to access what they
 391  * represent. It can be as simple as an numeric variable declared at a
 392  * specific NFP memory, but it can also be more complex structures and
 393  * related to specific hardware functionalities or components. Target,
 394  * domain and address allow to create the BAR window for accessing such
 395  * hw object and size defines the length to map.
 396  *
 397  * A vNIC is a network interface implemented inside the NFP and using a
 398  * subset of device PCI BARs. Specific firmware symbols allow to map those
 399  * vNIC bars by host drivers like the NFP PMD.
 400  *
 401  * Accessing what the symbol represents implies to map the access through
 402  * a PCI BAR window. NFP expansion BARs are used in this regard through
 403  * the NSPU interface.
 404  */
 405 static int
 406 nfp_nspu_set_bar_from_symbl(nspu_desc_t *desc, const char *symbl,
 407                             uint32_t expbar, uint64_t *pcie_offset,
 408                             ssize_t *size)
 409 {
 410         int64_t type;
 411         int64_t target;
 412         int64_t domain;
 413         uint64_t addr;
 414         char *sym_buf;
 415         int ret = 0;
 416
 417         sym_buf = malloc(desc->buf_size);
 418         if (!sym_buf)
 419                 return -ENOMEM;
 420
 421         strncpy(sym_buf, symbl, strlen(symbl));
 422         ret = nspu_command(desc, NSP_CMD_GET_SYMBOL, 1, 1, sym_buf,
 423                            NFP_SYM_DESC_LEN, strlen(symbl));
 424         if (ret) {
 425                 RTE_LOG(DEBUG, PMD, "symbol resolution (%s) failed\n", symbl);
 426                 goto clean;
 427         }
 428
 429         /* Reading symbol information */
 430         type = SYMBOL_DATA(sym_buf, 0);
 431         target = SYMBOL_DATA(sym_buf, 8);
 432         domain =  SYMBOL_DATA(sym_buf, 16);
 433         addr = SYMBOL_UDATA(sym_buf, 24);
 434         *size = (ssize_t)SYMBOL_UDATA(sym_buf, 32);
 435
 436         if (type != 1) {
 437                 RTE_LOG(INFO, PMD, "wrong symbol type\n");
 438                 ret = -EINVAL;
 439                 goto clean;
 440         }
 441         if (!(target == 7 || target == -7)) {
 442                 RTE_LOG(INFO, PMD, "wrong symbol target\n");
 443                 ret = -EINVAL;
 444                 goto clean;
 445         }
 446         if (domain == 8 || domain == 9) {
 447                 RTE_LOG(INFO, PMD, "wrong symbol domain\n");
 448                 ret = -EINVAL;
 449                 goto clean;
 450         }
 451
 452         /* Adjusting address based on symbol location */
 453         if ((domain >= 24) && (domain < 28) && (target == 7)) {
 454                 addr = 1ULL << 37 | addr | ((uint64_t)domain & 0x3) << 35;
 455         } else {
 456                 addr = 1ULL << 39 | addr | ((uint64_t)domain & 0x3f) << 32;
 457                 if (target == -7)
 458                         target = 7;
 459         }
 460
 461         /* Configuring NFP expansion bar for mapping specific PCI BAR window */
 462         nfp_nspu_mem_bar_cfg(desc, expbar, target, addr, pcie_offset);
 463
 464         /* This is the PCI BAR offset to use by the host */
 465         *pcie_offset |= ((expbar & 0x7) << (desc->barsz - 3));
 466
 467 clean:
 468         free(sym_buf);
 469         return ret;
 470 }
 471
 472 int
 473 nfp_nsp_fw_setup(nspu_desc_t *desc, const char *sym, uint64_t *pcie_offset)
 474 {
 475         ssize_t bar0_sym_size;
 476
 477         /* If the symbol resolution works, it implies a firmware app
 478          * is already there.
 479          */
 480         if (!nfp_nspu_set_bar_from_symbl(desc, sym, NFP_NET_PF_CFG_EXP_BAR,
 481                                          pcie_offset, &bar0_sym_size))
 482                 return 0;
 483
 484         /* No firmware app detected or not the right one */
 485         RTE_LOG(INFO, PMD, "No firmware detected. Resetting NFP...\n");
 486         if (nfp_fw_reset(desc) < 0) {
 487                 RTE_LOG(ERR, PMD, "nfp fw reset failed\n");
 488                 return -ENODEV;
 489         }
 490
 491         RTE_LOG(INFO, PMD, "Reset done.\n");
 492         RTE_LOG(INFO, PMD, "Uploading firmware...\n");
 493
 494         if (nfp_fw_upload(desc) < 0) {
 495                 RTE_LOG(ERR, PMD, "nfp fw upload failed\n");
 496                 return -ENODEV;
 497         }
 498
 499         RTE_LOG(INFO, PMD, "Done.\n");
 500
 501         /* Now the symbol should be there */
 502         if (nfp_nspu_set_bar_from_symbl(desc, sym, NFP_NET_PF_CFG_EXP_BAR,
 503                                         pcie_offset, &bar0_sym_size)) {
 504                 RTE_LOG(ERR, PMD, "nfp PF BAR symbol resolution failed\n");
 505                 return -ENODEV;
 506         }
 507
 508         return 0;
 509 }
 510
 511 int
 512 nfp_nsp_map_ctrl_bar(nspu_desc_t *desc, uint64_t *pcie_offset)
 513 {
 514         ssize_t bar0_sym_size;
 515
 516         if (nfp_nspu_set_bar_from_symbl(desc, "_pf0_net_bar0",
 517                                         NFP_NET_PF_CFG_EXP_BAR,
 518                                         pcie_offset, &bar0_sym_size))
 519                 return -ENODEV;
 520
 521         return 0;
 522 }
 523
 524 /*
 525  * This is a hardcoded fixed NFP internal CPP bus address for the hw queues unit
 526  * inside the PCIE island.
 527  */
 528 #define NFP_CPP_PCIE_QUEUES ((uint64_t)(1ULL << 39) |  0x80000 | \
 529                              ((uint64_t)0x4 & 0x3f) << 32)
 530
 531 /* Configure a specific NFP expansion bar for accessing the vNIC rx/tx BARs */
 532 void
 533 nfp_nsp_map_queues_bar(nspu_desc_t *desc, uint64_t *pcie_offset)
 534 {
 535         nfp_nspu_mem_bar_cfg(desc, NFP_NET_PF_HW_QUEUES_EXP_BAR, 0,
 536                              NFP_CPP_PCIE_QUEUES, pcie_offset);
 537
 538         /* This is the pcie offset to use by the host */
 539         *pcie_offset |= ((NFP_NET_PF_HW_QUEUES_EXP_BAR & 0x7) << (27 - 3));
 540 }
 541
 542 int
 543 nfp_nsp_eth_config(nspu_desc_t *desc, int port, int up)
 544 {
 545         union eth_table_entry *entries, *entry;
 546         int modified;
 547         int ret, idx;
 548         int i;
 549
 550         idx = port;
 551
 552         RTE_LOG(INFO, PMD, "Hw ethernet port %d configure...\n", port);
 553         rte_spinlock_lock(&desc->nsp_lock);
 554         entries = malloc(NSP_ETH_TABLE_SIZE);
 555         if (!entries) {
 556                 rte_spinlock_unlock(&desc->nsp_lock);
 557                 return -ENOMEM;
 558         }
 559
 560         ret = nspu_command(desc, NSP_CMD_READ_ETH_TABLE, 1, 0, entries,
 561                            NSP_ETH_TABLE_SIZE, 0);
 562         if (ret) {
 563                 rte_spinlock_unlock(&desc->nsp_lock);
 564                 return ret;
 565         }
 566
 567         entry = entries;
 568
 569         for (i = 0; i < NSP_ETH_MAX_COUNT; i++) {
 570                 /* ports in use do not appear sequentially in the table */
 571                 if (!(entry->port & NSP_ETH_PORT_LANES_MASK)) {
 572                         /* entry not in use */
 573                         entry++;
 574                         continue;
 575                 }
 576                 if (idx == 0)
 577                         break;
 578                 idx--;
 579                 entry++;
 580         }
 581
 582         if (i == NSP_ETH_MAX_COUNT) {
 583                 rte_spinlock_unlock(&desc->nsp_lock);
 584                 return -EINVAL;
 585         }
 586
 587         if (up && !(entry->state & NSP_ETH_STATE_CONFIGURED)) {
 588                 entry->control |= NSP_ETH_STATE_CONFIGURED;
 589                 modified = 1;
 590         }
 591
 592         if (!up && (entry->state & NSP_ETH_STATE_CONFIGURED)) {
 593                 entry->control &= ~NSP_ETH_STATE_CONFIGURED;
 594                 modified = 1;
 595         }
 596
 597         if (modified) {
 598                 ret = nspu_command(desc, NSP_CMD_WRITE_ETH_TABLE, 0, 1, entries,
 599                                    0, NSP_ETH_TABLE_SIZE);
 600                 if (!ret)
 601                         RTE_LOG(INFO, PMD,
 602                                 "Hw ethernet port %d configure done\n", port);
 603                 else
 604                         RTE_LOG(INFO, PMD,
 605                                 "Hw ethernet port %d configure failed\n", port);
 606         }
 607         rte_spinlock_unlock(&desc->nsp_lock);
 608         return ret;
 609 }
 610
 611 int
 612 nfp_nsp_eth_read_table(nspu_desc_t *desc, union eth_table_entry **table)
 613 {
 614         int ret;
 615
 616         RTE_LOG(INFO, PMD, "Reading hw ethernet table...\n");
 617         /* port 0 allocates the eth table and read it using NSPU */
 618         *table = malloc(NSP_ETH_TABLE_SIZE);
 619         if (!table)
 620                 return -ENOMEM;
 621
 622         ret = nspu_command(desc, NSP_CMD_READ_ETH_TABLE, 1, 0, *table,
 623                            NSP_ETH_TABLE_SIZE, 0);
 624         if (ret)
 625                 return ret;
 626
 627         RTE_LOG(INFO, PMD, "Done\n");
 628
 629         return 0;
 630 }