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

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