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