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_NFP5000, 72 PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID, 73 PCI_ANY_ID, 0, 74 }, 75 { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NETRONOME_NFP4000, 76 PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID, 77 PCI_ANY_ID, 0, 78 }, 79 { 0, } /* Required last entry. */ 80 }; 81 MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids); 82 83 int nfp_pf_rtsym_read_optional(struct nfp_pf *pf, const char *format, 84 unsigned int default_val) 85 { 86 char name[256]; 87 int err = 0; 88 u64 val; 89 90 snprintf(name, sizeof(name), format, nfp_cppcore_pcie_unit(pf->cpp)); 91 92 val = nfp_rtsym_read_le(pf->rtbl, name, &err); 93 if (err) { 94 if (err == -ENOENT) 95 return default_val; 96 nfp_err(pf->cpp, "Unable to read symbol %s\n", name); 97 return err; 98 } 99 100 return val; 101 } 102 103 u8 __iomem * 104 nfp_pf_map_rtsym(struct nfp_pf *pf, const char *name, const char *sym_fmt, 105 unsigned int min_size, struct nfp_cpp_area **area) 106 { 107 char pf_symbol[256]; 108 109 snprintf(pf_symbol, sizeof(pf_symbol), sym_fmt, 110 nfp_cppcore_pcie_unit(pf->cpp)); 111 112 return nfp_rtsym_map(pf->rtbl, pf_symbol, name, min_size, area); 113 } 114 115 /* Callers should hold the devlink instance lock */ 116 int nfp_mbox_cmd(struct nfp_pf *pf, u32 cmd, void *in_data, u64 in_length, 117 void *out_data, u64 out_length) 118 { 119 unsigned long err_at; 120 u64 max_data_sz; 121 u32 val = 0; 122 int n, err; 123 124 if (!pf->mbox) 125 return -EOPNOTSUPP; 126 127 max_data_sz = nfp_rtsym_size(pf->mbox) - NFP_MBOX_SYM_MIN_SIZE; 128 129 /* Check if cmd field is clear */ 130 err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_CMD, &val); 131 if (err || val) { 132 nfp_warn(pf->cpp, "failed to issue command (%u): %u, err: %d\n", 133 cmd, val, err); 134 return err ?: -EBUSY; 135 } 136 137 in_length = min(in_length, max_data_sz); 138 n = nfp_rtsym_write(pf->cpp, pf->mbox, NFP_MBOX_DATA, in_data, 139 in_length); 140 if (n != in_length) 141 return -EIO; 142 /* Write data_len and wipe reserved */ 143 err = nfp_rtsym_writeq(pf->cpp, pf->mbox, NFP_MBOX_DATA_LEN, in_length); 144 if (err) 145 return err; 146 147 /* Read back for ordering */ 148 err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_DATA_LEN, &val); 149 if (err) 150 return err; 151 152 /* Write cmd and wipe return value */ 153 err = nfp_rtsym_writeq(pf->cpp, pf->mbox, NFP_MBOX_CMD, cmd); 154 if (err) 155 return err; 156 157 err_at = jiffies + 5 * HZ; 158 while (true) { 159 /* Wait for command to go to 0 (NFP_MBOX_NO_CMD) */ 160 err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_CMD, &val); 161 if (err) 162 return err; 163 if (!val) 164 break; 165 166 if (time_is_before_eq_jiffies(err_at)) 167 return -ETIMEDOUT; 168 169 msleep(5); 170 } 171 172 /* Copy output if any (could be error info, do it before reading ret) */ 173 err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_DATA_LEN, &val); 174 if (err) 175 return err; 176 177 out_length = min_t(u32, val, min(out_length, max_data_sz)); 178 n = nfp_rtsym_read(pf->cpp, pf->mbox, NFP_MBOX_DATA, 179 out_data, out_length); 180 if (n != out_length) 181 return -EIO; 182 183 /* Check if there is an error */ 184 err = nfp_rtsym_readl(pf->cpp, pf->mbox, NFP_MBOX_RET, &val); 185 if (err) 186 return err; 187 if (val) 188 return -val; 189 190 return out_length; 191 } 192 193 static bool nfp_board_ready(struct nfp_pf *pf) 194 { 195 const char *cp; 196 long state; 197 int err; 198 199 cp = nfp_hwinfo_lookup(pf->hwinfo, "board.state"); 200 if (!cp) 201 return false; 202 203 err = kstrtol(cp, 0, &state); 204 if (err < 0) 205 return false; 206 207 return state == 15; 208 } 209 210 static int nfp_pf_board_state_wait(struct nfp_pf *pf) 211 { 212 const unsigned long wait_until = jiffies + 10 * HZ; 213 214 while (!nfp_board_ready(pf)) { 215 if (time_is_before_eq_jiffies(wait_until)) { 216 nfp_err(pf->cpp, "NFP board initialization timeout\n"); 217 return -EINVAL; 218 } 219 220 nfp_info(pf->cpp, "waiting for board initialization\n"); 221 if (msleep_interruptible(500)) 222 return -ERESTARTSYS; 223 224 /* Refresh cached information */ 225 kfree(pf->hwinfo); 226 pf->hwinfo = nfp_hwinfo_read(pf->cpp); 227 } 228 229 return 0; 230 } 231 232 static int nfp_pcie_sriov_read_nfd_limit(struct nfp_pf *pf) 233 { 234 int err; 235 236 pf->limit_vfs = nfp_rtsym_read_le(pf->rtbl, "nfd_vf_cfg_max_vfs", &err); 237 if (err) { 238 /* For backwards compatibility if symbol not found allow all */ 239 pf->limit_vfs = ~0; 240 if (err == -ENOENT) 241 return 0; 242 243 nfp_warn(pf->cpp, "Warning: VF limit read failed: %d\n", err); 244 return err; 245 } 246 247 err = pci_sriov_set_totalvfs(pf->pdev, pf->limit_vfs); 248 if (err) 249 nfp_warn(pf->cpp, "Failed to set VF count in sysfs: %d\n", err); 250 return 0; 251 } 252 253 static int nfp_pcie_sriov_enable(struct pci_dev *pdev, int num_vfs) 254 { 255 #ifdef CONFIG_PCI_IOV 256 struct nfp_pf *pf = pci_get_drvdata(pdev); 257 int err; 258 259 if (num_vfs > pf->limit_vfs) { 260 nfp_info(pf->cpp, "Firmware limits number of VFs to %u\n", 261 pf->limit_vfs); 262 return -EINVAL; 263 } 264 265 err = pci_enable_sriov(pdev, num_vfs); 266 if (err) { 267 dev_warn(&pdev->dev, "Failed to enable PCI SR-IOV: %d\n", err); 268 return err; 269 } 270 271 mutex_lock(&pf->lock); 272 273 err = nfp_app_sriov_enable(pf->app, num_vfs); 274 if (err) { 275 dev_warn(&pdev->dev, 276 "App specific PCI SR-IOV configuration failed: %d\n", 277 err); 278 goto err_sriov_disable; 279 } 280 281 pf->num_vfs = num_vfs; 282 283 dev_dbg(&pdev->dev, "Created %d VFs.\n", pf->num_vfs); 284 285 mutex_unlock(&pf->lock); 286 return num_vfs; 287 288 err_sriov_disable: 289 mutex_unlock(&pf->lock); 290 pci_disable_sriov(pdev); 291 return err; 292 #endif 293 return 0; 294 } 295 296 static int nfp_pcie_sriov_disable(struct pci_dev *pdev) 297 { 298 #ifdef CONFIG_PCI_IOV 299 struct nfp_pf *pf = pci_get_drvdata(pdev); 300 301 mutex_lock(&pf->lock); 302 303 /* If the VFs are assigned we cannot shut down SR-IOV without 304 * causing issues, so just leave the hardware available but 305 * disabled 306 */ 307 if (pci_vfs_assigned(pdev)) { 308 dev_warn(&pdev->dev, "Disabling while VFs assigned - VFs will not be deallocated\n"); 309 mutex_unlock(&pf->lock); 310 return -EPERM; 311 } 312 313 nfp_app_sriov_disable(pf->app); 314 315 pf->num_vfs = 0; 316 317 mutex_unlock(&pf->lock); 318 319 pci_disable_sriov(pdev); 320 dev_dbg(&pdev->dev, "Removed VFs.\n"); 321 #endif 322 return 0; 323 } 324 325 static int nfp_pcie_sriov_configure(struct pci_dev *pdev, int num_vfs) 326 { 327 if (num_vfs == 0) 328 return nfp_pcie_sriov_disable(pdev); 329 else 330 return nfp_pcie_sriov_enable(pdev, num_vfs); 331 } 332 333 static const struct firmware * 334 nfp_net_fw_request(struct pci_dev *pdev, struct nfp_pf *pf, const char *name) 335 { 336 const struct firmware *fw = NULL; 337 int err; 338 339 err = request_firmware_direct(&fw, name, &pdev->dev); 340 nfp_info(pf->cpp, " %s: %s\n", 341 name, err ? "not found" : "found, loading..."); 342 if (err) 343 return NULL; 344 345 return fw; 346 } 347 348 /** 349 * nfp_net_fw_find() - Find the correct firmware image for netdev mode 350 * @pdev: PCI Device structure 351 * @pf: NFP PF Device structure 352 * 353 * Return: firmware if found and requested successfully. 354 */ 355 static const struct firmware * 356 nfp_net_fw_find(struct pci_dev *pdev, struct nfp_pf *pf) 357 { 358 struct nfp_eth_table_port *port; 359 const struct firmware *fw; 360 const char *fw_model; 361 char fw_name[256]; 362 const u8 *serial; 363 u16 interface; 364 int spc, i, j; 365 366 nfp_info(pf->cpp, "Looking for firmware file in order of priority:\n"); 367 368 /* First try to find a firmware image specific for this device */ 369 interface = nfp_cpp_interface(pf->cpp); 370 nfp_cpp_serial(pf->cpp, &serial); 371 sprintf(fw_name, "netronome/serial-%pMF-%02hhx-%02hhx.nffw", 372 serial, interface >> 8, interface & 0xff); 373 fw = nfp_net_fw_request(pdev, pf, fw_name); 374 if (fw) 375 return fw; 376 377 /* Then try the PCI name */ 378 sprintf(fw_name, "netronome/pci-%s.nffw", pci_name(pdev)); 379 fw = nfp_net_fw_request(pdev, pf, fw_name); 380 if (fw) 381 return fw; 382 383 /* Finally try the card type and media */ 384 if (!pf->eth_tbl) { 385 dev_err(&pdev->dev, "Error: can't identify media config\n"); 386 return NULL; 387 } 388 389 fw_model = nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno"); 390 if (!fw_model) { 391 dev_err(&pdev->dev, "Error: can't read part number\n"); 392 return NULL; 393 } 394 395 spc = ARRAY_SIZE(fw_name); 396 spc -= snprintf(fw_name, spc, "netronome/nic_%s", fw_model); 397 398 for (i = 0; spc > 0 && i < pf->eth_tbl->count; i += j) { 399 port = &pf->eth_tbl->ports[i]; 400 j = 1; 401 while (i + j < pf->eth_tbl->count && 402 port->speed == port[j].speed) 403 j++; 404 405 spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc, 406 "_%dx%d", j, port->speed / 1000); 407 } 408 409 if (spc <= 0) 410 return NULL; 411 412 spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc, ".nffw"); 413 if (spc <= 0) 414 return NULL; 415 416 return nfp_net_fw_request(pdev, pf, fw_name); 417 } 418 419 /** 420 * nfp_net_fw_load() - Load the firmware image 421 * @pdev: PCI Device structure 422 * @pf: NFP PF Device structure 423 * @nsp: NFP SP handle 424 * 425 * Return: -ERRNO, 0 for no firmware loaded, 1 for firmware loaded 426 */ 427 static int 428 nfp_fw_load(struct pci_dev *pdev, struct nfp_pf *pf, struct nfp_nsp *nsp) 429 { 430 const struct firmware *fw; 431 u16 interface; 432 int err; 433 434 interface = nfp_cpp_interface(pf->cpp); 435 if (NFP_CPP_INTERFACE_UNIT_of(interface) != 0) { 436 /* Only Unit 0 should reset or load firmware */ 437 dev_info(&pdev->dev, "Firmware will be loaded by partner\n"); 438 return 0; 439 } 440 441 fw = nfp_net_fw_find(pdev, pf); 442 if (!fw) { 443 if (nfp_nsp_has_stored_fw_load(nsp)) 444 nfp_nsp_load_stored_fw(nsp); 445 return 0; 446 } 447 448 dev_info(&pdev->dev, "Soft-reset, loading FW image\n"); 449 err = nfp_nsp_device_soft_reset(nsp); 450 if (err < 0) { 451 dev_err(&pdev->dev, "Failed to soft reset the NFP: %d\n", 452 err); 453 goto exit_release_fw; 454 } 455 456 err = nfp_nsp_load_fw(nsp, fw); 457 if (err < 0) { 458 dev_err(&pdev->dev, "FW loading failed: %d\n", err); 459 goto exit_release_fw; 460 } 461 462 dev_info(&pdev->dev, "Finished loading FW image\n"); 463 464 exit_release_fw: 465 release_firmware(fw); 466 467 return err < 0 ? err : 1; 468 } 469 470 static void 471 nfp_nsp_init_ports(struct pci_dev *pdev, struct nfp_pf *pf, 472 struct nfp_nsp *nsp) 473 { 474 bool needs_reinit = false; 475 int i; 476 477 pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp); 478 if (!pf->eth_tbl) 479 return; 480 481 if (!nfp_nsp_has_mac_reinit(nsp)) 482 return; 483 484 for (i = 0; i < pf->eth_tbl->count; i++) 485 needs_reinit |= pf->eth_tbl->ports[i].override_changed; 486 if (!needs_reinit) 487 return; 488 489 kfree(pf->eth_tbl); 490 if (nfp_nsp_mac_reinit(nsp)) 491 dev_warn(&pdev->dev, "MAC reinit failed\n"); 492 493 pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp); 494 } 495 496 static int nfp_nsp_init(struct pci_dev *pdev, struct nfp_pf *pf) 497 { 498 struct nfp_nsp *nsp; 499 int err; 500 501 err = nfp_resource_wait(pf->cpp, NFP_RESOURCE_NSP, 30); 502 if (err) 503 return err; 504 505 nsp = nfp_nsp_open(pf->cpp); 506 if (IS_ERR(nsp)) { 507 err = PTR_ERR(nsp); 508 dev_err(&pdev->dev, "Failed to access the NSP: %d\n", err); 509 return err; 510 } 511 512 err = nfp_nsp_wait(nsp); 513 if (err < 0) 514 goto exit_close_nsp; 515 516 nfp_nsp_init_ports(pdev, pf, nsp); 517 518 pf->nspi = __nfp_nsp_identify(nsp); 519 if (pf->nspi) 520 dev_info(&pdev->dev, "BSP: %s\n", pf->nspi->version); 521 522 err = nfp_fw_load(pdev, pf, nsp); 523 if (err < 0) { 524 kfree(pf->nspi); 525 kfree(pf->eth_tbl); 526 dev_err(&pdev->dev, "Failed to load FW\n"); 527 goto exit_close_nsp; 528 } 529 530 pf->fw_loaded = !!err; 531 err = 0; 532 533 exit_close_nsp: 534 nfp_nsp_close(nsp); 535 536 return err; 537 } 538 539 static void nfp_fw_unload(struct nfp_pf *pf) 540 { 541 struct nfp_nsp *nsp; 542 int err; 543 544 nsp = nfp_nsp_open(pf->cpp); 545 if (IS_ERR(nsp)) { 546 nfp_err(pf->cpp, "Reset failed, can't open NSP\n"); 547 return; 548 } 549 550 err = nfp_nsp_device_soft_reset(nsp); 551 if (err < 0) 552 dev_warn(&pf->pdev->dev, "Couldn't unload firmware: %d\n", err); 553 else 554 dev_info(&pf->pdev->dev, "Firmware safely unloaded\n"); 555 556 nfp_nsp_close(nsp); 557 } 558 559 static int nfp_pf_find_rtsyms(struct nfp_pf *pf) 560 { 561 char pf_symbol[256]; 562 unsigned int pf_id; 563 564 pf_id = nfp_cppcore_pcie_unit(pf->cpp); 565 566 /* Optional per-PCI PF mailbox */ 567 snprintf(pf_symbol, sizeof(pf_symbol), NFP_MBOX_SYM_NAME, pf_id); 568 pf->mbox = nfp_rtsym_lookup(pf->rtbl, pf_symbol); 569 if (pf->mbox && nfp_rtsym_size(pf->mbox) < NFP_MBOX_SYM_MIN_SIZE) { 570 nfp_err(pf->cpp, "PF mailbox symbol too small: %llu < %d\n", 571 nfp_rtsym_size(pf->mbox), NFP_MBOX_SYM_MIN_SIZE); 572 return -EINVAL; 573 } 574 575 return 0; 576 } 577 578 static int nfp_pci_probe(struct pci_dev *pdev, 579 const struct pci_device_id *pci_id) 580 { 581 struct devlink *devlink; 582 struct nfp_pf *pf; 583 int err; 584 585 err = pci_enable_device(pdev); 586 if (err < 0) 587 return err; 588 589 pci_set_master(pdev); 590 591 err = dma_set_mask_and_coherent(&pdev->dev, 592 DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS)); 593 if (err) 594 goto err_pci_disable; 595 596 err = pci_request_regions(pdev, nfp_driver_name); 597 if (err < 0) { 598 dev_err(&pdev->dev, "Unable to reserve pci resources.\n"); 599 goto err_pci_disable; 600 } 601 602 devlink = devlink_alloc(&nfp_devlink_ops, sizeof(*pf)); 603 if (!devlink) { 604 err = -ENOMEM; 605 goto err_rel_regions; 606 } 607 pf = devlink_priv(devlink); 608 INIT_LIST_HEAD(&pf->vnics); 609 INIT_LIST_HEAD(&pf->ports); 610 mutex_init(&pf->lock); 611 pci_set_drvdata(pdev, pf); 612 pf->pdev = pdev; 613 614 pf->wq = alloc_workqueue("nfp-%s", 0, 2, pci_name(pdev)); 615 if (!pf->wq) { 616 err = -ENOMEM; 617 goto err_pci_priv_unset; 618 } 619 620 pf->cpp = nfp_cpp_from_nfp6000_pcie(pdev); 621 if (IS_ERR_OR_NULL(pf->cpp)) { 622 err = PTR_ERR(pf->cpp); 623 if (err >= 0) 624 err = -ENOMEM; 625 goto err_disable_msix; 626 } 627 628 err = nfp_resource_table_init(pf->cpp); 629 if (err) 630 goto err_cpp_free; 631 632 pf->hwinfo = nfp_hwinfo_read(pf->cpp); 633 634 dev_info(&pdev->dev, "Assembly: %s%s%s-%s CPLD: %s\n", 635 nfp_hwinfo_lookup(pf->hwinfo, "assembly.vendor"), 636 nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno"), 637 nfp_hwinfo_lookup(pf->hwinfo, "assembly.serial"), 638 nfp_hwinfo_lookup(pf->hwinfo, "assembly.revision"), 639 nfp_hwinfo_lookup(pf->hwinfo, "cpld.version")); 640 641 err = nfp_pf_board_state_wait(pf); 642 if (err) 643 goto err_hwinfo_free; 644 645 err = nfp_nsp_init(pdev, pf); 646 if (err) 647 goto err_hwinfo_free; 648 649 pf->mip = nfp_mip_open(pf->cpp); 650 pf->rtbl = __nfp_rtsym_table_read(pf->cpp, pf->mip); 651 652 err = nfp_pf_find_rtsyms(pf); 653 if (err) 654 goto err_fw_unload; 655 656 pf->dump_flag = NFP_DUMP_NSP_DIAG; 657 pf->dumpspec = nfp_net_dump_load_dumpspec(pf->cpp, pf->rtbl); 658 659 err = nfp_pcie_sriov_read_nfd_limit(pf); 660 if (err) 661 goto err_fw_unload; 662 663 pf->num_vfs = pci_num_vf(pdev); 664 if (pf->num_vfs > pf->limit_vfs) { 665 dev_err(&pdev->dev, 666 "Error: %d VFs already enabled, but loaded FW can only support %d\n", 667 pf->num_vfs, pf->limit_vfs); 668 err = -EINVAL; 669 goto err_fw_unload; 670 } 671 672 err = nfp_net_pci_probe(pf); 673 if (err) 674 goto err_fw_unload; 675 676 err = nfp_hwmon_register(pf); 677 if (err) { 678 dev_err(&pdev->dev, "Failed to register hwmon info\n"); 679 goto err_net_remove; 680 } 681 682 return 0; 683 684 err_net_remove: 685 nfp_net_pci_remove(pf); 686 err_fw_unload: 687 kfree(pf->rtbl); 688 nfp_mip_close(pf->mip); 689 if (pf->fw_loaded) 690 nfp_fw_unload(pf); 691 kfree(pf->eth_tbl); 692 kfree(pf->nspi); 693 vfree(pf->dumpspec); 694 err_hwinfo_free: 695 kfree(pf->hwinfo); 696 err_cpp_free: 697 nfp_cpp_free(pf->cpp); 698 err_disable_msix: 699 destroy_workqueue(pf->wq); 700 err_pci_priv_unset: 701 pci_set_drvdata(pdev, NULL); 702 mutex_destroy(&pf->lock); 703 devlink_free(devlink); 704 err_rel_regions: 705 pci_release_regions(pdev); 706 err_pci_disable: 707 pci_disable_device(pdev); 708 709 return err; 710 } 711 712 static void nfp_pci_remove(struct pci_dev *pdev) 713 { 714 struct nfp_pf *pf = pci_get_drvdata(pdev); 715 716 nfp_hwmon_unregister(pf); 717 718 nfp_pcie_sriov_disable(pdev); 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); 799