drivers/net/ethernet/netronome/nfp/nfp_main.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2015-2018 Netronome Systems, Inc. */
   3
   4 /*
   5  * nfp_main.c
   6  * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
   7  *          Alejandro Lucero <alejandro.lucero@netronome.com>
   8  *          Jason McMullan <jason.mcmullan@netronome.com>
   9  *          Rolf Neugebauer <rolf.neugebauer@netronome.com>
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/mutex.h>
  15 #include <linux/pci.h>
  16 #include <linux/firmware.h>
  17 #include <linux/vermagic.h>
  18 #include <linux/vmalloc.h>
  19 #include <net/devlink.h>
  20
  21 #include "nfpcore/nfp.h"
  22 #include "nfpcore/nfp_cpp.h"
  23 #include "nfpcore/nfp_nffw.h"
  24 #include "nfpcore/nfp_nsp.h"
  25
  26 #include "nfpcore/nfp6000_pcie.h"
  27
  28 #include "nfp_abi.h"
  29 #include "nfp_app.h"
  30 #include "nfp_main.h"
  31 #include "nfp_net.h"
  32
  33 static const char nfp_driver_name[] = "nfp";
  34 const char nfp_driver_version[] = VERMAGIC_STRING;
  35
  36 static const struct pci_device_id nfp_pci_device_ids[] = {
  37         { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NETRONOME_NFP6000,
  38           PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
  39           PCI_ANY_ID, 0,
  40         },
  41         { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NETRONOME_NFP5000,
  42           PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
  43           PCI_ANY_ID, 0,
  44         },
  45         { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NETRONOME_NFP4000,
  46           PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
  47           PCI_ANY_ID, 0,
  48         },
  49         { 0, } /* Required last entry. */
  50 };
  51 MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids);
  52
  53 int nfp_pf_rtsym_read_optional(struct nfp_pf *pf, const char *format,
  54                                unsigned int default_val)
  55 {
  56         char name[256];
  57         int err = 0;
  58         u64 val;
  59
  60         snprintf(name, sizeof(name), format, nfp_cppcore_pcie_unit(pf->cpp));
  61
  62         val = nfp_rtsym_read_le(pf->rtbl, name, &err);
  63         if (err) {
  64                 if (err == -ENOENT)
  65                         return default_val;
  66                 nfp_err(pf->cpp, "Unable to read symbol %s\n", name);
  67                 return err;
  68         }
  69
  70         return val;
  71 }
  72
  73 u8 __iomem *
  74 nfp_pf_map_rtsym(struct nfp_pf *pf, const char *name, const char *sym_fmt,
  75                  unsigned int min_size, struct nfp_cpp_area **area)
  76 {
  77         char pf_symbol[256];
  78
  79         snprintf(pf_symbol, sizeof(pf_symbol), sym_fmt,
  80                  nfp_cppcore_pcie_unit(pf->cpp));
  81
  82         return nfp_rtsym_map(pf->rtbl, pf_symbol, name, min_size, area);
  83 }
  84
  85 /* Callers should hold the devlink instance lock */
  86 int nfp_mbox_cmd(struct nfp_pf *pf, u32 cmd, void *in_data, u64 in_length,
  87                  void *out_data, u64 out_length)
  88 {
  89         unsigned long err_at;
  90         u64 max_data_sz;
  91         u32 val = 0;
  92         int n, err;
  93
  94         if (!pf->mbox)
  95                 return -EOPNOTSUPP;
  96
  97         max_data_sz = nfp_rtsym_size(pf->mbox) - NFP_MBOX_SYM_MIN_SIZE;
  98
  99         /* Check if cmd field is clear */
 100         err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_CMD, &val);
 101         if (err || val) {
 102                 nfp_warn(pf->cpp, "failed to issue command (%u): %u, err: %d\n",
 103                          cmd, val, err);
 104                 return err ?: -EBUSY;
 105         }
 106
 107         in_length = min(in_length, max_data_sz);
 108         n = nfp_rtsym_write(pf->cpp, pf->mbox, NFP_MBOX_DATA, in_data,
 109                             in_length);
 110         if (n != in_length)
 111                 return -EIO;
 112         /* Write data_len and wipe reserved */
 113         err = nfp_rtsym_writeq(pf->cpp, pf->mbox, NFP_MBOX_DATA_LEN, in_length);
 114         if (err)
 115                 return err;
 116
 117         /* Read back for ordering */
 118         err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_DATA_LEN, &val);
 119         if (err)
 120                 return err;
 121
 122         /* Write cmd and wipe return value */
 123         err = nfp_rtsym_writeq(pf->cpp, pf->mbox, NFP_MBOX_CMD, cmd);
 124         if (err)
 125                 return err;
 126
 127         err_at = jiffies + 5 * HZ;
 128         while (true) {
 129                 /* Wait for command to go to 0 (NFP_MBOX_NO_CMD) */
 130                 err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_CMD, &val);
 131                 if (err)
 132                         return err;
 133                 if (!val)
 134                         break;
 135
 136                 if (time_is_before_eq_jiffies(err_at))
 137                         return -ETIMEDOUT;
 138
 139                 msleep(5);
 140         }
 141
 142         /* Copy output if any (could be error info, do it before reading ret) */
 143         err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_DATA_LEN, &val);
 144         if (err)
 145                 return err;
 146
 147         out_length = min_t(u32, val, min(out_length, max_data_sz));
 148         n = nfp_rtsym_read(pf->cpp, pf->mbox, NFP_MBOX_DATA,
 149                            out_data, out_length);
 150         if (n != out_length)
 151                 return -EIO;
 152
 153         /* Check if there is an error */
 154         err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_RET, &val);
 155         if (err)
 156                 return err;
 157         if (val)
 158                 return -val;
 159
 160         return out_length;
 161 }
 162
 163 static bool nfp_board_ready(struct nfp_pf *pf)
 164 {
 165         const char *cp;
 166         long state;
 167         int err;
 168
 169         cp = nfp_hwinfo_lookup(pf->hwinfo, "board.state");
 170         if (!cp)
 171                 return false;
 172
 173         err = kstrtol(cp, 0, &state);
 174         if (err < 0)
 175                 return false;
 176
 177         return state == 15;
 178 }
 179
 180 static int nfp_pf_board_state_wait(struct nfp_pf *pf)
 181 {
 182         const unsigned long wait_until = jiffies + 10 * HZ;
 183
 184         while (!nfp_board_ready(pf)) {
 185                 if (time_is_before_eq_jiffies(wait_until)) {
 186                         nfp_err(pf->cpp, "NFP board initialization timeout\n");
 187                         return -EINVAL;
 188                 }
 189
 190                 nfp_info(pf->cpp, "waiting for board initialization\n");
 191                 if (msleep_interruptible(500))
 192                         return -ERESTARTSYS;
 193
 194                 /* Refresh cached information */
 195                 kfree(pf->hwinfo);
 196                 pf->hwinfo = nfp_hwinfo_read(pf->cpp);
 197         }
 198
 199         return 0;
 200 }
 201
 202 static int nfp_pcie_sriov_read_nfd_limit(struct nfp_pf *pf)
 203 {
 204         int err;
 205
 206         pf->limit_vfs = nfp_rtsym_read_le(pf->rtbl, "nfd_vf_cfg_max_vfs", &err);
 207         if (err) {
 208                 /* For backwards compatibility if symbol not found allow all */
 209                 pf->limit_vfs = ~0;
 210                 if (err == -ENOENT)
 211                         return 0;
 212
 213                 nfp_warn(pf->cpp, "Warning: VF limit read failed: %d\n", err);
 214                 return err;
 215         }
 216
 217         err = pci_sriov_set_totalvfs(pf->pdev, pf->limit_vfs);
 218         if (err)
 219                 nfp_warn(pf->cpp, "Failed to set VF count in sysfs: %d\n", err);
 220         return 0;
 221 }
 222
 223 static int nfp_pcie_sriov_enable(struct pci_dev *pdev, int num_vfs)
 224 {
 225 #ifdef CONFIG_PCI_IOV
 226         struct nfp_pf *pf = pci_get_drvdata(pdev);
 227         int err;
 228
 229         if (num_vfs > pf->limit_vfs) {
 230                 nfp_info(pf->cpp, "Firmware limits number of VFs to %u\n",
 231                          pf->limit_vfs);
 232                 return -EINVAL;
 233         }
 234
 235         err = pci_enable_sriov(pdev, num_vfs);
 236         if (err) {
 237                 dev_warn(&pdev->dev, "Failed to enable PCI SR-IOV: %d\n", err);
 238                 return err;
 239         }
 240
 241         mutex_lock(&pf->lock);
 242
 243         err = nfp_app_sriov_enable(pf->app, num_vfs);
 244         if (err) {
 245                 dev_warn(&pdev->dev,
 246                          "App specific PCI SR-IOV configuration failed: %d\n",
 247                          err);
 248                 goto err_sriov_disable;
 249         }
 250
 251         pf->num_vfs = num_vfs;
 252
 253         dev_dbg(&pdev->dev, "Created %d VFs.\n", pf->num_vfs);
 254
 255         mutex_unlock(&pf->lock);
 256         return num_vfs;
 257
 258 err_sriov_disable:
 259         mutex_unlock(&pf->lock);
 260         pci_disable_sriov(pdev);
 261         return err;
 262 #endif
 263         return 0;
 264 }
 265
 266 static int nfp_pcie_sriov_disable(struct pci_dev *pdev)
 267 {
 268 #ifdef CONFIG_PCI_IOV
 269         struct nfp_pf *pf = pci_get_drvdata(pdev);
 270
 271         mutex_lock(&pf->lock);
 272
 273         /* If the VFs are assigned we cannot shut down SR-IOV without
 274          * causing issues, so just leave the hardware available but
 275          * disabled
 276          */
 277         if (pci_vfs_assigned(pdev)) {
 278                 dev_warn(&pdev->dev, "Disabling while VFs assigned - VFs will not be deallocated\n");
 279                 mutex_unlock(&pf->lock);
 280                 return -EPERM;
 281         }
 282
 283         nfp_app_sriov_disable(pf->app);
 284
 285         pf->num_vfs = 0;
 286
 287         mutex_unlock(&pf->lock);
 288
 289         pci_disable_sriov(pdev);
 290         dev_dbg(&pdev->dev, "Removed VFs.\n");
 291 #endif
 292         return 0;
 293 }
 294
 295 static int nfp_pcie_sriov_configure(struct pci_dev *pdev, int num_vfs)
 296 {
 297         if (!pci_get_drvdata(pdev))
 298                 return -ENOENT;
 299
 300         if (num_vfs == 0)
 301                 return nfp_pcie_sriov_disable(pdev);
 302         else
 303                 return nfp_pcie_sriov_enable(pdev, num_vfs);
 304 }
 305
 306 int nfp_flash_update_common(struct nfp_pf *pf, const char *path,
 307                             struct netlink_ext_ack *extack)
 308 {
 309         struct device *dev = &pf->pdev->dev;
 310         const struct firmware *fw;
 311         struct nfp_nsp *nsp;
 312         int err;
 313
 314         nsp = nfp_nsp_open(pf->cpp);
 315         if (IS_ERR(nsp)) {
 316                 err = PTR_ERR(nsp);
 317                 if (extack)
 318                         NL_SET_ERR_MSG_MOD(extack, "can't access NSP");
 319                 else
 320                         dev_err(dev, "Failed to access the NSP: %d\n", err);
 321                 return err;
 322         }
 323
 324         err = reject_firmware_direct(&fw, path, dev);
 325         if (err) {
 326                 NL_SET_ERR_MSG_MOD(extack,
 327                                    "unable to read flash file from disk");
 328                 goto exit_close_nsp;
 329         }
 330
 331         dev_info(dev, "Please be patient while writing flash image: %s\n",
 332                  path);
 333
 334         err = nfp_nsp_write_flash(nsp, fw);
 335         if (err < 0)
 336                 goto exit_release_fw;
 337         dev_info(dev, "Finished writing flash image\n");
 338         err = 0;
 339
 340 exit_release_fw:
 341         release_firmware(fw);
 342 exit_close_nsp:
 343         nfp_nsp_close(nsp);
 344         return err;
 345 }
 346
 347 static const struct firmware *
 348 nfp_net_fw_request(struct pci_dev *pdev, struct nfp_pf *pf, const char *name)
 349 {
 350         const struct firmware *fw = NULL;
 351         int err;
 352
 353         err = reject_firmware_direct(&fw, name, &pdev->dev);
 354         nfp_info(pf->cpp, "  %s: %s\n",
 355                  name, err ? "not found" : "found, loading...");
 356         if (err)
 357                 return NULL;
 358
 359         return fw;
 360 }
 361
 362 /**
 363  * nfp_net_fw_find() - Find the correct firmware image for netdev mode
 364  * @pdev:       PCI Device structure
 365  * @pf:         NFP PF Device structure
 366  *
 367  * Return: firmware if found and requested successfully.
 368  */
 369 static const struct firmware *
 370 nfp_net_fw_find(struct pci_dev *pdev, struct nfp_pf *pf)
 371 {
 372         struct nfp_eth_table_port *port;
 373         const struct firmware *fw;
 374         const char *fw_model;
 375         char fw_name[256];
 376         const u8 *serial;
 377         u16 interface;
 378         int spc, i, j;
 379
 380         nfp_info(pf->cpp, "Looking for firmware file in order of priority:\n");
 381
 382         /* First try to find a firmware image specific for this device */
 383         interface = nfp_cpp_interface(pf->cpp);
 384         nfp_cpp_serial(pf->cpp, &serial);
 385         sprintf(fw_name, "/*(DEBLOBBED)*/",
 386                 serial, interface >> 8, interface & 0xff);
 387         fw = nfp_net_fw_request(pdev, pf, fw_name);
 388         if (fw)
 389                 return fw;
 390
 391         /* Then try the PCI name */
 392         sprintf(fw_name, "/*(DEBLOBBED)*/", pci_name(pdev));
 393         fw = nfp_net_fw_request(pdev, pf, fw_name);
 394         if (fw)
 395                 return fw;
 396
 397         /* Finally try the card type and media */
 398         if (!pf->eth_tbl) {
 399                 dev_err(&pdev->dev, "Error: can't identify media config\n");
 400                 return NULL;
 401         }
 402
 403         fw_model = nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno");
 404         if (!fw_model) {
 405                 dev_err(&pdev->dev, "Error: can't read part number\n");
 406                 return NULL;
 407         }
 408
 409         spc = ARRAY_SIZE(fw_name);
 410         spc -= snprintf(fw_name, spc, "/*(DEBLOBBED)*/", fw_model);
 411
 412         for (i = 0; spc > 0 && i < pf->eth_tbl->count; i += j) {
 413                 port = &pf->eth_tbl->ports[i];
 414                 j = 1;
 415                 while (i + j < pf->eth_tbl->count &&
 416                        port->speed == port[j].speed)
 417                         j++;
 418
 419                 /*(DEBLOBBED)*/;
 420         }
 421
 422         if (spc <= 0)
 423                 return NULL;
 424
 425         /*(DEBLOBBED)*/;
 426         if (spc <= 0)
 427                 return NULL;
 428
 429         return nfp_net_fw_request(pdev, pf, fw_name);
 430 }
 431
 432 /**
 433  * nfp_net_fw_load() - Load the firmware image
 434  * @pdev:       PCI Device structure
 435  * @pf:         NFP PF Device structure
 436  * @nsp:        NFP SP handle
 437  *
 438  * Return: -ERRNO, 0 for no firmware loaded, 1 for firmware loaded
 439  */
 440 static int
 441 nfp_fw_load(struct pci_dev *pdev, struct nfp_pf *pf, struct nfp_nsp *nsp)
 442 {
 443         const struct firmware *fw;
 444         u16 interface;
 445         int err;
 446
 447         interface = nfp_cpp_interface(pf->cpp);
 448         if (NFP_CPP_INTERFACE_UNIT_of(interface) != 0) {
 449                 /* Only Unit 0 should reset or load firmware */
 450                 dev_info(&pdev->dev, "Firmware will be loaded by partner\n");
 451                 return 0;
 452         }
 453
 454         fw = nfp_net_fw_find(pdev, pf);
 455         if (!fw) {
 456                 if (nfp_nsp_has_stored_fw_load(nsp))
 457                         nfp_nsp_load_stored_fw(nsp);
 458                 return 0;
 459         }
 460
 461         dev_info(&pdev->dev, "Soft-reset, loading FW image\n");
 462         err = nfp_nsp_device_soft_reset(nsp);
 463         if (err < 0) {
 464                 dev_err(&pdev->dev, "Failed to soft reset the NFP: %d\n",
 465                         err);
 466                 goto exit_release_fw;
 467         }
 468
 469         err = nfp_nsp_load_fw(nsp, fw);
 470         if (err < 0) {
 471                 dev_err(&pdev->dev, "FW loading failed: %d\n", err);
 472                 goto exit_release_fw;
 473         }
 474
 475         dev_info(&pdev->dev, "Finished loading FW image\n");
 476
 477 exit_release_fw:
 478         release_firmware(fw);
 479
 480         return err < 0 ? err : 1;
 481 }
 482
 483 static void
 484 nfp_nsp_init_ports(struct pci_dev *pdev, struct nfp_pf *pf,
 485                    struct nfp_nsp *nsp)
 486 {
 487         bool needs_reinit = false;
 488         int i;
 489
 490         pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);
 491         if (!pf->eth_tbl)
 492                 return;
 493
 494         if (!nfp_nsp_has_mac_reinit(nsp))
 495                 return;
 496
 497         for (i = 0; i < pf->eth_tbl->count; i++)
 498                 needs_reinit |= pf->eth_tbl->ports[i].override_changed;
 499         if (!needs_reinit)
 500                 return;
 501
 502         kfree(pf->eth_tbl);
 503         if (nfp_nsp_mac_reinit(nsp))
 504                 dev_warn(&pdev->dev, "MAC reinit failed\n");
 505
 506         pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);
 507 }
 508
 509 static int nfp_nsp_init(struct pci_dev *pdev, struct nfp_pf *pf)
 510 {
 511         struct nfp_nsp *nsp;
 512         int err;
 513
 514         err = nfp_resource_wait(pf->cpp, NFP_RESOURCE_NSP, 30);
 515         if (err)
 516                 return err;
 517
 518         nsp = nfp_nsp_open(pf->cpp);
 519         if (IS_ERR(nsp)) {
 520                 err = PTR_ERR(nsp);
 521                 dev_err(&pdev->dev, "Failed to access the NSP: %d\n", err);
 522                 return err;
 523         }
 524
 525         err = nfp_nsp_wait(nsp);
 526         if (err < 0)
 527                 goto exit_close_nsp;
 528
 529         nfp_nsp_init_ports(pdev, pf, nsp);
 530
 531         pf->nspi = __nfp_nsp_identify(nsp);
 532         if (pf->nspi)
 533                 dev_info(&pdev->dev, "BSP: %s\n", pf->nspi->version);
 534
 535         err = nfp_fw_load(pdev, pf, nsp);
 536         if (err < 0) {
 537                 kfree(pf->nspi);
 538                 kfree(pf->eth_tbl);
 539                 dev_err(&pdev->dev, "Failed to load FW\n");
 540                 goto exit_close_nsp;
 541         }
 542
 543         pf->fw_loaded = !!err;
 544         err = 0;
 545
 546 exit_close_nsp:
 547         nfp_nsp_close(nsp);
 548
 549         return err;
 550 }
 551
 552 static void nfp_fw_unload(struct nfp_pf *pf)
 553 {
 554         struct nfp_nsp *nsp;
 555         int err;
 556
 557         nsp = nfp_nsp_open(pf->cpp);
 558         if (IS_ERR(nsp)) {
 559                 nfp_err(pf->cpp, "Reset failed, can't open NSP\n");
 560                 return;
 561         }
 562
 563         err = nfp_nsp_device_soft_reset(nsp);
 564         if (err < 0)
 565                 dev_warn(&pf->pdev->dev, "Couldn't unload firmware: %d\n", err);
 566         else
 567                 dev_info(&pf->pdev->dev, "Firmware safely unloaded\n");
 568
 569         nfp_nsp_close(nsp);
 570 }
 571
 572 static int nfp_pf_find_rtsyms(struct nfp_pf *pf)
 573 {
 574         char pf_symbol[256];
 575         unsigned int pf_id;
 576
 577         pf_id = nfp_cppcore_pcie_unit(pf->cpp);
 578
 579         /* Optional per-PCI PF mailbox */
 580         snprintf(pf_symbol, sizeof(pf_symbol), NFP_MBOX_SYM_NAME, pf_id);
 581         pf->mbox = nfp_rtsym_lookup(pf->rtbl, pf_symbol);
 582         if (pf->mbox && nfp_rtsym_size(pf->mbox) < NFP_MBOX_SYM_MIN_SIZE) {
 583                 nfp_err(pf->cpp, "PF mailbox symbol too small: %llu < %d\n",
 584                         nfp_rtsym_size(pf->mbox), NFP_MBOX_SYM_MIN_SIZE);
 585                 return -EINVAL;
 586         }
 587
 588         return 0;
 589 }
 590
 591 static int nfp_pci_probe(struct pci_dev *pdev,
 592                          const struct pci_device_id *pci_id)
 593 {
 594         struct devlink *devlink;
 595         struct nfp_pf *pf;
 596         int err;
 597
 598         if (pdev->vendor == PCI_VENDOR_ID_NETRONOME &&
 599             pdev->device == PCI_DEVICE_ID_NETRONOME_NFP6000_VF)
 600                 dev_warn(&pdev->dev, "Binding NFP VF device to the NFP PF driver, the VF driver is called 'nfp_netvf'\n");
 601
 602         err = pci_enable_device(pdev);
 603         if (err < 0)
 604                 return err;
 605
 606         pci_set_master(pdev);
 607
 608         err = dma_set_mask_and_coherent(&pdev->dev,
 609                                         DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS));
 610         if (err)
 611                 goto err_pci_disable;
 612
 613         err = pci_request_regions(pdev, nfp_driver_name);
 614         if (err < 0) {
 615                 dev_err(&pdev->dev, "Unable to reserve pci resources.\n");
 616                 goto err_pci_disable;
 617         }
 618
 619         devlink = devlink_alloc(&nfp_devlink_ops, sizeof(*pf));
 620         if (!devlink) {
 621                 err = -ENOMEM;
 622                 goto err_rel_regions;
 623         }
 624         pf = devlink_priv(devlink);
 625         INIT_LIST_HEAD(&pf->vnics);
 626         INIT_LIST_HEAD(&pf->ports);
 627         mutex_init(&pf->lock);
 628         pci_set_drvdata(pdev, pf);
 629         pf->pdev = pdev;
 630
 631         pf->wq = alloc_workqueue("nfp-%s", 0, 2, pci_name(pdev));
 632         if (!pf->wq) {
 633                 err = -ENOMEM;
 634                 goto err_pci_priv_unset;
 635         }
 636
 637         pf->cpp = nfp_cpp_from_nfp6000_pcie(pdev);
 638         if (IS_ERR_OR_NULL(pf->cpp)) {
 639                 err = PTR_ERR(pf->cpp);
 640                 if (err >= 0)
 641                         err = -ENOMEM;
 642                 goto err_disable_msix;
 643         }
 644
 645         err = nfp_resource_table_init(pf->cpp);
 646         if (err)
 647                 goto err_cpp_free;
 648
 649         pf->hwinfo = nfp_hwinfo_read(pf->cpp);
 650
 651         dev_info(&pdev->dev, "Assembly: %s%s%s-%s CPLD: %s\n",
 652                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.vendor"),
 653                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno"),
 654                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.serial"),
 655                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.revision"),
 656                  nfp_hwinfo_lookup(pf->hwinfo, "cpld.version"));
 657
 658         err = nfp_pf_board_state_wait(pf);
 659         if (err)
 660                 goto err_hwinfo_free;
 661
 662         err = nfp_nsp_init(pdev, pf);
 663         if (err)
 664                 goto err_hwinfo_free;
 665
 666         pf->mip = nfp_mip_open(pf->cpp);
 667         pf->rtbl = __nfp_rtsym_table_read(pf->cpp, pf->mip);
 668
 669         err = nfp_pf_find_rtsyms(pf);
 670         if (err)
 671                 goto err_fw_unload;
 672
 673         pf->dump_flag = NFP_DUMP_NSP_DIAG;
 674         pf->dumpspec = nfp_net_dump_load_dumpspec(pf->cpp, pf->rtbl);
 675
 676         err = nfp_pcie_sriov_read_nfd_limit(pf);
 677         if (err)
 678                 goto err_fw_unload;
 679
 680         pf->num_vfs = pci_num_vf(pdev);
 681         if (pf->num_vfs > pf->limit_vfs) {
 682                 dev_err(&pdev->dev,
 683                         "Error: %d VFs already enabled, but loaded FW can only support %d\n",
 684                         pf->num_vfs, pf->limit_vfs);
 685                 err = -EINVAL;
 686                 goto err_fw_unload;
 687         }
 688
 689         err = nfp_net_pci_probe(pf);
 690         if (err)
 691                 goto err_fw_unload;
 692
 693         err = nfp_hwmon_register(pf);
 694         if (err) {
 695                 dev_err(&pdev->dev, "Failed to register hwmon info\n");
 696                 goto err_net_remove;
 697         }
 698
 699         return 0;
 700
 701 err_net_remove:
 702         nfp_net_pci_remove(pf);
 703 err_fw_unload:
 704         kfree(pf->rtbl);
 705         nfp_mip_close(pf->mip);
 706         if (pf->fw_loaded)
 707                 nfp_fw_unload(pf);
 708         kfree(pf->eth_tbl);
 709         kfree(pf->nspi);
 710         vfree(pf->dumpspec);
 711 err_hwinfo_free:
 712         kfree(pf->hwinfo);
 713 err_cpp_free:
 714         nfp_cpp_free(pf->cpp);
 715 err_disable_msix:
 716         destroy_workqueue(pf->wq);
 717 err_pci_priv_unset:
 718         pci_set_drvdata(pdev, NULL);
 719         mutex_destroy(&pf->lock);
 720         devlink_free(devlink);
 721 err_rel_regions:
 722         pci_release_regions(pdev);
 723 err_pci_disable:
 724         pci_disable_device(pdev);
 725
 726         return err;
 727 }
 728
 729 static void __nfp_pci_shutdown(struct pci_dev *pdev, bool unload_fw)
 730 {
 731         struct nfp_pf *pf;
 732
 733         pf = pci_get_drvdata(pdev);
 734         if (!pf)
 735                 return;
 736
 737         nfp_hwmon_unregister(pf);
 738
 739         nfp_pcie_sriov_disable(pdev);
 740
 741         nfp_net_pci_remove(pf);
 742
 743         vfree(pf->dumpspec);
 744         kfree(pf->rtbl);
 745         nfp_mip_close(pf->mip);
 746         if (unload_fw && pf->fw_loaded)
 747                 nfp_fw_unload(pf);
 748
 749         destroy_workqueue(pf->wq);
 750         pci_set_drvdata(pdev, NULL);
 751         kfree(pf->hwinfo);
 752         nfp_cpp_free(pf->cpp);
 753
 754         kfree(pf->eth_tbl);
 755         kfree(pf->nspi);
 756         mutex_destroy(&pf->lock);
 757         devlink_free(priv_to_devlink(pf));
 758         pci_release_regions(pdev);
 759         pci_disable_device(pdev);
 760 }
 761
 762 static void nfp_pci_remove(struct pci_dev *pdev)
 763 {
 764         __nfp_pci_shutdown(pdev, true);
 765 }
 766
 767 static void nfp_pci_shutdown(struct pci_dev *pdev)
 768 {
 769         __nfp_pci_shutdown(pdev, false);
 770 }
 771
 772 static struct pci_driver nfp_pci_driver = {
 773         .name                   = nfp_driver_name,
 774         .id_table               = nfp_pci_device_ids,
 775         .probe                  = nfp_pci_probe,
 776         .remove                 = nfp_pci_remove,
 777         .shutdown               = nfp_pci_shutdown,
 778         .sriov_configure        = nfp_pcie_sriov_configure,
 779 };
 780
 781 static int __init nfp_main_init(void)
 782 {
 783         int err;
 784
 785         pr_info("%s: NFP PCIe Driver, Copyright (C) 2014-2017 Netronome Systems\n",
 786                 nfp_driver_name);
 787
 788         nfp_net_debugfs_create();
 789
 790         err = pci_register_driver(&nfp_pci_driver);
 791         if (err < 0)
 792                 goto err_destroy_debugfs;
 793
 794         err = pci_register_driver(&nfp_netvf_pci_driver);
 795         if (err)
 796                 goto err_unreg_pf;
 797
 798         return err;
 799
 800 err_unreg_pf:
 801         pci_unregister_driver(&nfp_pci_driver);
 802 err_destroy_debugfs:
 803         nfp_net_debugfs_destroy();
 804         return err;
 805 }
 806
 807 static void __exit nfp_main_exit(void)
 808 {
 809         pci_unregister_driver(&nfp_netvf_pci_driver);
 810         pci_unregister_driver(&nfp_pci_driver);
 811         nfp_net_debugfs_destroy();
 812 }
 813
 814 module_init(nfp_main_init);
 815 module_exit(nfp_main_exit);
 816
 817 /*(DEBLOBBED)*/
 818
 819 MODULE_AUTHOR("Netronome Systems <oss-drivers@netronome.com>");
 820 MODULE_LICENSE("GPL");
 821 MODULE_DESCRIPTION("The Netronome Flow Processor (NFP) driver.");
 822 MODULE_VERSION(UTS_RELEASE);