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