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                 return pci_sriov_set_totalvfs(pf->pdev, pf->limit_vfs);
 241
 242         pf->limit_vfs = ~0;
 243         pci_sriov_set_totalvfs(pf->pdev, 0); /* 0 is unset */
 244         /* Allow any setting for backwards compatibility if symbol not found */
 245         if (err == -ENOENT)
 246                 return 0;
 247
 248         nfp_warn(pf->cpp, "Warning: VF limit read failed: %d\n", err);
 249         return err;
 250 }
 251
 252 static int nfp_pcie_sriov_enable(struct pci_dev *pdev, int num_vfs)
 253 {
 254 #ifdef CONFIG_PCI_IOV
 255         struct nfp_pf *pf = pci_get_drvdata(pdev);
 256         int err;
 257
 258         if (num_vfs > pf->limit_vfs) {
 259                 nfp_info(pf->cpp, "Firmware limits number of VFs to %u\n",
 260                          pf->limit_vfs);
 261                 return -EINVAL;
 262         }
 263
 264         err = pci_enable_sriov(pdev, num_vfs);
 265         if (err) {
 266                 dev_warn(&pdev->dev, "Failed to enable PCI SR-IOV: %d\n", err);
 267                 return err;
 268         }
 269
 270         mutex_lock(&pf->lock);
 271
 272         err = nfp_app_sriov_enable(pf->app, num_vfs);
 273         if (err) {
 274                 dev_warn(&pdev->dev,
 275                          "App specific PCI SR-IOV configuration failed: %d\n",
 276                          err);
 277                 goto err_sriov_disable;
 278         }
 279
 280         pf->num_vfs = num_vfs;
 281
 282         dev_dbg(&pdev->dev, "Created %d VFs.\n", pf->num_vfs);
 283
 284         mutex_unlock(&pf->lock);
 285         return num_vfs;
 286
 287 err_sriov_disable:
 288         mutex_unlock(&pf->lock);
 289         pci_disable_sriov(pdev);
 290         return err;
 291 #endif
 292         return 0;
 293 }
 294
 295 static int nfp_pcie_sriov_disable(struct pci_dev *pdev)
 296 {
 297 #ifdef CONFIG_PCI_IOV
 298         struct nfp_pf *pf = pci_get_drvdata(pdev);
 299
 300         mutex_lock(&pf->lock);
 301
 302         /* If the VFs are assigned we cannot shut down SR-IOV without
 303          * causing issues, so just leave the hardware available but
 304          * disabled
 305          */
 306         if (pci_vfs_assigned(pdev)) {
 307                 dev_warn(&pdev->dev, "Disabling while VFs assigned - VFs will not be deallocated\n");
 308                 mutex_unlock(&pf->lock);
 309                 return -EPERM;
 310         }
 311
 312         nfp_app_sriov_disable(pf->app);
 313
 314         pf->num_vfs = 0;
 315
 316         mutex_unlock(&pf->lock);
 317
 318         pci_disable_sriov(pdev);
 319         dev_dbg(&pdev->dev, "Removed VFs.\n");
 320 #endif
 321         return 0;
 322 }
 323
 324 static int nfp_pcie_sriov_configure(struct pci_dev *pdev, int num_vfs)
 325 {
 326         if (num_vfs == 0)
 327                 return nfp_pcie_sriov_disable(pdev);
 328         else
 329                 return nfp_pcie_sriov_enable(pdev, num_vfs);
 330 }
 331
 332 static const struct firmware *
 333 nfp_net_fw_request(struct pci_dev *pdev, struct nfp_pf *pf, const char *name)
 334 {
 335         const struct firmware *fw = NULL;
 336         int err;
 337
 338         err = request_firmware_direct(&fw, name, &pdev->dev);
 339         nfp_info(pf->cpp, "  %s: %s\n",
 340                  name, err ? "not found" : "found, loading...");
 341         if (err)
 342                 return NULL;
 343
 344         return fw;
 345 }
 346
 347 /**
 348  * nfp_net_fw_find() - Find the correct firmware image for netdev mode
 349  * @pdev:       PCI Device structure
 350  * @pf:         NFP PF Device structure
 351  *
 352  * Return: firmware if found and requested successfully.
 353  */
 354 static const struct firmware *
 355 nfp_net_fw_find(struct pci_dev *pdev, struct nfp_pf *pf)
 356 {
 357         struct nfp_eth_table_port *port;
 358         const struct firmware *fw;
 359         const char *fw_model;
 360         char fw_name[256];
 361         const u8 *serial;
 362         u16 interface;
 363         int spc, i, j;
 364
 365         nfp_info(pf->cpp, "Looking for firmware file in order of priority:\n");
 366
 367         /* First try to find a firmware image specific for this device */
 368         interface = nfp_cpp_interface(pf->cpp);
 369         nfp_cpp_serial(pf->cpp, &serial);
 370         sprintf(fw_name, "netronome/serial-%pMF-%02hhx-%02hhx.nffw",
 371                 serial, interface >> 8, interface & 0xff);
 372         fw = nfp_net_fw_request(pdev, pf, fw_name);
 373         if (fw)
 374                 return fw;
 375
 376         /* Then try the PCI name */
 377         sprintf(fw_name, "netronome/pci-%s.nffw", pci_name(pdev));
 378         fw = nfp_net_fw_request(pdev, pf, fw_name);
 379         if (fw)
 380                 return fw;
 381
 382         /* Finally try the card type and media */
 383         if (!pf->eth_tbl) {
 384                 dev_err(&pdev->dev, "Error: can't identify media config\n");
 385                 return NULL;
 386         }
 387
 388         fw_model = nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno");
 389         if (!fw_model) {
 390                 dev_err(&pdev->dev, "Error: can't read part number\n");
 391                 return NULL;
 392         }
 393
 394         spc = ARRAY_SIZE(fw_name);
 395         spc -= snprintf(fw_name, spc, "netronome/nic_%s", fw_model);
 396
 397         for (i = 0; spc > 0 && i < pf->eth_tbl->count; i += j) {
 398                 port = &pf->eth_tbl->ports[i];
 399                 j = 1;
 400                 while (i + j < pf->eth_tbl->count &&
 401                        port->speed == port[j].speed)
 402                         j++;
 403
 404                 spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc,
 405                                 "_%dx%d", j, port->speed / 1000);
 406         }
 407
 408         if (spc <= 0)
 409                 return NULL;
 410
 411         spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc, ".nffw");
 412         if (spc <= 0)
 413                 return NULL;
 414
 415         return nfp_net_fw_request(pdev, pf, fw_name);
 416 }
 417
 418 /**
 419  * nfp_net_fw_load() - Load the firmware image
 420  * @pdev:       PCI Device structure
 421  * @pf:         NFP PF Device structure
 422  * @nsp:        NFP SP handle
 423  *
 424  * Return: -ERRNO, 0 for no firmware loaded, 1 for firmware loaded
 425  */
 426 static int
 427 nfp_fw_load(struct pci_dev *pdev, struct nfp_pf *pf, struct nfp_nsp *nsp)
 428 {
 429         const struct firmware *fw;
 430         u16 interface;
 431         int err;
 432
 433         interface = nfp_cpp_interface(pf->cpp);
 434         if (NFP_CPP_INTERFACE_UNIT_of(interface) != 0) {
 435                 /* Only Unit 0 should reset or load firmware */
 436                 dev_info(&pdev->dev, "Firmware will be loaded by partner\n");
 437                 return 0;
 438         }
 439
 440         fw = nfp_net_fw_find(pdev, pf);
 441         if (!fw)
 442                 return 0;
 443
 444         dev_info(&pdev->dev, "Soft-reset, loading FW image\n");
 445         err = nfp_nsp_device_soft_reset(nsp);
 446         if (err < 0) {
 447                 dev_err(&pdev->dev, "Failed to soft reset the NFP: %d\n",
 448                         err);
 449                 goto exit_release_fw;
 450         }
 451
 452         err = nfp_nsp_load_fw(nsp, fw);
 453
 454         if (err < 0) {
 455                 dev_err(&pdev->dev, "FW loading failed: %d\n", err);
 456                 goto exit_release_fw;
 457         }
 458
 459         dev_info(&pdev->dev, "Finished loading FW image\n");
 460
 461 exit_release_fw:
 462         release_firmware(fw);
 463
 464         return err < 0 ? err : 1;
 465 }
 466
 467 static void
 468 nfp_nsp_init_ports(struct pci_dev *pdev, struct nfp_pf *pf,
 469                    struct nfp_nsp *nsp)
 470 {
 471         bool needs_reinit = false;
 472         int i;
 473
 474         pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);
 475         if (!pf->eth_tbl)
 476                 return;
 477
 478         if (!nfp_nsp_has_mac_reinit(nsp))
 479                 return;
 480
 481         for (i = 0; i < pf->eth_tbl->count; i++)
 482                 needs_reinit |= pf->eth_tbl->ports[i].override_changed;
 483         if (!needs_reinit)
 484                 return;
 485
 486         kfree(pf->eth_tbl);
 487         if (nfp_nsp_mac_reinit(nsp))
 488                 dev_warn(&pdev->dev, "MAC reinit failed\n");
 489
 490         pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);
 491 }
 492
 493 static int nfp_nsp_init(struct pci_dev *pdev, struct nfp_pf *pf)
 494 {
 495         struct nfp_nsp *nsp;
 496         int err;
 497
 498         err = nfp_resource_wait(pf->cpp, NFP_RESOURCE_NSP, 30);
 499         if (err)
 500                 return err;
 501
 502         nsp = nfp_nsp_open(pf->cpp);
 503         if (IS_ERR(nsp)) {
 504                 err = PTR_ERR(nsp);
 505                 dev_err(&pdev->dev, "Failed to access the NSP: %d\n", err);
 506                 return err;
 507         }
 508
 509         err = nfp_nsp_wait(nsp);
 510         if (err < 0)
 511                 goto exit_close_nsp;
 512
 513         nfp_nsp_init_ports(pdev, pf, nsp);
 514
 515         pf->nspi = __nfp_nsp_identify(nsp);
 516         if (pf->nspi)
 517                 dev_info(&pdev->dev, "BSP: %s\n", pf->nspi->version);
 518
 519         err = nfp_fw_load(pdev, pf, nsp);
 520         if (err < 0) {
 521                 kfree(pf->nspi);
 522                 kfree(pf->eth_tbl);
 523                 dev_err(&pdev->dev, "Failed to load FW\n");
 524                 goto exit_close_nsp;
 525         }
 526
 527         pf->fw_loaded = !!err;
 528         err = 0;
 529
 530 exit_close_nsp:
 531         nfp_nsp_close(nsp);
 532
 533         return err;
 534 }
 535
 536 static void nfp_fw_unload(struct nfp_pf *pf)
 537 {
 538         struct nfp_nsp *nsp;
 539         int err;
 540
 541         nsp = nfp_nsp_open(pf->cpp);
 542         if (IS_ERR(nsp)) {
 543                 nfp_err(pf->cpp, "Reset failed, can't open NSP\n");
 544                 return;
 545         }
 546
 547         err = nfp_nsp_device_soft_reset(nsp);
 548         if (err < 0)
 549                 dev_warn(&pf->pdev->dev, "Couldn't unload firmware: %d\n", err);
 550         else
 551                 dev_info(&pf->pdev->dev, "Firmware safely unloaded\n");
 552
 553         nfp_nsp_close(nsp);
 554 }
 555
 556 static int nfp_pf_find_rtsyms(struct nfp_pf *pf)
 557 {
 558         char pf_symbol[256];
 559         unsigned int pf_id;
 560
 561         pf_id = nfp_cppcore_pcie_unit(pf->cpp);
 562
 563         /* Optional per-PCI PF mailbox */
 564         snprintf(pf_symbol, sizeof(pf_symbol), NFP_MBOX_SYM_NAME, pf_id);
 565         pf->mbox = nfp_rtsym_lookup(pf->rtbl, pf_symbol);
 566         if (pf->mbox && pf->mbox->size < NFP_MBOX_SYM_MIN_SIZE) {
 567                 nfp_err(pf->cpp, "PF mailbox symbol too small: %llu < %d\n",
 568                         pf->mbox->size, NFP_MBOX_SYM_MIN_SIZE);
 569                 return -EINVAL;
 570         }
 571
 572         return 0;
 573 }
 574
 575 static int nfp_pci_probe(struct pci_dev *pdev,
 576                          const struct pci_device_id *pci_id)
 577 {
 578         struct devlink *devlink;
 579         struct nfp_pf *pf;
 580         int err;
 581
 582         err = pci_enable_device(pdev);
 583         if (err < 0)
 584                 return err;
 585
 586         pci_set_master(pdev);
 587
 588         err = dma_set_mask_and_coherent(&pdev->dev,
 589                                         DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS));
 590         if (err)
 591                 goto err_pci_disable;
 592
 593         err = pci_request_regions(pdev, nfp_driver_name);
 594         if (err < 0) {
 595                 dev_err(&pdev->dev, "Unable to reserve pci resources.\n");
 596                 goto err_pci_disable;
 597         }
 598
 599         devlink = devlink_alloc(&nfp_devlink_ops, sizeof(*pf));
 600         if (!devlink) {
 601                 err = -ENOMEM;
 602                 goto err_rel_regions;
 603         }
 604         pf = devlink_priv(devlink);
 605         INIT_LIST_HEAD(&pf->vnics);
 606         INIT_LIST_HEAD(&pf->ports);
 607         mutex_init(&pf->lock);
 608         pci_set_drvdata(pdev, pf);
 609         pf->pdev = pdev;
 610
 611         pf->wq = alloc_workqueue("nfp-%s", 0, 2, pci_name(pdev));
 612         if (!pf->wq) {
 613                 err = -ENOMEM;
 614                 goto err_pci_priv_unset;
 615         }
 616
 617         pf->cpp = nfp_cpp_from_nfp6000_pcie(pdev);
 618         if (IS_ERR_OR_NULL(pf->cpp)) {
 619                 err = PTR_ERR(pf->cpp);
 620                 if (err >= 0)
 621                         err = -ENOMEM;
 622                 goto err_disable_msix;
 623         }
 624
 625         err = nfp_resource_table_init(pf->cpp);
 626         if (err)
 627                 goto err_cpp_free;
 628
 629         pf->hwinfo = nfp_hwinfo_read(pf->cpp);
 630
 631         dev_info(&pdev->dev, "Assembly: %s%s%s-%s CPLD: %s\n",
 632                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.vendor"),
 633                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno"),
 634                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.serial"),
 635                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.revision"),
 636                  nfp_hwinfo_lookup(pf->hwinfo, "cpld.version"));
 637
 638         err = nfp_pf_board_state_wait(pf);
 639         if (err)
 640                 goto err_hwinfo_free;
 641
 642         err = nfp_nsp_init(pdev, pf);
 643         if (err)
 644                 goto err_hwinfo_free;
 645
 646         pf->mip = nfp_mip_open(pf->cpp);
 647         pf->rtbl = __nfp_rtsym_table_read(pf->cpp, pf->mip);
 648
 649         err = nfp_pf_find_rtsyms(pf);
 650         if (err)
 651                 goto err_fw_unload;
 652
 653         pf->dump_flag = NFP_DUMP_NSP_DIAG;
 654         pf->dumpspec = nfp_net_dump_load_dumpspec(pf->cpp, pf->rtbl);
 655
 656         err = nfp_pcie_sriov_read_nfd_limit(pf);
 657         if (err)
 658                 goto err_fw_unload;
 659
 660         pf->num_vfs = pci_num_vf(pdev);
 661         if (pf->num_vfs > pf->limit_vfs) {
 662                 dev_err(&pdev->dev,
 663                         "Error: %d VFs already enabled, but loaded FW can only support %d\n",
 664                         pf->num_vfs, pf->limit_vfs);
 665                 err = -EINVAL;
 666                 goto err_fw_unload;
 667         }
 668
 669         err = nfp_net_pci_probe(pf);
 670         if (err)
 671                 goto err_sriov_unlimit;
 672
 673         err = nfp_hwmon_register(pf);
 674         if (err) {
 675                 dev_err(&pdev->dev, "Failed to register hwmon info\n");
 676                 goto err_net_remove;
 677         }
 678
 679         return 0;
 680
 681 err_net_remove:
 682         nfp_net_pci_remove(pf);
 683 err_sriov_unlimit:
 684         pci_sriov_set_totalvfs(pf->pdev, 0);
 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         pci_sriov_set_totalvfs(pf->pdev, 0);
 719
 720         nfp_net_pci_remove(pf);
 721
 722         vfree(pf->dumpspec);
 723         kfree(pf->rtbl);
 724         nfp_mip_close(pf->mip);
 725         if (pf->fw_loaded)
 726                 nfp_fw_unload(pf);
 727
 728         destroy_workqueue(pf->wq);
 729         pci_set_drvdata(pdev, NULL);
 730         kfree(pf->hwinfo);
 731         nfp_cpp_free(pf->cpp);
 732
 733         kfree(pf->eth_tbl);
 734         kfree(pf->nspi);
 735         mutex_destroy(&pf->lock);
 736         devlink_free(priv_to_devlink(pf));
 737         pci_release_regions(pdev);
 738         pci_disable_device(pdev);
 739 }
 740
 741 static struct pci_driver nfp_pci_driver = {
 742         .name                   = nfp_driver_name,
 743         .id_table               = nfp_pci_device_ids,
 744         .probe                  = nfp_pci_probe,
 745         .remove                 = nfp_pci_remove,
 746         .sriov_configure        = nfp_pcie_sriov_configure,
 747 };
 748
 749 static int __init nfp_main_init(void)
 750 {
 751         int err;
 752
 753         pr_info("%s: NFP PCIe Driver, Copyright (C) 2014-2017 Netronome Systems\n",
 754                 nfp_driver_name);
 755
 756         nfp_net_debugfs_create();
 757
 758         err = pci_register_driver(&nfp_pci_driver);
 759         if (err < 0)
 760                 goto err_destroy_debugfs;
 761
 762         err = pci_register_driver(&nfp_netvf_pci_driver);
 763         if (err)
 764                 goto err_unreg_pf;
 765
 766         return err;
 767
 768 err_unreg_pf:
 769         pci_unregister_driver(&nfp_pci_driver);
 770 err_destroy_debugfs:
 771         nfp_net_debugfs_destroy();
 772         return err;
 773 }
 774
 775 static void __exit nfp_main_exit(void)
 776 {
 777         pci_unregister_driver(&nfp_netvf_pci_driver);
 778         pci_unregister_driver(&nfp_pci_driver);
 779         nfp_net_debugfs_destroy();
 780 }
 781
 782 module_init(nfp_main_init);
 783 module_exit(nfp_main_exit);
 784
 785 MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_1x40.nffw");
 786 MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_4x10.nffw");
 787 MODULE_FIRMWARE("netronome/nic_AMDA0096-0001_2x10.nffw");
 788 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_2x40.nffw");
 789 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_4x10_1x40.nffw");
 790 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_8x10.nffw");
 791 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x10.nffw");
 792 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x25.nffw");
 793 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_1x10_1x25.nffw");
 794
 795 MODULE_AUTHOR("Netronome Systems <oss-drivers@netronome.com>");
 796 MODULE_LICENSE("GPL");
 797 MODULE_DESCRIPTION("The Netronome Flow Processor (NFP) driver.");
 798 MODULE_VERSION(UTS_RELEASE);