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