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