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 <net/devlink.h>
  49
  50 #include "nfpcore/nfp.h"
  51 #include "nfpcore/nfp_cpp.h"
  52 #include "nfpcore/nfp_nffw.h"
  53 #include "nfpcore/nfp_nsp.h"
  54
  55 #include "nfpcore/nfp6000_pcie.h"
  56
  57 #include "nfp_app.h"
  58 #include "nfp_main.h"
  59 #include "nfp_net.h"
  60
  61 static const char nfp_driver_name[] = "nfp";
  62 const char nfp_driver_version[] = VERMAGIC_STRING;
  63
  64 static const struct pci_device_id nfp_pci_device_ids[] = {
  65         { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NETRONOME_NFP6000,
  66           PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
  67           PCI_ANY_ID, 0,
  68         },
  69         { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NETRONOME_NFP4000,
  70           PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
  71           PCI_ANY_ID, 0,
  72         },
  73         { 0, } /* Required last entry. */
  74 };
  75 MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids);
  76
  77 static bool nfp_board_ready(struct nfp_pf *pf)
  78 {
  79         const char *cp;
  80         long state;
  81         int err;
  82
  83         cp = nfp_hwinfo_lookup(pf->hwinfo, "board.state");
  84         if (!cp)
  85                 return false;
  86
  87         err = kstrtol(cp, 0, &state);
  88         if (err < 0)
  89                 return false;
  90
  91         return state == 15;
  92 }
  93
  94 static int nfp_pf_board_state_wait(struct nfp_pf *pf)
  95 {
  96         const unsigned long wait_until = jiffies + 10 * HZ;
  97
  98         while (!nfp_board_ready(pf)) {
  99                 if (time_is_before_eq_jiffies(wait_until)) {
 100                         nfp_err(pf->cpp, "NFP board initialization timeout\n");
 101                         return -EINVAL;
 102                 }
 103
 104                 nfp_info(pf->cpp, "waiting for board initialization\n");
 105                 if (msleep_interruptible(500))
 106                         return -ERESTARTSYS;
 107
 108                 /* Refresh cached information */
 109                 kfree(pf->hwinfo);
 110                 pf->hwinfo = nfp_hwinfo_read(pf->cpp);
 111         }
 112
 113         return 0;
 114 }
 115
 116 static int nfp_pcie_sriov_read_nfd_limit(struct nfp_pf *pf)
 117 {
 118         int err;
 119
 120         pf->limit_vfs = nfp_rtsym_read_le(pf->rtbl, "nfd_vf_cfg_max_vfs", &err);
 121         if (!err)
 122                 return pci_sriov_set_totalvfs(pf->pdev, pf->limit_vfs);
 123
 124         pf->limit_vfs = ~0;
 125         pci_sriov_set_totalvfs(pf->pdev, 0); /* 0 is unset */
 126         /* Allow any setting for backwards compatibility if symbol not found */
 127         if (err == -ENOENT)
 128                 return 0;
 129
 130         nfp_warn(pf->cpp, "Warning: VF limit read failed: %d\n", err);
 131         return err;
 132 }
 133
 134 static int nfp_pcie_sriov_enable(struct pci_dev *pdev, int num_vfs)
 135 {
 136 #ifdef CONFIG_PCI_IOV
 137         struct nfp_pf *pf = pci_get_drvdata(pdev);
 138         int err;
 139
 140         if (num_vfs > pf->limit_vfs) {
 141                 nfp_info(pf->cpp, "Firmware limits number of VFs to %u\n",
 142                          pf->limit_vfs);
 143                 return -EINVAL;
 144         }
 145
 146         err = pci_enable_sriov(pdev, num_vfs);
 147         if (err) {
 148                 dev_warn(&pdev->dev, "Failed to enable PCI SR-IOV: %d\n", err);
 149                 return err;
 150         }
 151
 152         mutex_lock(&pf->lock);
 153
 154         err = nfp_app_sriov_enable(pf->app, num_vfs);
 155         if (err) {
 156                 dev_warn(&pdev->dev,
 157                          "App specific PCI SR-IOV configuration failed: %d\n",
 158                          err);
 159                 goto err_sriov_disable;
 160         }
 161
 162         pf->num_vfs = num_vfs;
 163
 164         dev_dbg(&pdev->dev, "Created %d VFs.\n", pf->num_vfs);
 165
 166         mutex_unlock(&pf->lock);
 167         return num_vfs;
 168
 169 err_sriov_disable:
 170         mutex_unlock(&pf->lock);
 171         pci_disable_sriov(pdev);
 172         return err;
 173 #endif
 174         return 0;
 175 }
 176
 177 static int nfp_pcie_sriov_disable(struct pci_dev *pdev)
 178 {
 179 #ifdef CONFIG_PCI_IOV
 180         struct nfp_pf *pf = pci_get_drvdata(pdev);
 181
 182         mutex_lock(&pf->lock);
 183
 184         /* If the VFs are assigned we cannot shut down SR-IOV without
 185          * causing issues, so just leave the hardware available but
 186          * disabled
 187          */
 188         if (pci_vfs_assigned(pdev)) {
 189                 dev_warn(&pdev->dev, "Disabling while VFs assigned - VFs will not be deallocated\n");
 190                 mutex_unlock(&pf->lock);
 191                 return -EPERM;
 192         }
 193
 194         nfp_app_sriov_disable(pf->app);
 195
 196         pf->num_vfs = 0;
 197
 198         mutex_unlock(&pf->lock);
 199
 200         pci_disable_sriov(pdev);
 201         dev_dbg(&pdev->dev, "Removed VFs.\n");
 202 #endif
 203         return 0;
 204 }
 205
 206 static int nfp_pcie_sriov_configure(struct pci_dev *pdev, int num_vfs)
 207 {
 208         if (num_vfs == 0)
 209                 return nfp_pcie_sriov_disable(pdev);
 210         else
 211                 return nfp_pcie_sriov_enable(pdev, num_vfs);
 212 }
 213
 214 static const struct firmware *
 215 nfp_net_fw_request(struct pci_dev *pdev, struct nfp_pf *pf, const char *name)
 216 {
 217         const struct firmware *fw = NULL;
 218         int err;
 219
 220         err = request_firmware_direct(&fw, name, &pdev->dev);
 221         nfp_info(pf->cpp, "  %s: %s\n",
 222                  name, err ? "not found" : "found, loading...");
 223         if (err)
 224                 return NULL;
 225
 226         return fw;
 227 }
 228
 229 /**
 230  * nfp_net_fw_find() - Find the correct firmware image for netdev mode
 231  * @pdev:       PCI Device structure
 232  * @pf:         NFP PF Device structure
 233  *
 234  * Return: firmware if found and requested successfully.
 235  */
 236 static const struct firmware *
 237 nfp_net_fw_find(struct pci_dev *pdev, struct nfp_pf *pf)
 238 {
 239         struct nfp_eth_table_port *port;
 240         const struct firmware *fw;
 241         const char *fw_model;
 242         char fw_name[256];
 243         const u8 *serial;
 244         u16 interface;
 245         int spc, i, j;
 246
 247         nfp_info(pf->cpp, "Looking for firmware file in order of priority:\n");
 248
 249         /* First try to find a firmware image specific for this device */
 250         interface = nfp_cpp_interface(pf->cpp);
 251         nfp_cpp_serial(pf->cpp, &serial);
 252         sprintf(fw_name, "netronome/serial-%pMF-%02hhx-%02hhx.nffw",
 253                 serial, interface >> 8, interface & 0xff);
 254         fw = nfp_net_fw_request(pdev, pf, fw_name);
 255         if (fw)
 256                 return fw;
 257
 258         /* Then try the PCI name */
 259         sprintf(fw_name, "netronome/pci-%s.nffw", pci_name(pdev));
 260         fw = nfp_net_fw_request(pdev, pf, fw_name);
 261         if (fw)
 262                 return fw;
 263
 264         /* Finally try the card type and media */
 265         if (!pf->eth_tbl) {
 266                 dev_err(&pdev->dev, "Error: can't identify media config\n");
 267                 return NULL;
 268         }
 269
 270         fw_model = nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno");
 271         if (!fw_model) {
 272                 dev_err(&pdev->dev, "Error: can't read part number\n");
 273                 return NULL;
 274         }
 275
 276         spc = ARRAY_SIZE(fw_name);
 277         spc -= snprintf(fw_name, spc, "netronome/nic_%s", fw_model);
 278
 279         for (i = 0; spc > 0 && i < pf->eth_tbl->count; i += j) {
 280                 port = &pf->eth_tbl->ports[i];
 281                 j = 1;
 282                 while (i + j < pf->eth_tbl->count &&
 283                        port->speed == port[j].speed)
 284                         j++;
 285
 286                 spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc,
 287                                 "_%dx%d", j, port->speed / 1000);
 288         }
 289
 290         if (spc <= 0)
 291                 return NULL;
 292
 293         spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc, ".nffw");
 294         if (spc <= 0)
 295                 return NULL;
 296
 297         return nfp_net_fw_request(pdev, pf, fw_name);
 298 }
 299
 300 /**
 301  * nfp_net_fw_load() - Load the firmware image
 302  * @pdev:       PCI Device structure
 303  * @pf:         NFP PF Device structure
 304  * @nsp:        NFP SP handle
 305  *
 306  * Return: -ERRNO, 0 for no firmware loaded, 1 for firmware loaded
 307  */
 308 static int
 309 nfp_fw_load(struct pci_dev *pdev, struct nfp_pf *pf, struct nfp_nsp *nsp)
 310 {
 311         const struct firmware *fw;
 312         u16 interface;
 313         int err;
 314
 315         interface = nfp_cpp_interface(pf->cpp);
 316         if (NFP_CPP_INTERFACE_UNIT_of(interface) != 0) {
 317                 /* Only Unit 0 should reset or load firmware */
 318                 dev_info(&pdev->dev, "Firmware will be loaded by partner\n");
 319                 return 0;
 320         }
 321
 322         fw = nfp_net_fw_find(pdev, pf);
 323         if (!fw)
 324                 return 0;
 325
 326         dev_info(&pdev->dev, "Soft-reset, loading FW image\n");
 327         err = nfp_nsp_device_soft_reset(nsp);
 328         if (err < 0) {
 329                 dev_err(&pdev->dev, "Failed to soft reset the NFP: %d\n",
 330                         err);
 331                 goto exit_release_fw;
 332         }
 333
 334         err = nfp_nsp_load_fw(nsp, fw);
 335
 336         if (err < 0) {
 337                 dev_err(&pdev->dev, "FW loading failed: %d\n", err);
 338                 goto exit_release_fw;
 339         }
 340
 341         dev_info(&pdev->dev, "Finished loading FW image\n");
 342
 343 exit_release_fw:
 344         release_firmware(fw);
 345
 346         return err < 0 ? err : 1;
 347 }
 348
 349 static int nfp_nsp_init(struct pci_dev *pdev, struct nfp_pf *pf)
 350 {
 351         struct nfp_nsp *nsp;
 352         int err;
 353
 354         err = nfp_resource_wait(pf->cpp, NFP_RESOURCE_NSP, 30);
 355         if (err)
 356                 return err;
 357
 358         nsp = nfp_nsp_open(pf->cpp);
 359         if (IS_ERR(nsp)) {
 360                 err = PTR_ERR(nsp);
 361                 dev_err(&pdev->dev, "Failed to access the NSP: %d\n", err);
 362                 return err;
 363         }
 364
 365         err = nfp_nsp_wait(nsp);
 366         if (err < 0)
 367                 goto exit_close_nsp;
 368
 369         pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);
 370
 371         pf->nspi = __nfp_nsp_identify(nsp);
 372         if (pf->nspi)
 373                 dev_info(&pdev->dev, "BSP: %s\n", pf->nspi->version);
 374
 375         err = nfp_fw_load(pdev, pf, nsp);
 376         if (err < 0) {
 377                 kfree(pf->nspi);
 378                 kfree(pf->eth_tbl);
 379                 dev_err(&pdev->dev, "Failed to load FW\n");
 380                 goto exit_close_nsp;
 381         }
 382
 383         pf->fw_loaded = !!err;
 384         err = 0;
 385
 386 exit_close_nsp:
 387         nfp_nsp_close(nsp);
 388
 389         return err;
 390 }
 391
 392 static void nfp_fw_unload(struct nfp_pf *pf)
 393 {
 394         struct nfp_nsp *nsp;
 395         int err;
 396
 397         nsp = nfp_nsp_open(pf->cpp);
 398         if (IS_ERR(nsp)) {
 399                 nfp_err(pf->cpp, "Reset failed, can't open NSP\n");
 400                 return;
 401         }
 402
 403         err = nfp_nsp_device_soft_reset(nsp);
 404         if (err < 0)
 405                 dev_warn(&pf->pdev->dev, "Couldn't unload firmware: %d\n", err);
 406         else
 407                 dev_info(&pf->pdev->dev, "Firmware safely unloaded\n");
 408
 409         nfp_nsp_close(nsp);
 410 }
 411
 412 static int nfp_pci_probe(struct pci_dev *pdev,
 413                          const struct pci_device_id *pci_id)
 414 {
 415         struct devlink *devlink;
 416         struct nfp_pf *pf;
 417         int err;
 418
 419         err = pci_enable_device(pdev);
 420         if (err < 0)
 421                 return err;
 422
 423         pci_set_master(pdev);
 424
 425         err = dma_set_mask_and_coherent(&pdev->dev,
 426                                         DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS));
 427         if (err)
 428                 goto err_pci_disable;
 429
 430         err = pci_request_regions(pdev, nfp_driver_name);
 431         if (err < 0) {
 432                 dev_err(&pdev->dev, "Unable to reserve pci resources.\n");
 433                 goto err_pci_disable;
 434         }
 435
 436         devlink = devlink_alloc(&nfp_devlink_ops, sizeof(*pf));
 437         if (!devlink) {
 438                 err = -ENOMEM;
 439                 goto err_rel_regions;
 440         }
 441         pf = devlink_priv(devlink);
 442         INIT_LIST_HEAD(&pf->vnics);
 443         INIT_LIST_HEAD(&pf->ports);
 444         mutex_init(&pf->lock);
 445         pci_set_drvdata(pdev, pf);
 446         pf->pdev = pdev;
 447
 448         pf->wq = alloc_workqueue("nfp-%s", 0, 2, pci_name(pdev));
 449         if (!pf->wq) {
 450                 err = -ENOMEM;
 451                 goto err_pci_priv_unset;
 452         }
 453
 454         pf->cpp = nfp_cpp_from_nfp6000_pcie(pdev);
 455         if (IS_ERR_OR_NULL(pf->cpp)) {
 456                 err = PTR_ERR(pf->cpp);
 457                 if (err >= 0)
 458                         err = -ENOMEM;
 459                 goto err_disable_msix;
 460         }
 461
 462         pf->hwinfo = nfp_hwinfo_read(pf->cpp);
 463
 464         dev_info(&pdev->dev, "Assembly: %s%s%s-%s CPLD: %s\n",
 465                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.vendor"),
 466                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.partno"),
 467                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.serial"),
 468                  nfp_hwinfo_lookup(pf->hwinfo, "assembly.revision"),
 469                  nfp_hwinfo_lookup(pf->hwinfo, "cpld.version"));
 470
 471         err = nfp_pf_board_state_wait(pf);
 472         if (err)
 473                 goto err_hwinfo_free;
 474
 475         err = devlink_register(devlink, &pdev->dev);
 476         if (err)
 477                 goto err_hwinfo_free;
 478
 479         err = nfp_nsp_init(pdev, pf);
 480         if (err)
 481                 goto err_devlink_unreg;
 482
 483         pf->mip = nfp_mip_open(pf->cpp);
 484         pf->rtbl = __nfp_rtsym_table_read(pf->cpp, pf->mip);
 485
 486         err = nfp_pcie_sriov_read_nfd_limit(pf);
 487         if (err)
 488                 goto err_fw_unload;
 489
 490         pf->num_vfs = pci_num_vf(pdev);
 491         if (pf->num_vfs > pf->limit_vfs) {
 492                 dev_err(&pdev->dev,
 493                         "Error: %d VFs already enabled, but loaded FW can only support %d\n",
 494                         pf->num_vfs, pf->limit_vfs);
 495                 goto err_fw_unload;
 496         }
 497
 498         err = nfp_net_pci_probe(pf);
 499         if (err)
 500                 goto err_sriov_unlimit;
 501
 502         err = nfp_hwmon_register(pf);
 503         if (err) {
 504                 dev_err(&pdev->dev, "Failed to register hwmon info\n");
 505                 goto err_net_remove;
 506         }
 507
 508         return 0;
 509
 510 err_net_remove:
 511         nfp_net_pci_remove(pf);
 512 err_sriov_unlimit:
 513         pci_sriov_set_totalvfs(pf->pdev, 0);
 514 err_fw_unload:
 515         kfree(pf->rtbl);
 516         nfp_mip_close(pf->mip);
 517         if (pf->fw_loaded)
 518                 nfp_fw_unload(pf);
 519         kfree(pf->eth_tbl);
 520         kfree(pf->nspi);
 521 err_devlink_unreg:
 522         devlink_unregister(devlink);
 523 err_hwinfo_free:
 524         kfree(pf->hwinfo);
 525         nfp_cpp_free(pf->cpp);
 526 err_disable_msix:
 527         destroy_workqueue(pf->wq);
 528 err_pci_priv_unset:
 529         pci_set_drvdata(pdev, NULL);
 530         mutex_destroy(&pf->lock);
 531         devlink_free(devlink);
 532 err_rel_regions:
 533         pci_release_regions(pdev);
 534 err_pci_disable:
 535         pci_disable_device(pdev);
 536
 537         return err;
 538 }
 539
 540 static void nfp_pci_remove(struct pci_dev *pdev)
 541 {
 542         struct nfp_pf *pf = pci_get_drvdata(pdev);
 543         struct devlink *devlink;
 544
 545         nfp_hwmon_unregister(pf);
 546
 547         devlink = priv_to_devlink(pf);
 548
 549         nfp_net_pci_remove(pf);
 550
 551         nfp_pcie_sriov_disable(pdev);
 552         pci_sriov_set_totalvfs(pf->pdev, 0);
 553
 554         devlink_unregister(devlink);
 555
 556         kfree(pf->rtbl);
 557         nfp_mip_close(pf->mip);
 558         if (pf->fw_loaded)
 559                 nfp_fw_unload(pf);
 560
 561         destroy_workqueue(pf->wq);
 562         pci_set_drvdata(pdev, NULL);
 563         kfree(pf->hwinfo);
 564         nfp_cpp_free(pf->cpp);
 565
 566         kfree(pf->eth_tbl);
 567         kfree(pf->nspi);
 568         mutex_destroy(&pf->lock);
 569         devlink_free(devlink);
 570         pci_release_regions(pdev);
 571         pci_disable_device(pdev);
 572 }
 573
 574 static struct pci_driver nfp_pci_driver = {
 575         .name                   = nfp_driver_name,
 576         .id_table               = nfp_pci_device_ids,
 577         .probe                  = nfp_pci_probe,
 578         .remove                 = nfp_pci_remove,
 579         .sriov_configure        = nfp_pcie_sriov_configure,
 580 };
 581
 582 static int __init nfp_main_init(void)
 583 {
 584         int err;
 585
 586         pr_info("%s: NFP PCIe Driver, Copyright (C) 2014-2017 Netronome Systems\n",
 587                 nfp_driver_name);
 588
 589         nfp_net_debugfs_create();
 590
 591         err = pci_register_driver(&nfp_pci_driver);
 592         if (err < 0)
 593                 goto err_destroy_debugfs;
 594
 595         err = pci_register_driver(&nfp_netvf_pci_driver);
 596         if (err)
 597                 goto err_unreg_pf;
 598
 599         return err;
 600
 601 err_unreg_pf:
 602         pci_unregister_driver(&nfp_pci_driver);
 603 err_destroy_debugfs:
 604         nfp_net_debugfs_destroy();
 605         return err;
 606 }
 607
 608 static void __exit nfp_main_exit(void)
 609 {
 610         pci_unregister_driver(&nfp_netvf_pci_driver);
 611         pci_unregister_driver(&nfp_pci_driver);
 612         nfp_net_debugfs_destroy();
 613 }
 614
 615 module_init(nfp_main_init);
 616 module_exit(nfp_main_exit);
 617
 618 MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_1x40.nffw");
 619 MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_4x10.nffw");
 620 MODULE_FIRMWARE("netronome/nic_AMDA0096-0001_2x10.nffw");
 621 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_2x40.nffw");
 622 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_4x10_1x40.nffw");
 623 MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_8x10.nffw");
 624 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x10.nffw");
 625 MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x25.nffw");
 626
 627 MODULE_AUTHOR("Netronome Systems <oss-drivers@netronome.com>");
 628 MODULE_LICENSE("GPL");
 629 MODULE_DESCRIPTION("The Netronome Flow Processor (NFP) driver.");