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