1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) 2013-2015 Brocade Communications Systems, Inc. 3 * Copyright (c) 2015-2018 Cavium Inc. 4 * All rights reserved. 5 * www.cavium.com 6 */ 7 8 #include "bnx2x.h" 9 #include "bnx2x_rxtx.h" 10 11 #include <rte_string_fns.h> 12 #include <rte_dev.h> 13 #include <rte_ethdev_pci.h> 14 #include <rte_alarm.h> 15 16 /* 17 * The set of PCI devices this driver supports 18 */ 19 #define BROADCOM_PCI_VENDOR_ID 0x14E4 20 static const struct rte_pci_id pci_id_bnx2x_map[] = { 21 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57800) }, 22 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57711) }, 23 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57810) }, 24 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57811) }, 25 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_OBS) }, 26 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_4_10) }, 27 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_2_20) }, 28 #ifdef RTE_LIBRTE_BNX2X_MF_SUPPORT 29 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57810_MF) }, 30 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57811_MF) }, 31 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_MF) }, 32 #endif 33 { .vendor_id = 0, } 34 }; 35 36 static const struct rte_pci_id pci_id_bnx2xvf_map[] = { 37 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57800_VF) }, 38 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57810_VF) }, 39 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57811_VF) }, 40 { RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_VF) }, 41 { .vendor_id = 0, } 42 }; 43 44 struct rte_bnx2x_xstats_name_off { 45 char name[RTE_ETH_XSTATS_NAME_SIZE]; 46 uint32_t offset_hi; 47 uint32_t offset_lo; 48 }; 49 50 static const struct rte_bnx2x_xstats_name_off bnx2x_xstats_strings[] = { 51 {"rx_buffer_drops", 52 offsetof(struct bnx2x_eth_stats, brb_drop_hi), 53 offsetof(struct bnx2x_eth_stats, brb_drop_lo)}, 54 {"rx_buffer_truncates", 55 offsetof(struct bnx2x_eth_stats, brb_truncate_hi), 56 offsetof(struct bnx2x_eth_stats, brb_truncate_lo)}, 57 {"rx_buffer_truncate_discard", 58 offsetof(struct bnx2x_eth_stats, brb_truncate_discard), 59 offsetof(struct bnx2x_eth_stats, brb_truncate_discard)}, 60 {"mac_filter_discard", 61 offsetof(struct bnx2x_eth_stats, mac_filter_discard), 62 offsetof(struct bnx2x_eth_stats, mac_filter_discard)}, 63 {"no_match_vlan_tag_discard", 64 offsetof(struct bnx2x_eth_stats, mf_tag_discard), 65 offsetof(struct bnx2x_eth_stats, mf_tag_discard)}, 66 {"tx_pause", 67 offsetof(struct bnx2x_eth_stats, pause_frames_sent_hi), 68 offsetof(struct bnx2x_eth_stats, pause_frames_sent_lo)}, 69 {"rx_pause", 70 offsetof(struct bnx2x_eth_stats, pause_frames_received_hi), 71 offsetof(struct bnx2x_eth_stats, pause_frames_received_lo)}, 72 {"tx_priority_flow_control", 73 offsetof(struct bnx2x_eth_stats, pfc_frames_sent_hi), 74 offsetof(struct bnx2x_eth_stats, pfc_frames_sent_lo)}, 75 {"rx_priority_flow_control", 76 offsetof(struct bnx2x_eth_stats, pfc_frames_received_hi), 77 offsetof(struct bnx2x_eth_stats, pfc_frames_received_lo)} 78 }; 79 80 static int 81 bnx2x_link_update(struct rte_eth_dev *dev) 82 { 83 struct bnx2x_softc *sc = dev->data->dev_private; 84 struct rte_eth_link link; 85 86 PMD_INIT_FUNC_TRACE(sc); 87 88 memset(&link, 0, sizeof(link)); 89 mb(); 90 link.link_speed = sc->link_vars.line_speed; 91 switch (sc->link_vars.duplex) { 92 case DUPLEX_FULL: 93 link.link_duplex = ETH_LINK_FULL_DUPLEX; 94 break; 95 case DUPLEX_HALF: 96 link.link_duplex = ETH_LINK_HALF_DUPLEX; 97 break; 98 } 99 link.link_autoneg = !(dev->data->dev_conf.link_speeds & 100 ETH_LINK_SPEED_FIXED); 101 link.link_status = sc->link_vars.link_up; 102 103 return rte_eth_linkstatus_set(dev, &link); 104 } 105 106 static void 107 bnx2x_interrupt_action(struct rte_eth_dev *dev, int intr_cxt) 108 { 109 struct bnx2x_softc *sc = dev->data->dev_private; 110 uint32_t link_status; 111 112 bnx2x_intr_legacy(sc); 113 114 if ((atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO) && 115 !intr_cxt) 116 bnx2x_periodic_callout(sc); 117 link_status = REG_RD(sc, sc->link_params.shmem_base + 118 offsetof(struct shmem_region, 119 port_mb[sc->link_params.port].link_status)); 120 if ((link_status & LINK_STATUS_LINK_UP) != dev->data->dev_link.link_status) 121 bnx2x_link_update(dev); 122 } 123 124 static void 125 bnx2x_interrupt_handler(void *param) 126 { 127 struct rte_eth_dev *dev = (struct rte_eth_dev *)param; 128 struct bnx2x_softc *sc = dev->data->dev_private; 129 130 PMD_DEBUG_PERIODIC_LOG(INFO, sc, "Interrupt handled"); 131 132 bnx2x_interrupt_action(dev, 1); 133 rte_intr_ack(&sc->pci_dev->intr_handle); 134 } 135 136 static void bnx2x_periodic_start(void *param) 137 { 138 struct rte_eth_dev *dev = (struct rte_eth_dev *)param; 139 struct bnx2x_softc *sc = dev->data->dev_private; 140 int ret = 0; 141 142 atomic_store_rel_long(&sc->periodic_flags, PERIODIC_GO); 143 bnx2x_interrupt_action(dev, 0); 144 if (IS_PF(sc)) { 145 ret = rte_eal_alarm_set(BNX2X_SP_TIMER_PERIOD, 146 bnx2x_periodic_start, (void *)dev); 147 if (ret) { 148 PMD_DRV_LOG(ERR, sc, "Unable to start periodic" 149 " timer rc %d", ret); 150 } 151 } 152 } 153 154 void bnx2x_periodic_stop(void *param) 155 { 156 struct rte_eth_dev *dev = (struct rte_eth_dev *)param; 157 struct bnx2x_softc *sc = dev->data->dev_private; 158 159 atomic_store_rel_long(&sc->periodic_flags, PERIODIC_STOP); 160 161 rte_eal_alarm_cancel(bnx2x_periodic_start, (void *)dev); 162 163 PMD_DRV_LOG(DEBUG, sc, "Periodic poll stopped"); 164 } 165 166 /* 167 * Devops - helper functions can be called from user application 168 */ 169 170 static int 171 bnx2x_dev_configure(struct rte_eth_dev *dev) 172 { 173 struct bnx2x_softc *sc = dev->data->dev_private; 174 struct rte_eth_rxmode *rxmode = &dev->data->dev_conf.rxmode; 175 176 int mp_ncpus = sysconf(_SC_NPROCESSORS_CONF); 177 178 PMD_INIT_FUNC_TRACE(sc); 179 180 if (rxmode->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) { 181 sc->mtu = dev->data->dev_conf.rxmode.max_rx_pkt_len; 182 dev->data->mtu = sc->mtu; 183 } 184 185 if (dev->data->nb_tx_queues > dev->data->nb_rx_queues) { 186 PMD_DRV_LOG(ERR, sc, "The number of TX queues is greater than number of RX queues"); 187 return -EINVAL; 188 } 189 190 sc->num_queues = MAX(dev->data->nb_rx_queues, dev->data->nb_tx_queues); 191 if (sc->num_queues > mp_ncpus) { 192 PMD_DRV_LOG(ERR, sc, "The number of queues is more than number of CPUs"); 193 return -EINVAL; 194 } 195 196 PMD_DRV_LOG(DEBUG, sc, "num_queues=%d, mtu=%d", 197 sc->num_queues, sc->mtu); 198 199 /* allocate ilt */ 200 if (bnx2x_alloc_ilt_mem(sc) != 0) { 201 PMD_DRV_LOG(ERR, sc, "bnx2x_alloc_ilt_mem was failed"); 202 return -ENXIO; 203 } 204 205 bnx2x_dev_rxtx_init_dummy(dev); 206 return 0; 207 } 208 209 static int 210 bnx2x_dev_start(struct rte_eth_dev *dev) 211 { 212 struct bnx2x_softc *sc = dev->data->dev_private; 213 int ret = 0; 214 215 PMD_INIT_FUNC_TRACE(sc); 216 217 /* start the periodic callout */ 218 if (IS_PF(sc)) { 219 if (atomic_load_acq_long(&sc->periodic_flags) == 220 PERIODIC_STOP) { 221 bnx2x_periodic_start(dev); 222 PMD_DRV_LOG(DEBUG, sc, "Periodic poll re-started"); 223 } 224 } 225 226 ret = bnx2x_init(sc); 227 if (ret) { 228 PMD_DRV_LOG(DEBUG, sc, "bnx2x_init failed (%d)", ret); 229 return -1; 230 } 231 232 if (IS_PF(sc)) { 233 rte_intr_callback_register(&sc->pci_dev->intr_handle, 234 bnx2x_interrupt_handler, (void *)dev); 235 236 if (rte_intr_enable(&sc->pci_dev->intr_handle)) 237 PMD_DRV_LOG(ERR, sc, "rte_intr_enable failed"); 238 } 239 240 /* Configure the previously stored Multicast address list */ 241 if (IS_VF(sc)) 242 bnx2x_vfpf_set_mcast(sc, sc->mc_addrs, sc->mc_addrs_num); 243 bnx2x_dev_rxtx_init(dev); 244 245 bnx2x_print_device_info(sc); 246 247 return ret; 248 } 249 250 static void 251 bnx2x_dev_stop(struct rte_eth_dev *dev) 252 { 253 struct bnx2x_softc *sc = dev->data->dev_private; 254 int ret = 0; 255 256 PMD_INIT_FUNC_TRACE(sc); 257 258 bnx2x_dev_rxtx_init_dummy(dev); 259 260 if (IS_PF(sc)) { 261 rte_intr_disable(&sc->pci_dev->intr_handle); 262 rte_intr_callback_unregister(&sc->pci_dev->intr_handle, 263 bnx2x_interrupt_handler, (void *)dev); 264 265 /* stop the periodic callout */ 266 bnx2x_periodic_stop(dev); 267 } 268 /* Remove the configured Multicast list 269 * Sending NULL for the list of address and the 270 * Number is set to 0 denoting DEL_CMD 271 */ 272 if (IS_VF(sc)) 273 bnx2x_vfpf_set_mcast(sc, NULL, 0); 274 ret = bnx2x_nic_unload(sc, UNLOAD_NORMAL, FALSE); 275 if (ret) { 276 PMD_DRV_LOG(DEBUG, sc, "bnx2x_nic_unload failed (%d)", ret); 277 return; 278 } 279 280 return; 281 } 282 283 static int 284 bnx2x_dev_close(struct rte_eth_dev *dev) 285 { 286 struct bnx2x_softc *sc = dev->data->dev_private; 287 288 PMD_INIT_FUNC_TRACE(sc); 289 290 /* only close in case of the primary process */ 291 if (rte_eal_process_type() != RTE_PROC_PRIMARY) 292 return 0; 293 294 if (IS_VF(sc)) 295 bnx2x_vf_close(sc); 296 297 bnx2x_dev_clear_queues(dev); 298 memset(&(dev->data->dev_link), 0 , sizeof(struct rte_eth_link)); 299 300 /* free ilt */ 301 bnx2x_free_ilt_mem(sc); 302 303 /* mac_addrs must not be freed alone because part of dev_private */ 304 dev->data->mac_addrs = NULL; 305 306 return 0; 307 } 308 309 static int 310 bnx2x_promisc_enable(struct rte_eth_dev *dev) 311 { 312 struct bnx2x_softc *sc = dev->data->dev_private; 313 314 PMD_INIT_FUNC_TRACE(sc); 315 sc->rx_mode = BNX2X_RX_MODE_PROMISC; 316 if (rte_eth_allmulticast_get(dev->data->port_id) == 1) 317 sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC; 318 bnx2x_set_rx_mode(sc); 319 320 return 0; 321 } 322 323 static int 324 bnx2x_promisc_disable(struct rte_eth_dev *dev) 325 { 326 struct bnx2x_softc *sc = dev->data->dev_private; 327 328 PMD_INIT_FUNC_TRACE(sc); 329 sc->rx_mode = BNX2X_RX_MODE_NORMAL; 330 if (rte_eth_allmulticast_get(dev->data->port_id) == 1) 331 sc->rx_mode = BNX2X_RX_MODE_ALLMULTI; 332 bnx2x_set_rx_mode(sc); 333 334 return 0; 335 } 336 337 static int 338 bnx2x_dev_allmulticast_enable(struct rte_eth_dev *dev) 339 { 340 struct bnx2x_softc *sc = dev->data->dev_private; 341 342 PMD_INIT_FUNC_TRACE(sc); 343 sc->rx_mode = BNX2X_RX_MODE_ALLMULTI; 344 if (rte_eth_promiscuous_get(dev->data->port_id) == 1) 345 sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC; 346 bnx2x_set_rx_mode(sc); 347 348 return 0; 349 } 350 351 static int 352 bnx2x_dev_allmulticast_disable(struct rte_eth_dev *dev) 353 { 354 struct bnx2x_softc *sc = dev->data->dev_private; 355 356 PMD_INIT_FUNC_TRACE(sc); 357 sc->rx_mode = BNX2X_RX_MODE_NORMAL; 358 if (rte_eth_promiscuous_get(dev->data->port_id) == 1) 359 sc->rx_mode = BNX2X_RX_MODE_PROMISC; 360 bnx2x_set_rx_mode(sc); 361 362 return 0; 363 } 364 365 static int 366 bnx2x_dev_set_mc_addr_list(struct rte_eth_dev *dev, 367 struct rte_ether_addr *mc_addrs, uint32_t mc_addrs_num) 368 { 369 struct bnx2x_softc *sc = dev->data->dev_private; 370 int err; 371 PMD_INIT_FUNC_TRACE(sc); 372 /* flush previous addresses */ 373 err = bnx2x_vfpf_set_mcast(sc, NULL, 0); 374 if (err) 375 return err; 376 sc->mc_addrs_num = 0; 377 378 /* Add new ones */ 379 err = bnx2x_vfpf_set_mcast(sc, mc_addrs, mc_addrs_num); 380 if (err) 381 return err; 382 383 sc->mc_addrs_num = mc_addrs_num; 384 memcpy(sc->mc_addrs, mc_addrs, mc_addrs_num * sizeof(*mc_addrs)); 385 386 return 0; 387 } 388 389 static int 390 bnx2x_dev_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_complete) 391 { 392 struct bnx2x_softc *sc = dev->data->dev_private; 393 394 PMD_INIT_FUNC_TRACE(sc); 395 396 return bnx2x_link_update(dev); 397 } 398 399 static int 400 bnx2xvf_dev_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_complete) 401 { 402 struct bnx2x_softc *sc = dev->data->dev_private; 403 int ret = 0; 404 405 ret = bnx2x_link_update(dev); 406 407 bnx2x_check_bull(sc); 408 if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) { 409 PMD_DRV_LOG(ERR, sc, "PF indicated channel is down." 410 "VF device is no longer operational"); 411 dev->data->dev_link.link_status = ETH_LINK_DOWN; 412 } 413 414 return ret; 415 } 416 417 static int 418 bnx2x_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) 419 { 420 struct bnx2x_softc *sc = dev->data->dev_private; 421 uint32_t brb_truncate_discard; 422 uint64_t brb_drops; 423 uint64_t brb_truncates; 424 425 PMD_INIT_FUNC_TRACE(sc); 426 427 bnx2x_stats_handle(sc, STATS_EVENT_UPDATE); 428 429 memset(stats, 0, sizeof (struct rte_eth_stats)); 430 431 stats->ipackets = 432 HILO_U64(sc->eth_stats.total_unicast_packets_received_hi, 433 sc->eth_stats.total_unicast_packets_received_lo) + 434 HILO_U64(sc->eth_stats.total_multicast_packets_received_hi, 435 sc->eth_stats.total_multicast_packets_received_lo) + 436 HILO_U64(sc->eth_stats.total_broadcast_packets_received_hi, 437 sc->eth_stats.total_broadcast_packets_received_lo); 438 439 stats->opackets = 440 HILO_U64(sc->eth_stats.total_unicast_packets_transmitted_hi, 441 sc->eth_stats.total_unicast_packets_transmitted_lo) + 442 HILO_U64(sc->eth_stats.total_multicast_packets_transmitted_hi, 443 sc->eth_stats.total_multicast_packets_transmitted_lo) + 444 HILO_U64(sc->eth_stats.total_broadcast_packets_transmitted_hi, 445 sc->eth_stats.total_broadcast_packets_transmitted_lo); 446 447 stats->ibytes = 448 HILO_U64(sc->eth_stats.total_bytes_received_hi, 449 sc->eth_stats.total_bytes_received_lo); 450 451 stats->obytes = 452 HILO_U64(sc->eth_stats.total_bytes_transmitted_hi, 453 sc->eth_stats.total_bytes_transmitted_lo); 454 455 stats->ierrors = 456 HILO_U64(sc->eth_stats.error_bytes_received_hi, 457 sc->eth_stats.error_bytes_received_lo); 458 459 stats->oerrors = 0; 460 461 stats->rx_nombuf = 462 HILO_U64(sc->eth_stats.no_buff_discard_hi, 463 sc->eth_stats.no_buff_discard_lo); 464 465 brb_drops = 466 HILO_U64(sc->eth_stats.brb_drop_hi, 467 sc->eth_stats.brb_drop_lo); 468 469 brb_truncates = 470 HILO_U64(sc->eth_stats.brb_truncate_hi, 471 sc->eth_stats.brb_truncate_lo); 472 473 brb_truncate_discard = sc->eth_stats.brb_truncate_discard; 474 475 stats->imissed = brb_drops + brb_truncates + 476 brb_truncate_discard + stats->rx_nombuf; 477 478 return 0; 479 } 480 481 static int 482 bnx2x_get_xstats_names(__rte_unused struct rte_eth_dev *dev, 483 struct rte_eth_xstat_name *xstats_names, 484 __rte_unused unsigned limit) 485 { 486 unsigned int i, stat_cnt = RTE_DIM(bnx2x_xstats_strings); 487 488 if (xstats_names != NULL) 489 for (i = 0; i < stat_cnt; i++) 490 strlcpy(xstats_names[i].name, 491 bnx2x_xstats_strings[i].name, 492 sizeof(xstats_names[i].name)); 493 494 return stat_cnt; 495 } 496 497 static int 498 bnx2x_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats, 499 unsigned int n) 500 { 501 struct bnx2x_softc *sc = dev->data->dev_private; 502 unsigned int num = RTE_DIM(bnx2x_xstats_strings); 503 504 if (n < num) 505 return num; 506 507 bnx2x_stats_handle(sc, STATS_EVENT_UPDATE); 508 509 for (num = 0; num < n; num++) { 510 if (bnx2x_xstats_strings[num].offset_hi != 511 bnx2x_xstats_strings[num].offset_lo) 512 xstats[num].value = HILO_U64( 513 *(uint32_t *)((char *)&sc->eth_stats + 514 bnx2x_xstats_strings[num].offset_hi), 515 *(uint32_t *)((char *)&sc->eth_stats + 516 bnx2x_xstats_strings[num].offset_lo)); 517 else 518 xstats[num].value = 519 *(uint64_t *)((char *)&sc->eth_stats + 520 bnx2x_xstats_strings[num].offset_lo); 521 xstats[num].id = num; 522 } 523 524 return num; 525 } 526 527 static int 528 bnx2x_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) 529 { 530 struct bnx2x_softc *sc = dev->data->dev_private; 531 532 dev_info->max_rx_queues = sc->max_rx_queues; 533 dev_info->max_tx_queues = sc->max_tx_queues; 534 dev_info->min_rx_bufsize = BNX2X_MIN_RX_BUF_SIZE; 535 dev_info->max_rx_pktlen = BNX2X_MAX_RX_PKT_LEN; 536 dev_info->max_mac_addrs = BNX2X_MAX_MAC_ADDRS; 537 dev_info->speed_capa = ETH_LINK_SPEED_10G | ETH_LINK_SPEED_20G; 538 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_JUMBO_FRAME; 539 540 dev_info->rx_desc_lim.nb_max = MAX_RX_AVAIL; 541 dev_info->rx_desc_lim.nb_min = MIN_RX_SIZE_NONTPA; 542 dev_info->rx_desc_lim.nb_mtu_seg_max = 1; 543 dev_info->tx_desc_lim.nb_max = MAX_TX_AVAIL; 544 545 return 0; 546 } 547 548 static int 549 bnx2x_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr, 550 uint32_t index, uint32_t pool) 551 { 552 struct bnx2x_softc *sc = dev->data->dev_private; 553 554 if (sc->mac_ops.mac_addr_add) { 555 sc->mac_ops.mac_addr_add(dev, mac_addr, index, pool); 556 return 0; 557 } 558 return -ENOTSUP; 559 } 560 561 static void 562 bnx2x_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index) 563 { 564 struct bnx2x_softc *sc = dev->data->dev_private; 565 566 if (sc->mac_ops.mac_addr_remove) 567 sc->mac_ops.mac_addr_remove(dev, index); 568 } 569 570 static const struct eth_dev_ops bnx2x_eth_dev_ops = { 571 .dev_configure = bnx2x_dev_configure, 572 .dev_start = bnx2x_dev_start, 573 .dev_stop = bnx2x_dev_stop, 574 .dev_close = bnx2x_dev_close, 575 .promiscuous_enable = bnx2x_promisc_enable, 576 .promiscuous_disable = bnx2x_promisc_disable, 577 .allmulticast_enable = bnx2x_dev_allmulticast_enable, 578 .allmulticast_disable = bnx2x_dev_allmulticast_disable, 579 .link_update = bnx2x_dev_link_update, 580 .stats_get = bnx2x_dev_stats_get, 581 .xstats_get = bnx2x_dev_xstats_get, 582 .xstats_get_names = bnx2x_get_xstats_names, 583 .dev_infos_get = bnx2x_dev_infos_get, 584 .rx_queue_setup = bnx2x_dev_rx_queue_setup, 585 .rx_queue_release = bnx2x_dev_rx_queue_release, 586 .tx_queue_setup = bnx2x_dev_tx_queue_setup, 587 .tx_queue_release = bnx2x_dev_tx_queue_release, 588 .mac_addr_add = bnx2x_mac_addr_add, 589 .mac_addr_remove = bnx2x_mac_addr_remove, 590 }; 591 592 /* 593 * dev_ops for virtual function 594 */ 595 static const struct eth_dev_ops bnx2xvf_eth_dev_ops = { 596 .dev_configure = bnx2x_dev_configure, 597 .dev_start = bnx2x_dev_start, 598 .dev_stop = bnx2x_dev_stop, 599 .dev_close = bnx2x_dev_close, 600 .promiscuous_enable = bnx2x_promisc_enable, 601 .promiscuous_disable = bnx2x_promisc_disable, 602 .allmulticast_enable = bnx2x_dev_allmulticast_enable, 603 .allmulticast_disable = bnx2x_dev_allmulticast_disable, 604 .set_mc_addr_list = bnx2x_dev_set_mc_addr_list, 605 .link_update = bnx2xvf_dev_link_update, 606 .stats_get = bnx2x_dev_stats_get, 607 .xstats_get = bnx2x_dev_xstats_get, 608 .xstats_get_names = bnx2x_get_xstats_names, 609 .dev_infos_get = bnx2x_dev_infos_get, 610 .rx_queue_setup = bnx2x_dev_rx_queue_setup, 611 .rx_queue_release = bnx2x_dev_rx_queue_release, 612 .tx_queue_setup = bnx2x_dev_tx_queue_setup, 613 .tx_queue_release = bnx2x_dev_tx_queue_release, 614 .mac_addr_add = bnx2x_mac_addr_add, 615 .mac_addr_remove = bnx2x_mac_addr_remove, 616 }; 617 618 619 static int 620 bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf) 621 { 622 int ret = 0; 623 struct rte_pci_device *pci_dev; 624 struct rte_pci_addr pci_addr; 625 struct bnx2x_softc *sc; 626 static bool adapter_info = true; 627 628 /* Extract key data structures */ 629 sc = eth_dev->data->dev_private; 630 pci_dev = RTE_DEV_TO_PCI(eth_dev->device); 631 pci_addr = pci_dev->addr; 632 633 snprintf(sc->devinfo.name, NAME_SIZE, PCI_SHORT_PRI_FMT ":dpdk-port-%u", 634 pci_addr.bus, pci_addr.devid, pci_addr.function, 635 eth_dev->data->port_id); 636 637 PMD_INIT_FUNC_TRACE(sc); 638 639 eth_dev->dev_ops = is_vf ? &bnx2xvf_eth_dev_ops : &bnx2x_eth_dev_ops; 640 641 if (rte_eal_process_type() != RTE_PROC_PRIMARY) { 642 PMD_DRV_LOG(ERR, sc, "Skipping device init from secondary process"); 643 return 0; 644 } 645 646 rte_eth_copy_pci_info(eth_dev, pci_dev); 647 648 sc->pcie_bus = pci_dev->addr.bus; 649 sc->pcie_device = pci_dev->addr.devid; 650 651 sc->devinfo.vendor_id = pci_dev->id.vendor_id; 652 sc->devinfo.device_id = pci_dev->id.device_id; 653 sc->devinfo.subvendor_id = pci_dev->id.subsystem_vendor_id; 654 sc->devinfo.subdevice_id = pci_dev->id.subsystem_device_id; 655 656 if (is_vf) 657 sc->flags = BNX2X_IS_VF_FLAG; 658 659 sc->pcie_func = pci_dev->addr.function; 660 sc->bar[BAR0].base_addr = (void *)pci_dev->mem_resource[0].addr; 661 if (is_vf) 662 sc->bar[BAR1].base_addr = (void *) 663 ((uintptr_t)pci_dev->mem_resource[0].addr + PXP_VF_ADDR_DB_START); 664 else 665 sc->bar[BAR1].base_addr = pci_dev->mem_resource[2].addr; 666 667 assert(sc->bar[BAR0].base_addr); 668 assert(sc->bar[BAR1].base_addr); 669 670 bnx2x_load_firmware(sc); 671 assert(sc->firmware); 672 673 if (eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) 674 sc->udp_rss = 1; 675 676 sc->rx_budget = BNX2X_RX_BUDGET; 677 sc->hc_rx_ticks = BNX2X_RX_TICKS; 678 sc->hc_tx_ticks = BNX2X_TX_TICKS; 679 680 sc->interrupt_mode = INTR_MODE_SINGLE_MSIX; 681 sc->rx_mode = BNX2X_RX_MODE_NORMAL; 682 683 sc->pci_dev = pci_dev; 684 ret = bnx2x_attach(sc); 685 if (ret) { 686 PMD_DRV_LOG(ERR, sc, "bnx2x_attach failed (%d)", ret); 687 return ret; 688 } 689 690 /* Print important adapter info for the user. */ 691 if (adapter_info) { 692 bnx2x_print_adapter_info(sc); 693 adapter_info = false; 694 } 695 696 /* schedule periodic poll for slowpath link events */ 697 if (IS_PF(sc)) { 698 PMD_DRV_LOG(DEBUG, sc, "Scheduling periodic poll for slowpath link events"); 699 ret = rte_eal_alarm_set(BNX2X_SP_TIMER_PERIOD, 700 bnx2x_periodic_start, (void *)eth_dev); 701 if (ret) { 702 PMD_DRV_LOG(ERR, sc, "Unable to start periodic" 703 " timer rc %d", ret); 704 return -EINVAL; 705 } 706 } 707 708 eth_dev->data->mac_addrs = 709 (struct rte_ether_addr *)sc->link_params.mac_addr; 710 711 if (IS_VF(sc)) { 712 rte_spinlock_init(&sc->vf2pf_lock); 713 714 ret = bnx2x_dma_alloc(sc, sizeof(struct bnx2x_vf_mbx_msg), 715 &sc->vf2pf_mbox_mapping, "vf2pf_mbox", 716 RTE_CACHE_LINE_SIZE); 717 if (ret) 718 goto out; 719 720 sc->vf2pf_mbox = (struct bnx2x_vf_mbx_msg *) 721 sc->vf2pf_mbox_mapping.vaddr; 722 723 ret = bnx2x_dma_alloc(sc, sizeof(struct bnx2x_vf_bulletin), 724 &sc->pf2vf_bulletin_mapping, "vf2pf_bull", 725 RTE_CACHE_LINE_SIZE); 726 if (ret) 727 goto out; 728 729 sc->pf2vf_bulletin = (struct bnx2x_vf_bulletin *) 730 sc->pf2vf_bulletin_mapping.vaddr; 731 732 ret = bnx2x_vf_get_resources(sc, sc->max_tx_queues, 733 sc->max_rx_queues); 734 if (ret) 735 goto out; 736 } 737 738 return 0; 739 740 out: 741 if (IS_PF(sc)) 742 bnx2x_periodic_stop(eth_dev); 743 744 return ret; 745 } 746 747 static int 748 eth_bnx2x_dev_init(struct rte_eth_dev *eth_dev) 749 { 750 struct bnx2x_softc *sc = eth_dev->data->dev_private; 751 PMD_INIT_FUNC_TRACE(sc); 752 return bnx2x_common_dev_init(eth_dev, 0); 753 } 754 755 static int 756 eth_bnx2xvf_dev_init(struct rte_eth_dev *eth_dev) 757 { 758 struct bnx2x_softc *sc = eth_dev->data->dev_private; 759 PMD_INIT_FUNC_TRACE(sc); 760 return bnx2x_common_dev_init(eth_dev, 1); 761 } 762 763 static int eth_bnx2x_dev_uninit(struct rte_eth_dev *eth_dev) 764 { 765 struct bnx2x_softc *sc = eth_dev->data->dev_private; 766 PMD_INIT_FUNC_TRACE(sc); 767 bnx2x_dev_close(eth_dev); 768 return 0; 769 } 770 771 static struct rte_pci_driver rte_bnx2x_pmd; 772 static struct rte_pci_driver rte_bnx2xvf_pmd; 773 774 static int eth_bnx2x_pci_probe(struct rte_pci_driver *pci_drv, 775 struct rte_pci_device *pci_dev) 776 { 777 if (pci_drv == &rte_bnx2x_pmd) 778 return rte_eth_dev_pci_generic_probe(pci_dev, 779 sizeof(struct bnx2x_softc), eth_bnx2x_dev_init); 780 else if (pci_drv == &rte_bnx2xvf_pmd) 781 return rte_eth_dev_pci_generic_probe(pci_dev, 782 sizeof(struct bnx2x_softc), eth_bnx2xvf_dev_init); 783 else 784 return -EINVAL; 785 } 786 787 static int eth_bnx2x_pci_remove(struct rte_pci_device *pci_dev) 788 { 789 return rte_eth_dev_pci_generic_remove(pci_dev, eth_bnx2x_dev_uninit); 790 } 791 792 static struct rte_pci_driver rte_bnx2x_pmd = { 793 .id_table = pci_id_bnx2x_map, 794 .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC, 795 .probe = eth_bnx2x_pci_probe, 796 .remove = eth_bnx2x_pci_remove, 797 }; 798 799 /* 800 * virtual function driver struct 801 */ 802 static struct rte_pci_driver rte_bnx2xvf_pmd = { 803 .id_table = pci_id_bnx2xvf_map, 804 .drv_flags = RTE_PCI_DRV_NEED_MAPPING, 805 .probe = eth_bnx2x_pci_probe, 806 .remove = eth_bnx2x_pci_remove, 807 }; 808 809 RTE_PMD_REGISTER_PCI(net_bnx2x, rte_bnx2x_pmd); 810 RTE_PMD_REGISTER_PCI_TABLE(net_bnx2x, pci_id_bnx2x_map); 811 RTE_PMD_REGISTER_KMOD_DEP(net_bnx2x, "* igb_uio | uio_pci_generic | vfio-pci"); 812 RTE_PMD_REGISTER_PCI(net_bnx2xvf, rte_bnx2xvf_pmd); 813 RTE_PMD_REGISTER_PCI_TABLE(net_bnx2xvf, pci_id_bnx2xvf_map); 814 RTE_PMD_REGISTER_KMOD_DEP(net_bnx2xvf, "* igb_uio | vfio-pci"); 815 RTE_LOG_REGISTER(bnx2x_logtype_init, pmd.net.bnx2x.init, NOTICE); 816 RTE_LOG_REGISTER(bnx2x_logtype_driver, pmd.net.bnx2x.driver, NOTICE); 817