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 = request_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 = request_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, "netronome/serial-%pMF-%02hhx-%02hhx.nffw",
 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, "netronome/pci-%s.nffw", 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, "netronome/nic_%s", 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                 spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc,
 420                                 "_%dx%d", j, port->speed / 1000);
 421         }
 422
 423         if (spc <= 0)
 424                 return NULL;
 425
 426         spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc, ".nffw");
 427         if (spc <= 0)
 428                 return NULL;
 429
 430         return nfp_net_fw_request(pdev, pf, fw_name);
 431 }
 432
 433 /**
 434  * nfp_net_fw_load() - Load the firmware image
 435  * @pdev:       PCI Device structure
 436  * @pf:         NFP PF Device structure
 437  * @nsp:        NFP SP handle
 438  *
 439  * Return: -ERRNO, 0 for no firmware loaded, 1 for firmware loaded
 440  */
 441 static int
 442 nfp_fw_load(struct pci_dev *pdev, struct nfp_pf *pf, struct nfp_nsp *nsp)
 443 {
 444         const struct firmware *fw;
 445         u16 interface;
 446         int err;
 447
 448         interface = nfp_cpp_interface(pf->cpp);
 449         if (NFP_CPP_INTERFACE_UNIT_of(interface) != 0) {
 450                 /* Only Unit 0 should reset or load firmware */
 451                 dev_info(&pdev->dev, "Firmware will be loaded by partner\n");
 452                 return 0;
 453         }
 454
 455         fw = nfp_net_fw_find(pdev, pf);
 456         if (!fw) {
 457                 if (nfp_nsp_has_stored_fw_load(nsp))
 458                         nfp_nsp_load_stored_fw(nsp);
 459                 return 0;
 460         }
 461
 462         dev_info(&pdev->dev, "Soft-reset, loading FW image\n");
 463         err = nfp_nsp_device_soft_reset(nsp);
 464         if (err < 0) {
 465                 dev_err(&pdev->dev, "Failed to soft reset the NFP: %d\n",
 466                         err);
 467                 goto exit_release_fw;
 468         }
 469
 470         err = nfp_nsp_load_fw(nsp, fw);
 471         if (err < 0) {
 472                 dev_err(&pdev->dev, "FW loading failed: %d\n", err);
 473                 goto exit_release_fw;
 474         }
 475
 476         dev_info(&pdev->dev, "Finished loading FW image\n");
 477
 478 exit_release_fw:
 479         release_firmware(fw);
 480
 481         return err < 0 ? err : 1;
 482 }
 483
 484 static void
 485 nfp_nsp_init_ports(struct pci_dev *pdev, struct nfp_pf *pf,
 486                    struct nfp_nsp *nsp)
 487 {
 488         bool needs_reinit = false;
 489         int i;
 490
 491         pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);
 492         if (!pf->eth_tbl)
 493                 return;
 494
 495         if (!nfp_nsp_has_mac_reinit(nsp))
 496                 return;
 497
 498         for (i = 0; i < pf->eth_tbl->count; i++)
 499                 needs_reinit |= pf->eth_tbl->ports[i].override_changed;
 500         if (!needs_reinit)
 501                 return;
 502
 503         kfree(pf->eth_tbl);
 504         if (nfp_nsp_mac_reinit(nsp))
 505                 dev_warn(&pdev->dev, "MAC reinit failed\n");
 506
 507         pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);
 508 }
 509
 510 static int nfp_nsp_init(struct pci_dev *pdev, struct nfp_pf *pf)
 511 {
 512         struct nfp_nsp *nsp;
 513         int err;
 514
 515         err = nfp_resource_wait(pf->cpp, NFP_RESOURCE_NSP, 30);
 516         if (err)
 517                 return err;
 518
 519         nsp = nfp_nsp_open(pf->cpp);
 520         if (IS_ERR(nsp)) {
 521                 err = PTR_ERR(nsp);
 522                 dev_err(&pdev->dev, "Failed to access the NSP: %d\n", err);
 523                 return err;
 524         }
 525
 526         err = nfp_nsp_wait(nsp);
 527         if (err < 0)
 528                 goto exit_close_nsp;
 529
 530         nfp_nsp_init_ports(pdev, pf, nsp);
 531
 532         pf->nspi = __nfp_nsp_identify(nsp);
 533         if (pf->nspi)
 534                 dev_info(&pdev->dev, "BSP: %s\n", pf->nspi->version);
 535
 536         err = nfp_fw_load(pdev, pf, nsp);
 537         if (err < 0) {
 538                 kfree(pf->nspi);
 539                 kfree(pf->eth_tbl);
 540                 dev_err(&pdev->dev, "Failed to load FW\n");
 541                 goto exit_close_nsp;
 542         }
 543
 544         pf->fw_loaded = !!err;
 545         err = 0;
 546
 547 exit_close_nsp:
 548         nfp_nsp_close(nsp);
 549
 550         return err;
 551 }
 552
 553 static void nfp_fw_unload(struct nfp_pf *pf)
 554 {
 555         struct nfp_nsp *nsp;
 556         int err;
 557
 558         nsp = nfp_nsp_open(pf->cpp);
 559         if (IS_ERR(nsp)) {
 560                 nfp_err(pf->cpp, "Reset failed, can't open NSP\n");
 561                 return;
 562         }
 563
 564         err = nfp_nsp_device_soft_reset(nsp);
 565         if (err < 0)
 566                 dev_warn(&pf->pdev->dev, "Couldn't unload firmware: %d\n", err);
 567         else
 568                 dev_info(&pf->pdev->dev, "Firmware safely unloaded\n");
 569
 570         nfp_nsp_close(nsp);
 571 }
 572
 573 static int nfp_pf_find_rtsyms(struct nfp_pf *pf)
 574 {
 575         char pf_symbol[256];
 576         unsigned int pf_id;
 577
 578         pf_id = nfp_cppcore_pcie_unit(pf->cpp);
 579
 580         /* Optional per-PCI PF mailbox */
 581         snprintf(pf_symbol, sizeof(pf_symbol), NFP_MBOX_SYM_NAME, pf_id);
 582         pf->mbox = nfp_rtsym_lookup(pf->rtbl, pf_symbol);
 583         if (pf->mbox && nfp_rtsym_size(pf->mbox) < NFP_MBOX_SYM_MIN_SIZE) {
 584                 nfp_err(pf->cpp, "PF mailbox symbol too small: %llu < %d\n",
 585                         nfp_rtsym_size(pf->mbox), NFP_MBOX_SYM_MIN_SIZE);
 586                 return -EINVAL;
 587         }
 588
 589         return 0;
 590 }
 591
 592 static int nfp_pci_probe(struct pci_dev *pdev,
 593                          const struct pci_device_id *pci_id)
 594 {
 595         struct devlink *devlink;
 596         struct nfp_pf *pf;
 597         int err;
 598
 599         if (pdev->vendor == PCI_VENDOR_ID_NETRONOME &&
 600             pdev->device == PCI_DEVICE_ID_NETRONOME_NFP6000_VF)
 601                 dev_warn(&pdev->dev, "Binding NFP VF device to the NFP PF driver, the VF driver is called 'nfp_netvf'\n");
 602
 603         err = pci_enable_device(pdev);
 604         if (err < 0)
 605                 return err;
 606
 607         pci_set_master(pdev);
 608
 609         err = dma_set_mask_and_coherent(&pdev->dev,
 610                                         DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS));
 611         if (err)
 612                 goto err_pci_disable;
 613
 614         err = pci_request_regions(pdev, nfp_driver_name);
 615         if (err < 0) {
 616                 dev_err(&pdev->dev, "Unable to reserve pci resources.\n");
 617                 goto err_pci_disable;
 618         }
 619
 620         devlink = devlink_alloc(&nfp_devlink_ops, sizeof(*pf));
 621         if (!devlink) {
 622                 err = -ENOMEM;
 623                 goto err_rel_regions;
 624         }
 625         pf = devlink_priv(devlink);
 626         INIT_LIST_HEAD(&pf->vnics);
 627         INIT_LIST_HEAD(&pf->ports);
 628         mutex_init(&pf->lock);
 629         pci_set_drvdata(pdev, pf);
 630         pf->pdev = pdev;
 631
 632         pf->wq = alloc_workqueue("nfp-%s", 0, 2, pci_name(pdev));
 633         if (!pf->wq) {
 634                 err = -ENOMEM;
 635                 goto err_pci_priv_unset;
 636         }
 637
 638         pf->cpp = nfp_cpp_from_nfp6000_pcie(pdev);
 639         if (IS_ERR_OR_NULL(pf->cpp)) {
 640                 err = PTR_ERR(pf->cpp);
 641                 if (err >= 0)
 642                         err = -ENOMEM;
 643                 goto err_disable_msix;
 644         }
 645
 646         err = nfp_resource_table_init(pf->cpp);
 647         if (err)
 648                 goto err_cpp_free;
 649
 650         pf->hwinfo = nfp_hwinfo_read(pf->cpp);
 651
 652         dev_info(&pdev->dev, "Assembly: %s%s%s-%s CPLD: %s\n",
 653                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.vendor"),
 654                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno"),
 655                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.serial"),
 656                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.revision"),
 657                  nfp_hwinfo_lookup(pf->hwinfo, "cpld.version"));
 658
 659         err = nfp_pf_board_state_wait(pf);
 660         if (err)
 661                 goto err_hwinfo_free;
 662
 663         err = nfp_nsp_init(pdev, pf);
 664         if (err)
 665                 goto err_hwinfo_free;
 666
 667         pf->mip = nfp_mip_open(pf->cpp);
 668         pf->rtbl = __nfp_rtsym_table_read(pf->cpp, pf->mip);
 669
 670         err = nfp_pf_find_rtsyms(pf);
 671         if (err)
 672                 goto err_fw_unload;
 673
 674         pf->dump_flag = NFP_DUMP_NSP_DIAG;
 675         pf->dumpspec = nfp_net_dump_load_dumpspec(pf->cpp, pf->rtbl);
 676
 677         err = nfp_pcie_sriov_read_nfd_limit(pf);
 678         if (err)
 679                 goto err_fw_unload;
 680
 681         pf->num_vfs = pci_num_vf(pdev);
 682         if (pf->num_vfs > pf->limit_vfs) {
 683                 dev_err(&pdev->dev,
 684                         "Error: %d VFs already enabled, but loaded FW can only support %d\n",
 685                         pf->num_vfs, pf->limit_vfs);
 686                 err = -EINVAL;
 687                 goto err_fw_unload;
 688         }
 689
 690         err = nfp_net_pci_probe(pf);
 691         if (err)
 692                 goto err_fw_unload;
 693
 694         err = nfp_hwmon_register(pf);
 695         if (err) {
 696                 dev_err(&pdev->dev, "Failed to register hwmon info\n");
 697                 goto err_net_remove;
 698         }
 699
 700         return 0;
 701
 702 err_net_remove:
 703         nfp_net_pci_remove(pf);
 704 err_fw_unload:
 705         kfree(pf->rtbl);
 706         nfp_mip_close(pf->mip);
 707         if (pf->fw_loaded)
 708                 nfp_fw_unload(pf);
 709         kfree(pf->eth_tbl);
 710         kfree(pf->nspi);
 711         vfree(pf->dumpspec);
 712 err_hwinfo_free:
 713         kfree(pf->hwinfo);
 714 err_cpp_free:
 715         nfp_cpp_free(pf->cpp);
 716 err_disable_msix:
 717         destroy_workqueue(pf->wq);
 718 err_pci_priv_unset:
 719         pci_set_drvdata(pdev, NULL);
 720         mutex_destroy(&pf->lock);
 721         devlink_free(devlink);
 722 err_rel_regions:
 723         pci_release_regions(pdev);
 724 err_pci_disable:
 725         pci_disable_device(pdev);
 726
 727         return err;
 728 }
 729
 730 static void __nfp_pci_shutdown(struct pci_dev *pdev, bool unload_fw)
 731 {
 732         struct nfp_pf *pf;
 733
 734         pf = pci_get_drvdata(pdev);
 735         if (!pf)
 736                 return;
 737
 738         nfp_hwmon_unregister(pf);
 739
 740         nfp_pcie_sriov_disable(pdev);
 741
 742         nfp_net_pci_remove(pf);
 743
 744         vfree(pf->dumpspec);
 745         kfree(pf->rtbl);
 746         nfp_mip_close(pf->mip);
 747         if (unload_fw && pf->fw_loaded)
 748                 nfp_fw_unload(pf);
 749
 750         destroy_workqueue(pf->wq);
 751         pci_set_drvdata(pdev, NULL);
 752         kfree(pf->hwinfo);
 753         nfp_cpp_free(pf->cpp);
 754
 755         kfree(pf->eth_tbl);
 756         kfree(pf->nspi);
 757         mutex_destroy(&pf->lock);
 758         devlink_free(priv_to_devlink(pf));
 759         pci_release_regions(pdev);
 760         pci_disable_device(pdev);
 761 }
 762
 763 static void nfp_pci_remove(struct pci_dev *pdev)
 764 {
 765         __nfp_pci_shutdown(pdev, true);
 766 }
 767
 768 static void nfp_pci_shutdown(struct pci_dev *pdev)
 769 {
 770         __nfp_pci_shutdown(pdev, false);
 771 }
 772
 773 static struct pci_driver nfp_pci_driver = {
 774         .name                   = nfp_driver_name,
 775         .id_table               = nfp_pci_device_ids,
 776         .probe                  = nfp_pci_probe,
 777         .remove                 = nfp_pci_remove,
 778         .shutdown               = nfp_pci_shutdown,
 779         .sriov_configure        = nfp_pcie_sriov_configure,
 780 };
 781
 782 static int __init nfp_main_init(void)
 783 {
 784         int err;
 785
 786         pr_info("%s: NFP PCIe Driver, Copyright (C) 2014-2017 Netronome Systems\n",
 787                 nfp_driver_name);
 788
 789         nfp_net_debugfs_create();
 790
 791         err = pci_register_driver(&nfp_pci_driver);
 792         if (err < 0)
 793                 goto err_destroy_debugfs;
 794
 795         err = pci_register_driver(&nfp_netvf_pci_driver);
 796         if (err)
 797                 goto err_unreg_pf;
 798
 799         return err;
 800
 801 err_unreg_pf:
 802         pci_unregister_driver(&nfp_pci_driver);
 803 err_destroy_debugfs:
 804         nfp_net_debugfs_destroy();
 805         return err;
 806 }
 807
 808 static void __exit nfp_main_exit(void)
 809 {
 810         pci_unregister_driver(&nfp_netvf_pci_driver);
 811         pci_unregister_driver(&nfp_pci_driver);
 812         nfp_net_debugfs_destroy();
 813 }
 814
 815 module_init(nfp_main_init);
 816 module_exit(nfp_main_exit);
 817
 818 MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_1x40.nffw");
 819 MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_4x10.nffw");
 820 MODULE_FIRMWARE("netronome/nic_AMDA0096-0001_2x10.nffw");
 821 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_2x40.nffw");
 822 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_4x10_1x40.nffw");
 823 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_8x10.nffw");
 824 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x10.nffw");
 825 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x25.nffw");
 826 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_1x10_1x25.nffw");
 827
 828 MODULE_AUTHOR("Netronome Systems <oss-drivers@netronome.com>");
 829 MODULE_LICENSE("GPL");
 830 MODULE_DESCRIPTION("The Netronome Flow Processor (NFP) driver.");
 831 MODULE_VERSION(UTS_RELEASE);