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