drivers/net/ethernet/netronome/nfp/nfp_net_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_net_main.c
  36  * Netronome network device driver: Main entry point
  37  * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
  38  *          Alejandro Lucero <alejandro.lucero@netronome.com>
  39  *          Jason McMullan <jason.mcmullan@netronome.com>
  40  *          Rolf Neugebauer <rolf.neugebauer@netronome.com>
  41  */
  42
  43 #include <linux/etherdevice.h>
  44 #include <linux/kernel.h>
  45 #include <linux/init.h>
  46 #include <linux/lockdep.h>
  47 #include <linux/pci.h>
  48 #include <linux/pci_regs.h>
  49 #include <linux/msi.h>
  50 #include <linux/random.h>
  51 #include <linux/rtnetlink.h>
  52
  53 #include "nfpcore/nfp.h"
  54 #include "nfpcore/nfp_cpp.h"
  55 #include "nfpcore/nfp_nffw.h"
  56 #include "nfpcore/nfp_nsp.h"
  57 #include "nfpcore/nfp6000_pcie.h"
  58 #include "nfp_app.h"
  59 #include "nfp_net_ctrl.h"
  60 #include "nfp_net_sriov.h"
  61 #include "nfp_net.h"
  62 #include "nfp_main.h"
  63 #include "nfp_port.h"
  64
  65 #define NFP_PF_CSR_SLICE_SIZE   (32 * 1024)
  66
  67 /**
  68  * nfp_net_get_mac_addr() - Get the MAC address.
  69  * @pf:       NFP PF handle
  70  * @netdev:   net_device to set MAC address on
  71  * @port:     NFP port structure
  72  *
  73  * First try to get the MAC address from NSP ETH table. If that
  74  * fails generate a random address.
  75  */
  76 void
  77 nfp_net_get_mac_addr(struct nfp_pf *pf, struct net_device *netdev,
  78                      struct nfp_port *port)
  79 {
  80         struct nfp_eth_table_port *eth_port;
  81
  82         eth_port = __nfp_port_get_eth_port(port);
  83         if (!eth_port) {
  84                 eth_hw_addr_random(netdev);
  85                 return;
  86         }
  87
  88         ether_addr_copy(netdev->dev_addr, eth_port->mac_addr);
  89         ether_addr_copy(netdev->perm_addr, eth_port->mac_addr);
  90 }
  91
  92 static struct nfp_eth_table_port *
  93 nfp_net_find_port(struct nfp_eth_table *eth_tbl, unsigned int index)
  94 {
  95         int i;
  96
  97         for (i = 0; eth_tbl && i < eth_tbl->count; i++)
  98                 if (eth_tbl->ports[i].index == index)
  99                         return &eth_tbl->ports[i];
 100
 101         return NULL;
 102 }
 103
 104 static int nfp_net_pf_get_num_ports(struct nfp_pf *pf)
 105 {
 106         return nfp_pf_rtsym_read_optional(pf, "nfd_cfg_pf%u_num_ports", 1);
 107 }
 108
 109 static int nfp_net_pf_get_app_id(struct nfp_pf *pf)
 110 {
 111         return nfp_pf_rtsym_read_optional(pf, "_pf%u_net_app_id",
 112                                           NFP_APP_CORE_NIC);
 113 }
 114
 115 static void nfp_net_pf_free_vnic(struct nfp_pf *pf, struct nfp_net *nn)
 116 {
 117         if (nfp_net_is_data_vnic(nn))
 118                 nfp_app_vnic_free(pf->app, nn);
 119         nfp_port_free(nn->port);
 120         list_del(&nn->vnic_list);
 121         pf->num_vnics--;
 122         nfp_net_free(nn);
 123 }
 124
 125 static void nfp_net_pf_free_vnics(struct nfp_pf *pf)
 126 {
 127         struct nfp_net *nn, *next;
 128
 129         list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list)
 130                 if (nfp_net_is_data_vnic(nn))
 131                         nfp_net_pf_free_vnic(pf, nn);
 132 }
 133
 134 static struct nfp_net *
 135 nfp_net_pf_alloc_vnic(struct nfp_pf *pf, bool needs_netdev,
 136                       void __iomem *ctrl_bar, void __iomem *qc_bar,
 137                       int stride, unsigned int id)
 138 {
 139         u32 tx_base, rx_base, n_tx_rings, n_rx_rings;
 140         struct nfp_net *nn;
 141         int err;
 142
 143         tx_base = readl(ctrl_bar + NFP_NET_CFG_START_TXQ);
 144         rx_base = readl(ctrl_bar + NFP_NET_CFG_START_RXQ);
 145         n_tx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_TXRINGS);
 146         n_rx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_RXRINGS);
 147
 148         /* Allocate and initialise the vNIC */
 149         nn = nfp_net_alloc(pf->pdev, needs_netdev, n_tx_rings, n_rx_rings);
 150         if (IS_ERR(nn))
 151                 return nn;
 152
 153         nn->app = pf->app;
 154         nfp_net_get_fw_version(&nn->fw_ver, ctrl_bar);
 155         nn->dp.ctrl_bar = ctrl_bar;
 156         nn->tx_bar = qc_bar + tx_base * NFP_QCP_QUEUE_ADDR_SZ;
 157         nn->rx_bar = qc_bar + rx_base * NFP_QCP_QUEUE_ADDR_SZ;
 158         nn->dp.is_vf = 0;
 159         nn->stride_rx = stride;
 160         nn->stride_tx = stride;
 161
 162         if (needs_netdev) {
 163                 err = nfp_app_vnic_alloc(pf->app, nn, id);
 164                 if (err) {
 165                         nfp_net_free(nn);
 166                         return ERR_PTR(err);
 167                 }
 168         }
 169
 170         pf->num_vnics++;
 171         list_add_tail(&nn->vnic_list, &pf->vnics);
 172
 173         return nn;
 174 }
 175
 176 static int
 177 nfp_net_pf_init_vnic(struct nfp_pf *pf, struct nfp_net *nn, unsigned int id)
 178 {
 179         int err;
 180
 181         err = nfp_net_init(nn);
 182         if (err)
 183                 return err;
 184
 185         nfp_net_debugfs_vnic_add(nn, pf->ddir, id);
 186
 187         if (nn->port) {
 188                 err = nfp_devlink_port_register(pf->app, nn->port);
 189                 if (err)
 190                         goto err_dfs_clean;
 191         }
 192
 193         nfp_net_info(nn);
 194
 195         if (nfp_net_is_data_vnic(nn)) {
 196                 err = nfp_app_vnic_init(pf->app, nn);
 197                 if (err)
 198                         goto err_devlink_port_clean;
 199         }
 200
 201         return 0;
 202
 203 err_devlink_port_clean:
 204         if (nn->port)
 205                 nfp_devlink_port_unregister(nn->port);
 206 err_dfs_clean:
 207         nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
 208         nfp_net_clean(nn);
 209         return err;
 210 }
 211
 212 static int
 213 nfp_net_pf_alloc_vnics(struct nfp_pf *pf, void __iomem *ctrl_bar,
 214                        void __iomem *qc_bar, int stride)
 215 {
 216         struct nfp_net *nn;
 217         unsigned int i;
 218         int err;
 219
 220         for (i = 0; i < pf->max_data_vnics; i++) {
 221                 nn = nfp_net_pf_alloc_vnic(pf, true, ctrl_bar, qc_bar,
 222                                            stride, i);
 223                 if (IS_ERR(nn)) {
 224                         err = PTR_ERR(nn);
 225                         goto err_free_prev;
 226                 }
 227
 228                 ctrl_bar += NFP_PF_CSR_SLICE_SIZE;
 229
 230                 /* Kill the vNIC if app init marked it as invalid */
 231                 if (nn->port && nn->port->type == NFP_PORT_INVALID) {
 232                         nfp_net_pf_free_vnic(pf, nn);
 233                         continue;
 234                 }
 235         }
 236
 237         if (list_empty(&pf->vnics))
 238                 return -ENODEV;
 239
 240         return 0;
 241
 242 err_free_prev:
 243         nfp_net_pf_free_vnics(pf);
 244         return err;
 245 }
 246
 247 static void nfp_net_pf_clean_vnic(struct nfp_pf *pf, struct nfp_net *nn)
 248 {
 249         if (nfp_net_is_data_vnic(nn))
 250                 nfp_app_vnic_clean(pf->app, nn);
 251         if (nn->port)
 252                 nfp_devlink_port_unregister(nn->port);
 253         nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
 254         nfp_net_clean(nn);
 255 }
 256
 257 static int nfp_net_pf_alloc_irqs(struct nfp_pf *pf)
 258 {
 259         unsigned int wanted_irqs, num_irqs, vnics_left, irqs_left;
 260         struct nfp_net *nn;
 261
 262         /* Get MSI-X vectors */
 263         wanted_irqs = 0;
 264         list_for_each_entry(nn, &pf->vnics, vnic_list)
 265                 wanted_irqs += NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs;
 266         pf->irq_entries = kcalloc(wanted_irqs, sizeof(*pf->irq_entries),
 267                                   GFP_KERNEL);
 268         if (!pf->irq_entries)
 269                 return -ENOMEM;
 270
 271         num_irqs = nfp_net_irqs_alloc(pf->pdev, pf->irq_entries,
 272                                       NFP_NET_MIN_VNIC_IRQS * pf->num_vnics,
 273                                       wanted_irqs);
 274         if (!num_irqs) {
 275                 nfp_warn(pf->cpp, "Unable to allocate MSI-X vectors\n");
 276                 kfree(pf->irq_entries);
 277                 return -ENOMEM;
 278         }
 279
 280         /* Distribute IRQs to vNICs */
 281         irqs_left = num_irqs;
 282         vnics_left = pf->num_vnics;
 283         list_for_each_entry(nn, &pf->vnics, vnic_list) {
 284                 unsigned int n;
 285
 286                 n = min(NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs,
 287                         DIV_ROUND_UP(irqs_left, vnics_left));
 288                 nfp_net_irqs_assign(nn, &pf->irq_entries[num_irqs - irqs_left],
 289                                     n);
 290                 irqs_left -= n;
 291                 vnics_left--;
 292         }
 293
 294         return 0;
 295 }
 296
 297 static void nfp_net_pf_free_irqs(struct nfp_pf *pf)
 298 {
 299         nfp_net_irqs_disable(pf->pdev);
 300         kfree(pf->irq_entries);
 301 }
 302
 303 static int nfp_net_pf_init_vnics(struct nfp_pf *pf)
 304 {
 305         struct nfp_net *nn;
 306         unsigned int id;
 307         int err;
 308
 309         /* Finish vNIC init and register */
 310         id = 0;
 311         list_for_each_entry(nn, &pf->vnics, vnic_list) {
 312                 if (!nfp_net_is_data_vnic(nn))
 313                         continue;
 314                 err = nfp_net_pf_init_vnic(pf, nn, id);
 315                 if (err)
 316                         goto err_prev_deinit;
 317
 318                 id++;
 319         }
 320
 321         return 0;
 322
 323 err_prev_deinit:
 324         list_for_each_entry_continue_reverse(nn, &pf->vnics, vnic_list)
 325                 if (nfp_net_is_data_vnic(nn))
 326                         nfp_net_pf_clean_vnic(pf, nn);
 327         return err;
 328 }
 329
 330 static int
 331 nfp_net_pf_app_init(struct nfp_pf *pf, u8 __iomem *qc_bar, unsigned int stride)
 332 {
 333         u8 __iomem *ctrl_bar;
 334         int err;
 335
 336         pf->app = nfp_app_alloc(pf, nfp_net_pf_get_app_id(pf));
 337         if (IS_ERR(pf->app))
 338                 return PTR_ERR(pf->app);
 339
 340         mutex_lock(&pf->lock);
 341         err = nfp_app_init(pf->app);
 342         mutex_unlock(&pf->lock);
 343         if (err)
 344                 goto err_free;
 345
 346         if (!nfp_app_needs_ctrl_vnic(pf->app))
 347                 return 0;
 348
 349         ctrl_bar = nfp_pf_map_rtsym(pf, "net.ctrl", "_pf%u_net_ctrl_bar",
 350                                     NFP_PF_CSR_SLICE_SIZE, &pf->ctrl_vnic_bar);
 351         if (IS_ERR(ctrl_bar)) {
 352                 nfp_err(pf->cpp, "Failed to find ctrl vNIC memory symbol\n");
 353                 err = PTR_ERR(ctrl_bar);
 354                 goto err_app_clean;
 355         }
 356
 357         pf->ctrl_vnic = nfp_net_pf_alloc_vnic(pf, false, ctrl_bar, qc_bar,
 358                                               stride, 0);
 359         if (IS_ERR(pf->ctrl_vnic)) {
 360                 err = PTR_ERR(pf->ctrl_vnic);
 361                 goto err_unmap;
 362         }
 363
 364         return 0;
 365
 366 err_unmap:
 367         nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
 368 err_app_clean:
 369         mutex_lock(&pf->lock);
 370         nfp_app_clean(pf->app);
 371         mutex_unlock(&pf->lock);
 372 err_free:
 373         nfp_app_free(pf->app);
 374         pf->app = NULL;
 375         return err;
 376 }
 377
 378 static void nfp_net_pf_app_clean(struct nfp_pf *pf)
 379 {
 380         if (pf->ctrl_vnic) {
 381                 nfp_net_pf_free_vnic(pf, pf->ctrl_vnic);
 382                 nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
 383         }
 384
 385         mutex_lock(&pf->lock);
 386         nfp_app_clean(pf->app);
 387         mutex_unlock(&pf->lock);
 388
 389         nfp_app_free(pf->app);
 390         pf->app = NULL;
 391 }
 392
 393 static int nfp_net_pf_app_start_ctrl(struct nfp_pf *pf)
 394 {
 395         int err;
 396
 397         if (!pf->ctrl_vnic)
 398                 return 0;
 399         err = nfp_net_pf_init_vnic(pf, pf->ctrl_vnic, 0);
 400         if (err)
 401                 return err;
 402
 403         err = nfp_ctrl_open(pf->ctrl_vnic);
 404         if (err)
 405                 goto err_clean_ctrl;
 406
 407         return 0;
 408
 409 err_clean_ctrl:
 410         nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
 411         return err;
 412 }
 413
 414 static void nfp_net_pf_app_stop_ctrl(struct nfp_pf *pf)
 415 {
 416         if (!pf->ctrl_vnic)
 417                 return;
 418         nfp_ctrl_close(pf->ctrl_vnic);
 419         nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
 420 }
 421
 422 static int nfp_net_pf_app_start(struct nfp_pf *pf)
 423 {
 424         int err;
 425
 426         err = nfp_net_pf_app_start_ctrl(pf);
 427         if (err)
 428                 return err;
 429
 430         err = nfp_app_start(pf->app, pf->ctrl_vnic);
 431         if (err)
 432                 goto err_ctrl_stop;
 433
 434         if (pf->num_vfs) {
 435                 err = nfp_app_sriov_enable(pf->app, pf->num_vfs);
 436                 if (err)
 437                         goto err_app_stop;
 438         }
 439
 440         return 0;
 441
 442 err_app_stop:
 443         nfp_app_stop(pf->app);
 444 err_ctrl_stop:
 445         nfp_net_pf_app_stop_ctrl(pf);
 446         return err;
 447 }
 448
 449 static void nfp_net_pf_app_stop(struct nfp_pf *pf)
 450 {
 451         if (pf->num_vfs)
 452                 nfp_app_sriov_disable(pf->app);
 453         nfp_app_stop(pf->app);
 454         nfp_net_pf_app_stop_ctrl(pf);
 455 }
 456
 457 static void nfp_net_pci_unmap_mem(struct nfp_pf *pf)
 458 {
 459         if (pf->vfcfg_tbl2_area)
 460                 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
 461         if (pf->vf_cfg_bar)
 462                 nfp_cpp_area_release_free(pf->vf_cfg_bar);
 463         if (pf->mac_stats_bar)
 464                 nfp_cpp_area_release_free(pf->mac_stats_bar);
 465         nfp_cpp_area_release_free(pf->qc_area);
 466         nfp_cpp_area_release_free(pf->data_vnic_bar);
 467 }
 468
 469 static int nfp_net_pci_map_mem(struct nfp_pf *pf)
 470 {
 471         u8 __iomem *mem;
 472         u32 min_size;
 473         int err;
 474
 475         min_size = pf->max_data_vnics * NFP_PF_CSR_SLICE_SIZE;
 476         mem = nfp_pf_map_rtsym(pf, "net.bar0", "_pf%d_net_bar0",
 477                                min_size, &pf->data_vnic_bar);
 478         if (IS_ERR(mem)) {
 479                 nfp_err(pf->cpp, "Failed to find data vNIC memory symbol\n");
 480                 return PTR_ERR(mem);
 481         }
 482
 483         if (pf->eth_tbl) {
 484                 min_size =  NFP_MAC_STATS_SIZE * (pf->eth_tbl->max_index + 1);
 485                 pf->mac_stats_mem = nfp_rtsym_map(pf->rtbl, "_mac_stats",
 486                                                   "net.macstats", min_size,
 487                                                   &pf->mac_stats_bar);
 488                 if (IS_ERR(pf->mac_stats_mem)) {
 489                         if (PTR_ERR(pf->mac_stats_mem) != -ENOENT) {
 490                                 err = PTR_ERR(pf->mac_stats_mem);
 491                                 goto err_unmap_ctrl;
 492                         }
 493                         pf->mac_stats_mem = NULL;
 494                 }
 495         }
 496
 497         pf->vf_cfg_mem = nfp_pf_map_rtsym(pf, "net.vfcfg", "_pf%d_net_vf_bar",
 498                                           NFP_NET_CFG_BAR_SZ * pf->limit_vfs,
 499                                           &pf->vf_cfg_bar);
 500         if (IS_ERR(pf->vf_cfg_mem)) {
 501                 if (PTR_ERR(pf->vf_cfg_mem) != -ENOENT) {
 502                         err = PTR_ERR(pf->vf_cfg_mem);
 503                         goto err_unmap_mac_stats;
 504                 }
 505                 pf->vf_cfg_mem = NULL;
 506         }
 507
 508         min_size = NFP_NET_VF_CFG_SZ * pf->limit_vfs + NFP_NET_VF_CFG_MB_SZ;
 509         pf->vfcfg_tbl2 = nfp_pf_map_rtsym(pf, "net.vfcfg_tbl2",
 510                                           "_pf%d_net_vf_cfg2",
 511                                           min_size, &pf->vfcfg_tbl2_area);
 512         if (IS_ERR(pf->vfcfg_tbl2)) {
 513                 if (PTR_ERR(pf->vfcfg_tbl2) != -ENOENT) {
 514                         err = PTR_ERR(pf->vfcfg_tbl2);
 515                         goto err_unmap_vf_cfg;
 516                 }
 517                 pf->vfcfg_tbl2 = NULL;
 518         }
 519
 520         mem = nfp_cpp_map_area(pf->cpp, "net.qc", 0, 0,
 521                                NFP_PCIE_QUEUE(0), NFP_QCP_QUEUE_AREA_SZ,
 522                                &pf->qc_area);
 523         if (IS_ERR(mem)) {
 524                 nfp_err(pf->cpp, "Failed to map Queue Controller area.\n");
 525                 err = PTR_ERR(mem);
 526                 goto err_unmap_vfcfg_tbl2;
 527         }
 528
 529         return 0;
 530
 531 err_unmap_vfcfg_tbl2:
 532         if (pf->vfcfg_tbl2_area)
 533                 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
 534 err_unmap_vf_cfg:
 535         if (pf->vf_cfg_bar)
 536                 nfp_cpp_area_release_free(pf->vf_cfg_bar);
 537 err_unmap_mac_stats:
 538         if (pf->mac_stats_bar)
 539                 nfp_cpp_area_release_free(pf->mac_stats_bar);
 540 err_unmap_ctrl:
 541         nfp_cpp_area_release_free(pf->data_vnic_bar);
 542         return err;
 543 }
 544
 545 static int
 546 nfp_net_eth_port_update(struct nfp_cpp *cpp, struct nfp_port *port,
 547                         struct nfp_eth_table *eth_table)
 548 {
 549         struct nfp_eth_table_port *eth_port;
 550
 551         ASSERT_RTNL();
 552
 553         eth_port = nfp_net_find_port(eth_table, port->eth_id);
 554         if (!eth_port) {
 555                 set_bit(NFP_PORT_CHANGED, &port->flags);
 556                 nfp_warn(cpp, "Warning: port #%d not present after reconfig\n",
 557                          port->eth_id);
 558                 return -EIO;
 559         }
 560         if (eth_port->override_changed) {
 561                 nfp_warn(cpp, "Port #%d config changed, unregistering. Driver reload required before port will be operational again.\n", port->eth_id);
 562                 port->type = NFP_PORT_INVALID;
 563         }
 564
 565         memcpy(port->eth_port, eth_port, sizeof(*eth_port));
 566
 567         return 0;
 568 }
 569
 570 int nfp_net_refresh_port_table_sync(struct nfp_pf *pf)
 571 {
 572         struct nfp_eth_table *eth_table;
 573         struct nfp_net *nn, *next;
 574         struct nfp_port *port;
 575         int err;
 576
 577         lockdep_assert_held(&pf->lock);
 578
 579         /* Check for nfp_net_pci_remove() racing against us */
 580         if (list_empty(&pf->vnics))
 581                 return 0;
 582
 583         /* Update state of all ports */
 584         rtnl_lock();
 585         list_for_each_entry(port, &pf->ports, port_list)
 586                 clear_bit(NFP_PORT_CHANGED, &port->flags);
 587
 588         eth_table = nfp_eth_read_ports(pf->cpp);
 589         if (!eth_table) {
 590                 list_for_each_entry(port, &pf->ports, port_list)
 591                         if (__nfp_port_get_eth_port(port))
 592                                 set_bit(NFP_PORT_CHANGED, &port->flags);
 593                 rtnl_unlock();
 594                 nfp_err(pf->cpp, "Error refreshing port config!\n");
 595                 return -EIO;
 596         }
 597
 598         list_for_each_entry(port, &pf->ports, port_list)
 599                 if (__nfp_port_get_eth_port(port))
 600                         nfp_net_eth_port_update(pf->cpp, port, eth_table);
 601         rtnl_unlock();
 602
 603         kfree(eth_table);
 604
 605         /* Resync repr state. This may cause reprs to be removed. */
 606         err = nfp_reprs_resync_phys_ports(pf->app);
 607         if (err)
 608                 return err;
 609
 610         /* Shoot off the ports which became invalid */
 611         list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
 612                 if (!nn->port || nn->port->type != NFP_PORT_INVALID)
 613                         continue;
 614
 615                 nfp_net_pf_clean_vnic(pf, nn);
 616                 nfp_net_pf_free_vnic(pf, nn);
 617         }
 618
 619         return 0;
 620 }
 621
 622 static void nfp_net_refresh_vnics(struct work_struct *work)
 623 {
 624         struct nfp_pf *pf = container_of(work, struct nfp_pf,
 625                                          port_refresh_work);
 626
 627         mutex_lock(&pf->lock);
 628         nfp_net_refresh_port_table_sync(pf);
 629         mutex_unlock(&pf->lock);
 630 }
 631
 632 void nfp_net_refresh_port_table(struct nfp_port *port)
 633 {
 634         struct nfp_pf *pf = port->app->pf;
 635
 636         set_bit(NFP_PORT_CHANGED, &port->flags);
 637
 638         queue_work(pf->wq, &pf->port_refresh_work);
 639 }
 640
 641 int nfp_net_refresh_eth_port(struct nfp_port *port)
 642 {
 643         struct nfp_cpp *cpp = port->app->cpp;
 644         struct nfp_eth_table *eth_table;
 645         int ret;
 646
 647         clear_bit(NFP_PORT_CHANGED, &port->flags);
 648
 649         eth_table = nfp_eth_read_ports(cpp);
 650         if (!eth_table) {
 651                 set_bit(NFP_PORT_CHANGED, &port->flags);
 652                 nfp_err(cpp, "Error refreshing port state table!\n");
 653                 return -EIO;
 654         }
 655
 656         ret = nfp_net_eth_port_update(cpp, port, eth_table);
 657
 658         kfree(eth_table);
 659
 660         return ret;
 661 }
 662
 663 /*
 664  * PCI device functions
 665  */
 666 int nfp_net_pci_probe(struct nfp_pf *pf)
 667 {
 668         struct devlink *devlink = priv_to_devlink(pf);
 669         struct nfp_net_fw_version fw_ver;
 670         u8 __iomem *ctrl_bar, *qc_bar;
 671         int stride;
 672         int err;
 673
 674         INIT_WORK(&pf->port_refresh_work, nfp_net_refresh_vnics);
 675
 676         if (!pf->rtbl) {
 677                 nfp_err(pf->cpp, "No %s, giving up.\n",
 678                         pf->fw_loaded ? "symbol table" : "firmware found");
 679                 return -EINVAL;
 680         }
 681
 682         pf->max_data_vnics = nfp_net_pf_get_num_ports(pf);
 683         if ((int)pf->max_data_vnics < 0)
 684                 return pf->max_data_vnics;
 685
 686         err = nfp_net_pci_map_mem(pf);
 687         if (err)
 688                 return err;
 689
 690         ctrl_bar = nfp_cpp_area_iomem(pf->data_vnic_bar);
 691         qc_bar = nfp_cpp_area_iomem(pf->qc_area);
 692         if (!ctrl_bar || !qc_bar) {
 693                 err = -EIO;
 694                 goto err_unmap;
 695         }
 696
 697         nfp_net_get_fw_version(&fw_ver, ctrl_bar);
 698         if (fw_ver.resv || fw_ver.class != NFP_NET_CFG_VERSION_CLASS_GENERIC) {
 699                 nfp_err(pf->cpp, "Unknown Firmware ABI %d.%d.%d.%d\n",
 700                         fw_ver.resv, fw_ver.class, fw_ver.major, fw_ver.minor);
 701                 err = -EINVAL;
 702                 goto err_unmap;
 703         }
 704
 705         /* Determine stride */
 706         if (nfp_net_fw_ver_eq(&fw_ver, 0, 0, 0, 1)) {
 707                 stride = 2;
 708                 nfp_warn(pf->cpp, "OBSOLETE Firmware detected - VF isolation not available\n");
 709         } else {
 710                 switch (fw_ver.major) {
 711                 case 1 ... 5:
 712                         stride = 4;
 713                         break;
 714                 default:
 715                         nfp_err(pf->cpp, "Unsupported Firmware ABI %d.%d.%d.%d\n",
 716                                 fw_ver.resv, fw_ver.class,
 717                                 fw_ver.major, fw_ver.minor);
 718                         err = -EINVAL;
 719                         goto err_unmap;
 720                 }
 721         }
 722
 723         err = nfp_net_pf_app_init(pf, qc_bar, stride);
 724         if (err)
 725                 goto err_unmap;
 726
 727         err = devlink_register(devlink, &pf->pdev->dev);
 728         if (err)
 729                 goto err_app_clean;
 730
 731         err = nfp_shared_buf_register(pf);
 732         if (err)
 733                 goto err_devlink_unreg;
 734
 735         mutex_lock(&pf->lock);
 736         pf->ddir = nfp_net_debugfs_device_add(pf->pdev);
 737
 738         /* Allocate the vnics and do basic init */
 739         err = nfp_net_pf_alloc_vnics(pf, ctrl_bar, qc_bar, stride);
 740         if (err)
 741                 goto err_clean_ddir;
 742
 743         err = nfp_net_pf_alloc_irqs(pf);
 744         if (err)
 745                 goto err_free_vnics;
 746
 747         err = nfp_net_pf_app_start(pf);
 748         if (err)
 749                 goto err_free_irqs;
 750
 751         err = nfp_net_pf_init_vnics(pf);
 752         if (err)
 753                 goto err_stop_app;
 754
 755         mutex_unlock(&pf->lock);
 756
 757         return 0;
 758
 759 err_stop_app:
 760         nfp_net_pf_app_stop(pf);
 761 err_free_irqs:
 762         nfp_net_pf_free_irqs(pf);
 763 err_free_vnics:
 764         nfp_net_pf_free_vnics(pf);
 765 err_clean_ddir:
 766         nfp_net_debugfs_dir_clean(&pf->ddir);
 767         mutex_unlock(&pf->lock);
 768         nfp_shared_buf_unregister(pf);
 769 err_devlink_unreg:
 770         cancel_work_sync(&pf->port_refresh_work);
 771         devlink_unregister(devlink);
 772 err_app_clean:
 773         nfp_net_pf_app_clean(pf);
 774 err_unmap:
 775         nfp_net_pci_unmap_mem(pf);
 776         return err;
 777 }
 778
 779 void nfp_net_pci_remove(struct nfp_pf *pf)
 780 {
 781         struct nfp_net *nn, *next;
 782
 783         mutex_lock(&pf->lock);
 784         list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
 785                 if (!nfp_net_is_data_vnic(nn))
 786                         continue;
 787                 nfp_net_pf_clean_vnic(pf, nn);
 788                 nfp_net_pf_free_vnic(pf, nn);
 789         }
 790
 791         nfp_net_pf_app_stop(pf);
 792         /* stop app first, to avoid double free of ctrl vNIC's ddir */
 793         nfp_net_debugfs_dir_clean(&pf->ddir);
 794
 795         mutex_unlock(&pf->lock);
 796
 797         nfp_shared_buf_unregister(pf);
 798         devlink_unregister(priv_to_devlink(pf));
 799
 800         nfp_net_pf_free_irqs(pf);
 801         nfp_net_pf_app_clean(pf);
 802         nfp_net_pci_unmap_mem(pf);
 803
 804         cancel_work_sync(&pf->port_refresh_work);
 805 }