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