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 ð_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 } 834