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