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         nn->id = id;
 182
 183         err = nfp_net_init(nn);
 184         if (err)
 185                 return err;
 186
 187         nfp_net_debugfs_vnic_add(nn, pf->ddir);
 188
 189         if (nn->port) {
 190                 err = nfp_devlink_port_register(pf->app, nn->port);
 191                 if (err)
 192                         goto err_dfs_clean;
 193         }
 194
 195         nfp_net_info(nn);
 196
 197         if (nfp_net_is_data_vnic(nn)) {
 198                 err = nfp_app_vnic_init(pf->app, nn);
 199                 if (err)
 200                         goto err_devlink_port_clean;
 201         }
 202
 203         return 0;
 204
 205 err_devlink_port_clean:
 206         if (nn->port)
 207                 nfp_devlink_port_unregister(nn->port);
 208 err_dfs_clean:
 209         nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
 210         nfp_net_clean(nn);
 211         return err;
 212 }
 213
 214 static int
 215 nfp_net_pf_alloc_vnics(struct nfp_pf *pf, void __iomem *ctrl_bar,
 216                        void __iomem *qc_bar, int stride)
 217 {
 218         struct nfp_net *nn;
 219         unsigned int i;
 220         int err;
 221
 222         for (i = 0; i < pf->max_data_vnics; i++) {
 223                 nn = nfp_net_pf_alloc_vnic(pf, true, ctrl_bar, qc_bar,
 224                                            stride, i);
 225                 if (IS_ERR(nn)) {
 226                         err = PTR_ERR(nn);
 227                         goto err_free_prev;
 228                 }
 229
 230                 ctrl_bar += NFP_PF_CSR_SLICE_SIZE;
 231
 232                 /* Kill the vNIC if app init marked it as invalid */
 233                 if (nn->port && nn->port->type == NFP_PORT_INVALID) {
 234                         nfp_net_pf_free_vnic(pf, nn);
 235                         continue;
 236                 }
 237         }
 238
 239         if (list_empty(&pf->vnics))
 240                 return -ENODEV;
 241
 242         return 0;
 243
 244 err_free_prev:
 245         nfp_net_pf_free_vnics(pf);
 246         return err;
 247 }
 248
 249 static void nfp_net_pf_clean_vnic(struct nfp_pf *pf, struct nfp_net *nn)
 250 {
 251         if (nfp_net_is_data_vnic(nn))
 252                 nfp_app_vnic_clean(pf->app, nn);
 253         if (nn->port)
 254                 nfp_devlink_port_unregister(nn->port);
 255         nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
 256         nfp_net_clean(nn);
 257 }
 258
 259 static int nfp_net_pf_alloc_irqs(struct nfp_pf *pf)
 260 {
 261         unsigned int wanted_irqs, num_irqs, vnics_left, irqs_left;
 262         struct nfp_net *nn;
 263
 264         /* Get MSI-X vectors */
 265         wanted_irqs = 0;
 266         list_for_each_entry(nn, &pf->vnics, vnic_list)
 267                 wanted_irqs += NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs;
 268         pf->irq_entries = kcalloc(wanted_irqs, sizeof(*pf->irq_entries),
 269                                   GFP_KERNEL);
 270         if (!pf->irq_entries)
 271                 return -ENOMEM;
 272
 273         num_irqs = nfp_net_irqs_alloc(pf->pdev, pf->irq_entries,
 274                                       NFP_NET_MIN_VNIC_IRQS * pf->num_vnics,
 275                                       wanted_irqs);
 276         if (!num_irqs) {
 277                 nfp_warn(pf->cpp, "Unable to allocate MSI-X vectors\n");
 278                 kfree(pf->irq_entries);
 279                 return -ENOMEM;
 280         }
 281
 282         /* Distribute IRQs to vNICs */
 283         irqs_left = num_irqs;
 284         vnics_left = pf->num_vnics;
 285         list_for_each_entry(nn, &pf->vnics, vnic_list) {
 286                 unsigned int n;
 287
 288                 n = min(NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs,
 289                         DIV_ROUND_UP(irqs_left, vnics_left));
 290                 nfp_net_irqs_assign(nn, &pf->irq_entries[num_irqs - irqs_left],
 291                                     n);
 292                 irqs_left -= n;
 293                 vnics_left--;
 294         }
 295
 296         return 0;
 297 }
 298
 299 static void nfp_net_pf_free_irqs(struct nfp_pf *pf)
 300 {
 301         nfp_net_irqs_disable(pf->pdev);
 302         kfree(pf->irq_entries);
 303 }
 304
 305 static int nfp_net_pf_init_vnics(struct nfp_pf *pf)
 306 {
 307         struct nfp_net *nn;
 308         unsigned int id;
 309         int err;
 310
 311         /* Finish vNIC init and register */
 312         id = 0;
 313         list_for_each_entry(nn, &pf->vnics, vnic_list) {
 314                 if (!nfp_net_is_data_vnic(nn))
 315                         continue;
 316                 err = nfp_net_pf_init_vnic(pf, nn, id);
 317                 if (err)
 318                         goto err_prev_deinit;
 319
 320                 id++;
 321         }
 322
 323         return 0;
 324
 325 err_prev_deinit:
 326         list_for_each_entry_continue_reverse(nn, &pf->vnics, vnic_list)
 327                 if (nfp_net_is_data_vnic(nn))
 328                         nfp_net_pf_clean_vnic(pf, nn);
 329         return err;
 330 }
 331
 332 static int
 333 nfp_net_pf_app_init(struct nfp_pf *pf, u8 __iomem *qc_bar, unsigned int stride)
 334 {
 335         u8 __iomem *ctrl_bar;
 336         int err;
 337
 338         pf->app = nfp_app_alloc(pf, nfp_net_pf_get_app_id(pf));
 339         if (IS_ERR(pf->app))
 340                 return PTR_ERR(pf->app);
 341
 342         mutex_lock(&pf->lock);
 343         err = nfp_app_init(pf->app);
 344         mutex_unlock(&pf->lock);
 345         if (err)
 346                 goto err_free;
 347
 348         if (!nfp_app_needs_ctrl_vnic(pf->app))
 349                 return 0;
 350
 351         ctrl_bar = nfp_pf_map_rtsym(pf, "net.ctrl", "_pf%u_net_ctrl_bar",
 352                                     NFP_PF_CSR_SLICE_SIZE, &pf->ctrl_vnic_bar);
 353         if (IS_ERR(ctrl_bar)) {
 354                 nfp_err(pf->cpp, "Failed to find ctrl vNIC memory symbol\n");
 355                 err = PTR_ERR(ctrl_bar);
 356                 goto err_app_clean;
 357         }
 358
 359         pf->ctrl_vnic = nfp_net_pf_alloc_vnic(pf, false, ctrl_bar, qc_bar,
 360                                               stride, 0);
 361         if (IS_ERR(pf->ctrl_vnic)) {
 362                 err = PTR_ERR(pf->ctrl_vnic);
 363                 goto err_unmap;
 364         }
 365
 366         return 0;
 367
 368 err_unmap:
 369         nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
 370 err_app_clean:
 371         mutex_lock(&pf->lock);
 372         nfp_app_clean(pf->app);
 373         mutex_unlock(&pf->lock);
 374 err_free:
 375         nfp_app_free(pf->app);
 376         pf->app = NULL;
 377         return err;
 378 }
 379
 380 static void nfp_net_pf_app_clean(struct nfp_pf *pf)
 381 {
 382         if (pf->ctrl_vnic) {
 383                 nfp_net_pf_free_vnic(pf, pf->ctrl_vnic);
 384                 nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
 385         }
 386
 387         mutex_lock(&pf->lock);
 388         nfp_app_clean(pf->app);
 389         mutex_unlock(&pf->lock);
 390
 391         nfp_app_free(pf->app);
 392         pf->app = NULL;
 393 }
 394
 395 static int nfp_net_pf_app_start_ctrl(struct nfp_pf *pf)
 396 {
 397         int err;
 398
 399         if (!pf->ctrl_vnic)
 400                 return 0;
 401         err = nfp_net_pf_init_vnic(pf, pf->ctrl_vnic, 0);
 402         if (err)
 403                 return err;
 404
 405         err = nfp_ctrl_open(pf->ctrl_vnic);
 406         if (err)
 407                 goto err_clean_ctrl;
 408
 409         return 0;
 410
 411 err_clean_ctrl:
 412         nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
 413         return err;
 414 }
 415
 416 static void nfp_net_pf_app_stop_ctrl(struct nfp_pf *pf)
 417 {
 418         if (!pf->ctrl_vnic)
 419                 return;
 420         nfp_ctrl_close(pf->ctrl_vnic);
 421         nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
 422 }
 423
 424 static int nfp_net_pf_app_start(struct nfp_pf *pf)
 425 {
 426         int err;
 427
 428         err = nfp_net_pf_app_start_ctrl(pf);
 429         if (err)
 430                 return err;
 431
 432         err = nfp_app_start(pf->app, pf->ctrl_vnic);
 433         if (err)
 434                 goto err_ctrl_stop;
 435
 436         if (pf->num_vfs) {
 437                 err = nfp_app_sriov_enable(pf->app, pf->num_vfs);
 438                 if (err)
 439                         goto err_app_stop;
 440         }
 441
 442         return 0;
 443
 444 err_app_stop:
 445         nfp_app_stop(pf->app);
 446 err_ctrl_stop:
 447         nfp_net_pf_app_stop_ctrl(pf);
 448         return err;
 449 }
 450
 451 static void nfp_net_pf_app_stop(struct nfp_pf *pf)
 452 {
 453         if (pf->num_vfs)
 454                 nfp_app_sriov_disable(pf->app);
 455         nfp_app_stop(pf->app);
 456         nfp_net_pf_app_stop_ctrl(pf);
 457 }
 458
 459 static void nfp_net_pci_unmap_mem(struct nfp_pf *pf)
 460 {
 461         if (pf->vfcfg_tbl2_area)
 462                 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
 463         if (pf->vf_cfg_bar)
 464                 nfp_cpp_area_release_free(pf->vf_cfg_bar);
 465         if (pf->mac_stats_bar)
 466                 nfp_cpp_area_release_free(pf->mac_stats_bar);
 467         nfp_cpp_area_release_free(pf->qc_area);
 468         nfp_cpp_area_release_free(pf->data_vnic_bar);
 469 }
 470
 471 static int nfp_net_pci_map_mem(struct nfp_pf *pf)
 472 {
 473         u8 __iomem *mem;
 474         u32 min_size;
 475         int err;
 476
 477         min_size = pf->max_data_vnics * NFP_PF_CSR_SLICE_SIZE;
 478         mem = nfp_pf_map_rtsym(pf, "net.bar0", "_pf%d_net_bar0",
 479                                min_size, &pf->data_vnic_bar);
 480         if (IS_ERR(mem)) {
 481                 nfp_err(pf->cpp, "Failed to find data vNIC memory symbol\n");
 482                 return PTR_ERR(mem);
 483         }
 484
 485         if (pf->eth_tbl) {
 486                 min_size =  NFP_MAC_STATS_SIZE * (pf->eth_tbl->max_index + 1);
 487                 pf->mac_stats_mem = nfp_rtsym_map(pf->rtbl, "_mac_stats",
 488                                                   "net.macstats", min_size,
 489                                                   &pf->mac_stats_bar);
 490                 if (IS_ERR(pf->mac_stats_mem)) {
 491                         if (PTR_ERR(pf->mac_stats_mem) != -ENOENT) {
 492                                 err = PTR_ERR(pf->mac_stats_mem);
 493                                 goto err_unmap_ctrl;
 494                         }
 495                         pf->mac_stats_mem = NULL;
 496                 }
 497         }
 498
 499         pf->vf_cfg_mem = nfp_pf_map_rtsym(pf, "net.vfcfg", "_pf%d_net_vf_bar",
 500                                           NFP_NET_CFG_BAR_SZ * pf->limit_vfs,
 501                                           &pf->vf_cfg_bar);
 502         if (IS_ERR(pf->vf_cfg_mem)) {
 503                 if (PTR_ERR(pf->vf_cfg_mem) != -ENOENT) {
 504                         err = PTR_ERR(pf->vf_cfg_mem);
 505                         goto err_unmap_mac_stats;
 506                 }
 507                 pf->vf_cfg_mem = NULL;
 508         }
 509
 510         min_size = NFP_NET_VF_CFG_SZ * pf->limit_vfs + NFP_NET_VF_CFG_MB_SZ;
 511         pf->vfcfg_tbl2 = nfp_pf_map_rtsym(pf, "net.vfcfg_tbl2",
 512                                           "_pf%d_net_vf_cfg2",
 513                                           min_size, &pf->vfcfg_tbl2_area);
 514         if (IS_ERR(pf->vfcfg_tbl2)) {
 515                 if (PTR_ERR(pf->vfcfg_tbl2) != -ENOENT) {
 516                         err = PTR_ERR(pf->vfcfg_tbl2);
 517                         goto err_unmap_vf_cfg;
 518                 }
 519                 pf->vfcfg_tbl2 = NULL;
 520         }
 521
 522         mem = nfp_cpp_map_area(pf->cpp, "net.qc", 0, 0,
 523                                NFP_PCIE_QUEUE(0), NFP_QCP_QUEUE_AREA_SZ,
 524                                &pf->qc_area);
 525         if (IS_ERR(mem)) {
 526                 nfp_err(pf->cpp, "Failed to map Queue Controller area.\n");
 527                 err = PTR_ERR(mem);
 528                 goto err_unmap_vfcfg_tbl2;
 529         }
 530
 531         return 0;
 532
 533 err_unmap_vfcfg_tbl2:
 534         if (pf->vfcfg_tbl2_area)
 535                 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
 536 err_unmap_vf_cfg:
 537         if (pf->vf_cfg_bar)
 538                 nfp_cpp_area_release_free(pf->vf_cfg_bar);
 539 err_unmap_mac_stats:
 540         if (pf->mac_stats_bar)
 541                 nfp_cpp_area_release_free(pf->mac_stats_bar);
 542 err_unmap_ctrl:
 543         nfp_cpp_area_release_free(pf->data_vnic_bar);
 544         return err;
 545 }
 546
 547 static int
 548 nfp_net_eth_port_update(struct nfp_cpp *cpp, struct nfp_port *port,
 549                         struct nfp_eth_table *eth_table)
 550 {
 551         struct nfp_eth_table_port *eth_port;
 552
 553         ASSERT_RTNL();
 554
 555         eth_port = nfp_net_find_port(eth_table, port->eth_id);
 556         if (!eth_port) {
 557                 set_bit(NFP_PORT_CHANGED, &port->flags);
 558                 nfp_warn(cpp, "Warning: port #%d not present after reconfig\n",
 559                          port->eth_id);
 560                 return -EIO;
 561         }
 562         if (eth_port->override_changed) {
 563                 nfp_warn(cpp, "Port #%d config changed, unregistering. Driver reload required before port will be operational again.\n", port->eth_id);
 564                 port->type = NFP_PORT_INVALID;
 565         }
 566
 567         memcpy(port->eth_port, eth_port, sizeof(*eth_port));
 568
 569         return 0;
 570 }
 571
 572 int nfp_net_refresh_port_table_sync(struct nfp_pf *pf)
 573 {
 574         struct nfp_eth_table *eth_table;
 575         struct nfp_net *nn, *next;
 576         struct nfp_port *port;
 577         int err;
 578
 579         lockdep_assert_held(&pf->lock);
 580
 581         /* Check for nfp_net_pci_remove() racing against us */
 582         if (list_empty(&pf->vnics))
 583                 return 0;
 584
 585         /* Update state of all ports */
 586         rtnl_lock();
 587         list_for_each_entry(port, &pf->ports, port_list)
 588                 clear_bit(NFP_PORT_CHANGED, &port->flags);
 589
 590         eth_table = nfp_eth_read_ports(pf->cpp);
 591         if (!eth_table) {
 592                 list_for_each_entry(port, &pf->ports, port_list)
 593                         if (__nfp_port_get_eth_port(port))
 594                                 set_bit(NFP_PORT_CHANGED, &port->flags);
 595                 rtnl_unlock();
 596                 nfp_err(pf->cpp, "Error refreshing port config!\n");
 597                 return -EIO;
 598         }
 599
 600         list_for_each_entry(port, &pf->ports, port_list)
 601                 if (__nfp_port_get_eth_port(port))
 602                         nfp_net_eth_port_update(pf->cpp, port, eth_table);
 603         rtnl_unlock();
 604
 605         kfree(eth_table);
 606
 607         /* Resync repr state. This may cause reprs to be removed. */
 608         err = nfp_reprs_resync_phys_ports(pf->app);
 609         if (err)
 610                 return err;
 611
 612         /* Shoot off the ports which became invalid */
 613         list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
 614                 if (!nn->port || nn->port->type != NFP_PORT_INVALID)
 615                         continue;
 616
 617                 nfp_net_pf_clean_vnic(pf, nn);
 618                 nfp_net_pf_free_vnic(pf, nn);
 619         }
 620
 621         return 0;
 622 }
 623
 624 static void nfp_net_refresh_vnics(struct work_struct *work)
 625 {
 626         struct nfp_pf *pf = container_of(work, struct nfp_pf,
 627                                          port_refresh_work);
 628
 629         mutex_lock(&pf->lock);
 630         nfp_net_refresh_port_table_sync(pf);
 631         mutex_unlock(&pf->lock);
 632 }
 633
 634 void nfp_net_refresh_port_table(struct nfp_port *port)
 635 {
 636         struct nfp_pf *pf = port->app->pf;
 637
 638         set_bit(NFP_PORT_CHANGED, &port->flags);
 639
 640         queue_work(pf->wq, &pf->port_refresh_work);
 641 }
 642
 643 int nfp_net_refresh_eth_port(struct nfp_port *port)
 644 {
 645         struct nfp_cpp *cpp = port->app->cpp;
 646         struct nfp_eth_table *eth_table;
 647         int ret;
 648
 649         clear_bit(NFP_PORT_CHANGED, &port->flags);
 650
 651         eth_table = nfp_eth_read_ports(cpp);
 652         if (!eth_table) {
 653                 set_bit(NFP_PORT_CHANGED, &port->flags);
 654                 nfp_err(cpp, "Error refreshing port state table!\n");
 655                 return -EIO;
 656         }
 657
 658         ret = nfp_net_eth_port_update(cpp, port, eth_table);
 659
 660         kfree(eth_table);
 661
 662         return ret;
 663 }
 664
 665 /*
 666  * PCI device functions
 667  */
 668 int nfp_net_pci_probe(struct nfp_pf *pf)
 669 {
 670         struct devlink *devlink = priv_to_devlink(pf);
 671         struct nfp_net_fw_version fw_ver;
 672         u8 __iomem *ctrl_bar, *qc_bar;
 673         int stride;
 674         int err;
 675
 676         INIT_WORK(&pf->port_refresh_work, nfp_net_refresh_vnics);
 677
 678         if (!pf->rtbl) {
 679                 nfp_err(pf->cpp, "No %s, giving up.\n",
 680                         pf->fw_loaded ? "symbol table" : "firmware found");
 681                 return -EINVAL;
 682         }
 683
 684         pf->max_data_vnics = nfp_net_pf_get_num_ports(pf);
 685         if ((int)pf->max_data_vnics < 0)
 686                 return pf->max_data_vnics;
 687
 688         err = nfp_net_pci_map_mem(pf);
 689         if (err)
 690                 return err;
 691
 692         ctrl_bar = nfp_cpp_area_iomem(pf->data_vnic_bar);
 693         qc_bar = nfp_cpp_area_iomem(pf->qc_area);
 694         if (!ctrl_bar || !qc_bar) {
 695                 err = -EIO;
 696                 goto err_unmap;
 697         }
 698
 699         nfp_net_get_fw_version(&fw_ver, ctrl_bar);
 700         if (fw_ver.resv || fw_ver.class != NFP_NET_CFG_VERSION_CLASS_GENERIC) {
 701                 nfp_err(pf->cpp, "Unknown Firmware ABI %d.%d.%d.%d\n",
 702                         fw_ver.resv, fw_ver.class, fw_ver.major, fw_ver.minor);
 703                 err = -EINVAL;
 704                 goto err_unmap;
 705         }
 706
 707         /* Determine stride */
 708         if (nfp_net_fw_ver_eq(&fw_ver, 0, 0, 0, 1)) {
 709                 stride = 2;
 710                 nfp_warn(pf->cpp, "OBSOLETE Firmware detected - VF isolation not available\n");
 711         } else {
 712                 switch (fw_ver.major) {
 713                 case 1 ... 5:
 714                         stride = 4;
 715                         break;
 716                 default:
 717                         nfp_err(pf->cpp, "Unsupported Firmware ABI %d.%d.%d.%d\n",
 718                                 fw_ver.resv, fw_ver.class,
 719                                 fw_ver.major, fw_ver.minor);
 720                         err = -EINVAL;
 721                         goto err_unmap;
 722                 }
 723         }
 724
 725         err = nfp_net_pf_app_init(pf, qc_bar, stride);
 726         if (err)
 727                 goto err_unmap;
 728
 729         err = devlink_register(devlink, &pf->pdev->dev);
 730         if (err)
 731                 goto err_app_clean;
 732
 733         err = nfp_shared_buf_register(pf);
 734         if (err)
 735                 goto err_devlink_unreg;
 736
 737         mutex_lock(&pf->lock);
 738         pf->ddir = nfp_net_debugfs_device_add(pf->pdev);
 739
 740         /* Allocate the vnics and do basic init */
 741         err = nfp_net_pf_alloc_vnics(pf, ctrl_bar, qc_bar, stride);
 742         if (err)
 743                 goto err_clean_ddir;
 744
 745         err = nfp_net_pf_alloc_irqs(pf);
 746         if (err)
 747                 goto err_free_vnics;
 748
 749         err = nfp_net_pf_app_start(pf);
 750         if (err)
 751                 goto err_free_irqs;
 752
 753         err = nfp_net_pf_init_vnics(pf);
 754         if (err)
 755                 goto err_stop_app;
 756
 757         mutex_unlock(&pf->lock);
 758
 759         return 0;
 760
 761 err_stop_app:
 762         nfp_net_pf_app_stop(pf);
 763 err_free_irqs:
 764         nfp_net_pf_free_irqs(pf);
 765 err_free_vnics:
 766         nfp_net_pf_free_vnics(pf);
 767 err_clean_ddir:
 768         nfp_net_debugfs_dir_clean(&pf->ddir);
 769         mutex_unlock(&pf->lock);
 770         nfp_shared_buf_unregister(pf);
 771 err_devlink_unreg:
 772         cancel_work_sync(&pf->port_refresh_work);
 773         devlink_unregister(devlink);
 774 err_app_clean:
 775         nfp_net_pf_app_clean(pf);
 776 err_unmap:
 777         nfp_net_pci_unmap_mem(pf);
 778         return err;
 779 }
 780
 781 void nfp_net_pci_remove(struct nfp_pf *pf)
 782 {
 783         struct nfp_net *nn, *next;
 784
 785         mutex_lock(&pf->lock);
 786         list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
 787                 if (!nfp_net_is_data_vnic(nn))
 788                         continue;
 789                 nfp_net_pf_clean_vnic(pf, nn);
 790                 nfp_net_pf_free_vnic(pf, nn);
 791         }
 792
 793         nfp_net_pf_app_stop(pf);
 794         /* stop app first, to avoid double free of ctrl vNIC's ddir */
 795         nfp_net_debugfs_dir_clean(&pf->ddir);
 796
 797         mutex_unlock(&pf->lock);
 798
 799         nfp_shared_buf_unregister(pf);
 800         devlink_unregister(priv_to_devlink(pf));
 801
 802         nfp_net_pf_free_irqs(pf);
 803         nfp_net_pf_app_clean(pf);
 804         nfp_net_pci_unmap_mem(pf);
 805
 806         cancel_work_sync(&pf->port_refresh_work);
 807 }