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