1 /****************************************************************************** 2 3 Copyright (c) 2001-2017, Intel Corporation 4 All rights reserved. 5 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions are met: 8 9 1. Redistributions of source code must retain the above copyright notice, 10 this list of conditions and the following disclaimer. 11 12 2. Redistributions in binary form must reproduce the above copyright 13 notice, this list of conditions and the following disclaimer in the 14 documentation and/or other materials provided with the distribution. 15 16 3. Neither the name of the Intel Corporation nor the names of its 17 contributors may be used to endorse or promote products derived from 18 this software without specific prior written permission. 19 20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 POSSIBILITY OF SUCH DAMAGE. 31 32 ******************************************************************************/ 33 /*$FreeBSD$*/ 34 35 36 #include "opt_inet.h" 37 #include "opt_inet6.h" 38 39 #include "ixgbe.h" 40 #include "ifdi_if.h" 41 42 #include <net/netmap.h> 43 #include <dev/netmap/netmap_kern.h> 44 45 /************************************************************************ 46 * Driver version 47 ************************************************************************/ 48 char ixv_driver_version[] = "2.0.1-k"; 49 50 /************************************************************************ 51 * PCI Device ID Table 52 * 53 * Used by probe to select devices to load on 54 * Last field stores an index into ixv_strings 55 * Last entry must be all 0s 56 * 57 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 58 ************************************************************************/ 59 static pci_vendor_info_t ixv_vendor_info_array[] = 60 { 61 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"), 62 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"), 63 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"), 64 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"), 65 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"), 66 /* required last entry */ 67 PVID_END 68 }; 69 70 /************************************************************************ 71 * Function prototypes 72 ************************************************************************/ 73 static void *ixv_register(device_t dev); 74 static int ixv_if_attach_pre(if_ctx_t ctx); 75 static int ixv_if_attach_post(if_ctx_t ctx); 76 static int ixv_if_detach(if_ctx_t ctx); 77 78 static int ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid); 79 static int ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets); 80 static int ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets); 81 static void ixv_if_queues_free(if_ctx_t ctx); 82 static void ixv_identify_hardware(if_ctx_t ctx); 83 static void ixv_init_device_features(struct adapter *); 84 static int ixv_allocate_pci_resources(if_ctx_t ctx); 85 static void ixv_free_pci_resources(if_ctx_t ctx); 86 static int ixv_setup_interface(if_ctx_t ctx); 87 static void ixv_if_media_status(if_ctx_t , struct ifmediareq *); 88 static int ixv_if_media_change(if_ctx_t ctx); 89 static void ixv_if_update_admin_status(if_ctx_t ctx); 90 static int ixv_if_msix_intr_assign(if_ctx_t ctx, int msix); 91 92 static int ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu); 93 static void ixv_if_init(if_ctx_t ctx); 94 static void ixv_if_local_timer(if_ctx_t ctx, uint16_t qid); 95 static void ixv_if_stop(if_ctx_t ctx); 96 static int ixv_negotiate_api(struct adapter *); 97 98 static void ixv_initialize_transmit_units(if_ctx_t ctx); 99 static void ixv_initialize_receive_units(if_ctx_t ctx); 100 static void ixv_initialize_rss_mapping(struct adapter *); 101 102 static void ixv_setup_vlan_support(if_ctx_t ctx); 103 static void ixv_configure_ivars(struct adapter *); 104 static void ixv_if_enable_intr(if_ctx_t ctx); 105 static void ixv_if_disable_intr(if_ctx_t ctx); 106 static void ixv_if_multi_set(if_ctx_t ctx); 107 108 static void ixv_if_register_vlan(if_ctx_t, u16); 109 static void ixv_if_unregister_vlan(if_ctx_t, u16); 110 111 static uint64_t ixv_if_get_counter(if_ctx_t, ift_counter); 112 113 static void ixv_save_stats(struct adapter *); 114 static void ixv_init_stats(struct adapter *); 115 static void ixv_update_stats(struct adapter *); 116 static void ixv_add_stats_sysctls(struct adapter *adapter); 117 118 static int ixv_sysctl_debug(SYSCTL_HANDLER_ARGS); 119 static void ixv_set_ivar(struct adapter *, u8, u8, s8); 120 121 static u8 *ixv_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *); 122 123 /* The MSI-X Interrupt handlers */ 124 static int ixv_msix_que(void *); 125 static int ixv_msix_mbx(void *); 126 127 /************************************************************************ 128 * FreeBSD Device Interface Entry Points 129 ************************************************************************/ 130 static device_method_t ixv_methods[] = { 131 /* Device interface */ 132 DEVMETHOD(device_register, ixv_register), 133 DEVMETHOD(device_probe, iflib_device_probe), 134 DEVMETHOD(device_attach, iflib_device_attach), 135 DEVMETHOD(device_detach, iflib_device_detach), 136 DEVMETHOD(device_shutdown, iflib_device_shutdown), 137 DEVMETHOD_END 138 }; 139 140 static driver_t ixv_driver = { 141 "ixv", ixv_methods, sizeof(struct adapter), 142 }; 143 144 devclass_t ixv_devclass; 145 DRIVER_MODULE(ixv, pci, ixv_driver, ixv_devclass, 0, 0); 146 IFLIB_PNP_INFO(pci, ixv_driver, ixv_vendor_info_array); 147 MODULE_DEPEND(ixv, iflib, 1, 1, 1); 148 MODULE_DEPEND(ixv, pci, 1, 1, 1); 149 MODULE_DEPEND(ixv, ether, 1, 1, 1); 150 151 static device_method_t ixv_if_methods[] = { 152 DEVMETHOD(ifdi_attach_pre, ixv_if_attach_pre), 153 DEVMETHOD(ifdi_attach_post, ixv_if_attach_post), 154 DEVMETHOD(ifdi_detach, ixv_if_detach), 155 DEVMETHOD(ifdi_init, ixv_if_init), 156 DEVMETHOD(ifdi_stop, ixv_if_stop), 157 DEVMETHOD(ifdi_msix_intr_assign, ixv_if_msix_intr_assign), 158 DEVMETHOD(ifdi_intr_enable, ixv_if_enable_intr), 159 DEVMETHOD(ifdi_intr_disable, ixv_if_disable_intr), 160 DEVMETHOD(ifdi_tx_queue_intr_enable, ixv_if_rx_queue_intr_enable), 161 DEVMETHOD(ifdi_rx_queue_intr_enable, ixv_if_rx_queue_intr_enable), 162 DEVMETHOD(ifdi_tx_queues_alloc, ixv_if_tx_queues_alloc), 163 DEVMETHOD(ifdi_rx_queues_alloc, ixv_if_rx_queues_alloc), 164 DEVMETHOD(ifdi_queues_free, ixv_if_queues_free), 165 DEVMETHOD(ifdi_update_admin_status, ixv_if_update_admin_status), 166 DEVMETHOD(ifdi_multi_set, ixv_if_multi_set), 167 DEVMETHOD(ifdi_mtu_set, ixv_if_mtu_set), 168 DEVMETHOD(ifdi_media_status, ixv_if_media_status), 169 DEVMETHOD(ifdi_media_change, ixv_if_media_change), 170 DEVMETHOD(ifdi_timer, ixv_if_local_timer), 171 DEVMETHOD(ifdi_vlan_register, ixv_if_register_vlan), 172 DEVMETHOD(ifdi_vlan_unregister, ixv_if_unregister_vlan), 173 DEVMETHOD(ifdi_get_counter, ixv_if_get_counter), 174 DEVMETHOD_END 175 }; 176 177 static driver_t ixv_if_driver = { 178 "ixv_if", ixv_if_methods, sizeof(struct adapter) 179 }; 180 181 /* 182 * TUNEABLE PARAMETERS: 183 */ 184 185 /* Flow control setting, default to full */ 186 static int ixv_flow_control = ixgbe_fc_full; 187 TUNABLE_INT("hw.ixv.flow_control", &ixv_flow_control); 188 189 /* 190 * Header split: this causes the hardware to DMA 191 * the header into a separate mbuf from the payload, 192 * it can be a performance win in some workloads, but 193 * in others it actually hurts, its off by default. 194 */ 195 static int ixv_header_split = FALSE; 196 TUNABLE_INT("hw.ixv.hdr_split", &ixv_header_split); 197 198 /* 199 * Shadow VFTA table, this is needed because 200 * the real filter table gets cleared during 201 * a soft reset and we need to repopulate it. 202 */ 203 static u32 ixv_shadow_vfta[IXGBE_VFTA_SIZE]; 204 extern struct if_txrx ixgbe_txrx; 205 206 static struct if_shared_ctx ixv_sctx_init = { 207 .isc_magic = IFLIB_MAGIC, 208 .isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */ 209 .isc_tx_maxsize = IXGBE_TSO_SIZE + sizeof(struct ether_vlan_header), 210 .isc_tx_maxsegsize = PAGE_SIZE, 211 .isc_tso_maxsize = IXGBE_TSO_SIZE + sizeof(struct ether_vlan_header), 212 .isc_tso_maxsegsize = PAGE_SIZE, 213 .isc_rx_maxsize = MJUM16BYTES, 214 .isc_rx_nsegments = 1, 215 .isc_rx_maxsegsize = MJUM16BYTES, 216 .isc_nfl = 1, 217 .isc_ntxqs = 1, 218 .isc_nrxqs = 1, 219 .isc_admin_intrcnt = 1, 220 .isc_vendor_info = ixv_vendor_info_array, 221 .isc_driver_version = ixv_driver_version, 222 .isc_driver = &ixv_if_driver, 223 .isc_flags = IFLIB_TSO_INIT_IP, 224 225 .isc_nrxd_min = {MIN_RXD}, 226 .isc_ntxd_min = {MIN_TXD}, 227 .isc_nrxd_max = {MAX_RXD}, 228 .isc_ntxd_max = {MAX_TXD}, 229 .isc_nrxd_default = {DEFAULT_RXD}, 230 .isc_ntxd_default = {DEFAULT_TXD}, 231 }; 232 233 if_shared_ctx_t ixv_sctx = &ixv_sctx_init; 234 235 static void * 236 ixv_register(device_t dev) 237 { 238 return (ixv_sctx); 239 } 240 241 /************************************************************************ 242 * ixv_if_tx_queues_alloc 243 ************************************************************************/ 244 static int 245 ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, 246 int ntxqs, int ntxqsets) 247 { 248 struct adapter *adapter = iflib_get_softc(ctx); 249 if_softc_ctx_t scctx = adapter->shared; 250 struct ix_tx_queue *que; 251 int i, j, error; 252 253 MPASS(adapter->num_tx_queues == ntxqsets); 254 MPASS(ntxqs == 1); 255 256 /* Allocate queue structure memory */ 257 adapter->tx_queues = 258 (struct ix_tx_queue *)malloc(sizeof(struct ix_tx_queue) * ntxqsets, 259 M_DEVBUF, M_NOWAIT | M_ZERO); 260 if (!adapter->tx_queues) { 261 device_printf(iflib_get_dev(ctx), 262 "Unable to allocate TX ring memory\n"); 263 return (ENOMEM); 264 } 265 266 for (i = 0, que = adapter->tx_queues; i < ntxqsets; i++, que++) { 267 struct tx_ring *txr = &que->txr; 268 269 txr->me = i; 270 txr->adapter = que->adapter = adapter; 271 adapter->active_queues |= (u64)1 << txr->me; 272 273 /* Allocate report status array */ 274 if (!(txr->tx_rsq = (qidx_t *)malloc(sizeof(qidx_t) * scctx->isc_ntxd[0], M_DEVBUF, M_NOWAIT | M_ZERO))) { 275 error = ENOMEM; 276 goto fail; 277 } 278 for (j = 0; j < scctx->isc_ntxd[0]; j++) 279 txr->tx_rsq[j] = QIDX_INVALID; 280 /* get the virtual and physical address of the hardware queues */ 281 txr->tail = IXGBE_VFTDT(txr->me); 282 txr->tx_base = (union ixgbe_adv_tx_desc *)vaddrs[i*ntxqs]; 283 txr->tx_paddr = paddrs[i*ntxqs]; 284 285 txr->bytes = 0; 286 txr->total_packets = 0; 287 288 } 289 290 device_printf(iflib_get_dev(ctx), "allocated for %d queues\n", 291 adapter->num_tx_queues); 292 293 return (0); 294 295 fail: 296 ixv_if_queues_free(ctx); 297 298 return (error); 299 } /* ixv_if_tx_queues_alloc */ 300 301 /************************************************************************ 302 * ixv_if_rx_queues_alloc 303 ************************************************************************/ 304 static int 305 ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, 306 int nrxqs, int nrxqsets) 307 { 308 struct adapter *adapter = iflib_get_softc(ctx); 309 struct ix_rx_queue *que; 310 int i, error; 311 312 MPASS(adapter->num_rx_queues == nrxqsets); 313 MPASS(nrxqs == 1); 314 315 /* Allocate queue structure memory */ 316 adapter->rx_queues = 317 (struct ix_rx_queue *)malloc(sizeof(struct ix_rx_queue) * nrxqsets, 318 M_DEVBUF, M_NOWAIT | M_ZERO); 319 if (!adapter->rx_queues) { 320 device_printf(iflib_get_dev(ctx), 321 "Unable to allocate TX ring memory\n"); 322 error = ENOMEM; 323 goto fail; 324 } 325 326 for (i = 0, que = adapter->rx_queues; i < nrxqsets; i++, que++) { 327 struct rx_ring *rxr = &que->rxr; 328 rxr->me = i; 329 rxr->adapter = que->adapter = adapter; 330 331 332 /* get the virtual and physical address of the hw queues */ 333 rxr->tail = IXGBE_VFRDT(rxr->me); 334 rxr->rx_base = (union ixgbe_adv_rx_desc *)vaddrs[i]; 335 rxr->rx_paddr = paddrs[i*nrxqs]; 336 rxr->bytes = 0; 337 rxr->que = que; 338 } 339 340 device_printf(iflib_get_dev(ctx), "allocated for %d rx queues\n", 341 adapter->num_rx_queues); 342 343 return (0); 344 345 fail: 346 ixv_if_queues_free(ctx); 347 348 return (error); 349 } /* ixv_if_rx_queues_alloc */ 350 351 /************************************************************************ 352 * ixv_if_queues_free 353 ************************************************************************/ 354 static void 355 ixv_if_queues_free(if_ctx_t ctx) 356 { 357 struct adapter *adapter = iflib_get_softc(ctx); 358 struct ix_tx_queue *que = adapter->tx_queues; 359 int i; 360 361 if (que == NULL) 362 goto free; 363 364 for (i = 0; i < adapter->num_tx_queues; i++, que++) { 365 struct tx_ring *txr = &que->txr; 366 if (txr->tx_rsq == NULL) 367 break; 368 369 free(txr->tx_rsq, M_DEVBUF); 370 txr->tx_rsq = NULL; 371 } 372 if (adapter->tx_queues != NULL) 373 free(adapter->tx_queues, M_DEVBUF); 374 free: 375 if (adapter->rx_queues != NULL) 376 free(adapter->rx_queues, M_DEVBUF); 377 adapter->tx_queues = NULL; 378 adapter->rx_queues = NULL; 379 } /* ixv_if_queues_free */ 380 381 /************************************************************************ 382 * ixv_if_attach_pre - Device initialization routine 383 * 384 * Called when the driver is being loaded. 385 * Identifies the type of hardware, allocates all resources 386 * and initializes the hardware. 387 * 388 * return 0 on success, positive on failure 389 ************************************************************************/ 390 static int 391 ixv_if_attach_pre(if_ctx_t ctx) 392 { 393 struct adapter *adapter; 394 device_t dev; 395 if_softc_ctx_t scctx; 396 struct ixgbe_hw *hw; 397 int error = 0; 398 399 INIT_DEBUGOUT("ixv_attach: begin"); 400 401 /* Allocate, clear, and link in our adapter structure */ 402 dev = iflib_get_dev(ctx); 403 adapter = iflib_get_softc(ctx); 404 adapter->dev = dev; 405 adapter->ctx = ctx; 406 adapter->hw.back = adapter; 407 scctx = adapter->shared = iflib_get_softc_ctx(ctx); 408 adapter->media = iflib_get_media(ctx); 409 hw = &adapter->hw; 410 411 /* Do base PCI setup - map BAR0 */ 412 if (ixv_allocate_pci_resources(ctx)) { 413 device_printf(dev, "ixv_allocate_pci_resources() failed!\n"); 414 error = ENXIO; 415 goto err_out; 416 } 417 418 /* SYSCTL APIs */ 419 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 420 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "debug", 421 CTLTYPE_INT | CTLFLAG_RW, adapter, 0, ixv_sysctl_debug, "I", 422 "Debug Info"); 423 424 /* Determine hardware revision */ 425 ixv_identify_hardware(ctx); 426 ixv_init_device_features(adapter); 427 428 /* Initialize the shared code */ 429 error = ixgbe_init_ops_vf(hw); 430 if (error) { 431 device_printf(dev, "ixgbe_init_ops_vf() failed!\n"); 432 error = EIO; 433 goto err_out; 434 } 435 436 /* Setup the mailbox */ 437 ixgbe_init_mbx_params_vf(hw); 438 439 error = hw->mac.ops.reset_hw(hw); 440 if (error == IXGBE_ERR_RESET_FAILED) 441 device_printf(dev, "...reset_hw() failure: Reset Failed!\n"); 442 else if (error) 443 device_printf(dev, "...reset_hw() failed with error %d\n", 444 error); 445 if (error) { 446 error = EIO; 447 goto err_out; 448 } 449 450 error = hw->mac.ops.init_hw(hw); 451 if (error) { 452 device_printf(dev, "...init_hw() failed with error %d\n", 453 error); 454 error = EIO; 455 goto err_out; 456 } 457 458 /* Negotiate mailbox API version */ 459 error = ixv_negotiate_api(adapter); 460 if (error) { 461 device_printf(dev, 462 "Mailbox API negotiation failed during attach!\n"); 463 goto err_out; 464 } 465 466 /* If no mac address was assigned, make a random one */ 467 if (!ixv_check_ether_addr(hw->mac.addr)) { 468 u8 addr[ETHER_ADDR_LEN]; 469 arc4rand(&addr, sizeof(addr), 0); 470 addr[0] &= 0xFE; 471 addr[0] |= 0x02; 472 bcopy(addr, hw->mac.addr, sizeof(addr)); 473 bcopy(addr, hw->mac.perm_addr, sizeof(addr)); 474 } 475 476 /* Most of the iflib initialization... */ 477 478 iflib_set_mac(ctx, hw->mac.addr); 479 switch (adapter->hw.mac.type) { 480 case ixgbe_mac_X550_vf: 481 case ixgbe_mac_X550EM_x_vf: 482 case ixgbe_mac_X550EM_a_vf: 483 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 2; 484 break; 485 default: 486 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 1; 487 } 488 scctx->isc_txqsizes[0] = 489 roundup2(scctx->isc_ntxd[0] * sizeof(union ixgbe_adv_tx_desc) + 490 sizeof(u32), DBA_ALIGN); 491 scctx->isc_rxqsizes[0] = 492 roundup2(scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc), 493 DBA_ALIGN); 494 /* XXX */ 495 scctx->isc_tx_csum_flags = CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_TSO | 496 CSUM_IP6_TCP | CSUM_IP6_UDP | CSUM_IP6_TSO; 497 scctx->isc_tx_nsegments = IXGBE_82599_SCATTER; 498 scctx->isc_msix_bar = PCIR_BAR(MSIX_82598_BAR); 499 scctx->isc_tx_tso_segments_max = scctx->isc_tx_nsegments; 500 scctx->isc_tx_tso_size_max = IXGBE_TSO_SIZE; 501 scctx->isc_tx_tso_segsize_max = PAGE_SIZE; 502 503 scctx->isc_txrx = &ixgbe_txrx; 504 505 /* 506 * Tell the upper layer(s) we support everything the PF 507 * driver does except... 508 * Wake-on-LAN 509 */ 510 scctx->isc_capabilities = IXGBE_CAPS; 511 scctx->isc_capabilities ^= IFCAP_WOL; 512 scctx->isc_capenable = scctx->isc_capabilities; 513 514 INIT_DEBUGOUT("ixv_if_attach_pre: end"); 515 516 return (0); 517 518 err_out: 519 ixv_free_pci_resources(ctx); 520 521 return (error); 522 } /* ixv_if_attach_pre */ 523 524 static int 525 ixv_if_attach_post(if_ctx_t ctx) 526 { 527 struct adapter *adapter = iflib_get_softc(ctx); 528 device_t dev = iflib_get_dev(ctx); 529 int error = 0; 530 531 /* Setup OS specific network interface */ 532 error = ixv_setup_interface(ctx); 533 if (error) { 534 device_printf(dev, "Interface setup failed: %d\n", error); 535 goto end; 536 } 537 538 /* Do the stats setup */ 539 ixv_save_stats(adapter); 540 ixv_init_stats(adapter); 541 ixv_add_stats_sysctls(adapter); 542 543 end: 544 return error; 545 } /* ixv_if_attach_post */ 546 547 /************************************************************************ 548 * ixv_detach - Device removal routine 549 * 550 * Called when the driver is being removed. 551 * Stops the adapter and deallocates all the resources 552 * that were allocated for driver operation. 553 * 554 * return 0 on success, positive on failure 555 ************************************************************************/ 556 static int 557 ixv_if_detach(if_ctx_t ctx) 558 { 559 INIT_DEBUGOUT("ixv_detach: begin"); 560 561 ixv_free_pci_resources(ctx); 562 563 return (0); 564 } /* ixv_if_detach */ 565 566 /************************************************************************ 567 * ixv_if_mtu_set 568 ************************************************************************/ 569 static int 570 ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu) 571 { 572 struct adapter *adapter = iflib_get_softc(ctx); 573 struct ifnet *ifp = iflib_get_ifp(ctx); 574 int error = 0; 575 576 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 577 if (mtu > IXGBE_MAX_FRAME_SIZE - IXGBE_MTU_HDR) { 578 error = EINVAL; 579 } else { 580 ifp->if_mtu = mtu; 581 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR; 582 } 583 584 return error; 585 } /* ixv_if_mtu_set */ 586 587 /************************************************************************ 588 * ixv_if_init - Init entry point 589 * 590 * Used in two ways: It is used by the stack as an init entry 591 * point in network interface structure. It is also used 592 * by the driver as a hw/sw initialization routine to get 593 * to a consistent state. 594 * 595 * return 0 on success, positive on failure 596 ************************************************************************/ 597 static void 598 ixv_if_init(if_ctx_t ctx) 599 { 600 struct adapter *adapter = iflib_get_softc(ctx); 601 struct ifnet *ifp = iflib_get_ifp(ctx); 602 device_t dev = iflib_get_dev(ctx); 603 struct ixgbe_hw *hw = &adapter->hw; 604 int error = 0; 605 606 INIT_DEBUGOUT("ixv_if_init: begin"); 607 hw->adapter_stopped = FALSE; 608 hw->mac.ops.stop_adapter(hw); 609 610 /* reprogram the RAR[0] in case user changed it. */ 611 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 612 613 /* Get the latest mac address, User can use a LAA */ 614 bcopy(IF_LLADDR(ifp), hw->mac.addr, IXGBE_ETH_LENGTH_OF_ADDRESS); 615 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1); 616 617 /* Reset VF and renegotiate mailbox API version */ 618 hw->mac.ops.reset_hw(hw); 619 hw->mac.ops.start_hw(hw); 620 error = ixv_negotiate_api(adapter); 621 if (error) { 622 device_printf(dev, 623 "Mailbox API negotiation failed in if_init!\n"); 624 return; 625 } 626 627 ixv_initialize_transmit_units(ctx); 628 629 /* Setup Multicast table */ 630 ixv_if_multi_set(ctx); 631 632 /* 633 * Determine the correct mbuf pool 634 * for doing jumbo/headersplit 635 */ 636 if (ifp->if_mtu > ETHERMTU) 637 adapter->rx_mbuf_sz = MJUMPAGESIZE; 638 else 639 adapter->rx_mbuf_sz = MCLBYTES; 640 641 /* Configure RX settings */ 642 ixv_initialize_receive_units(ctx); 643 644 /* Set up VLAN offload and filter */ 645 ixv_setup_vlan_support(ctx); 646 647 /* Set up MSI-X routing */ 648 ixv_configure_ivars(adapter); 649 650 /* Set up auto-mask */ 651 IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, IXGBE_EICS_RTX_QUEUE); 652 653 /* Set moderation on the Link interrupt */ 654 IXGBE_WRITE_REG(hw, IXGBE_VTEITR(adapter->vector), IXGBE_LINK_ITR); 655 656 /* Stats init */ 657 ixv_init_stats(adapter); 658 659 /* Config/Enable Link */ 660 hw->mac.ops.check_link(hw, &adapter->link_speed, &adapter->link_up, 661 FALSE); 662 663 /* And now turn on interrupts */ 664 ixv_if_enable_intr(ctx); 665 666 return; 667 } /* ixv_if_init */ 668 669 /************************************************************************ 670 * ixv_enable_queue 671 ************************************************************************/ 672 static inline void 673 ixv_enable_queue(struct adapter *adapter, u32 vector) 674 { 675 struct ixgbe_hw *hw = &adapter->hw; 676 u32 queue = 1 << vector; 677 u32 mask; 678 679 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 680 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask); 681 } /* ixv_enable_queue */ 682 683 /************************************************************************ 684 * ixv_disable_queue 685 ************************************************************************/ 686 static inline void 687 ixv_disable_queue(struct adapter *adapter, u32 vector) 688 { 689 struct ixgbe_hw *hw = &adapter->hw; 690 u64 queue = (u64)(1 << vector); 691 u32 mask; 692 693 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 694 IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask); 695 } /* ixv_disable_queue */ 696 697 698 /************************************************************************ 699 * ixv_msix_que - MSI-X Queue Interrupt Service routine 700 ************************************************************************/ 701 static int 702 ixv_msix_que(void *arg) 703 { 704 struct ix_rx_queue *que = arg; 705 struct adapter *adapter = que->adapter; 706 707 ixv_disable_queue(adapter, que->msix); 708 ++que->irqs; 709 710 return (FILTER_SCHEDULE_THREAD); 711 } /* ixv_msix_que */ 712 713 /************************************************************************ 714 * ixv_msix_mbx 715 ************************************************************************/ 716 static int 717 ixv_msix_mbx(void *arg) 718 { 719 struct adapter *adapter = arg; 720 struct ixgbe_hw *hw = &adapter->hw; 721 u32 reg; 722 723 ++adapter->link_irq; 724 725 /* First get the cause */ 726 reg = IXGBE_READ_REG(hw, IXGBE_VTEICS); 727 /* Clear interrupt with write */ 728 IXGBE_WRITE_REG(hw, IXGBE_VTEICR, reg); 729 730 /* Link status change */ 731 if (reg & IXGBE_EICR_LSC) 732 iflib_admin_intr_deferred(adapter->ctx); 733 734 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, IXGBE_EIMS_OTHER); 735 736 return (FILTER_HANDLED); 737 } /* ixv_msix_mbx */ 738 739 /************************************************************************ 740 * ixv_media_status - Media Ioctl callback 741 * 742 * Called whenever the user queries the status of 743 * the interface using ifconfig. 744 ************************************************************************/ 745 static void 746 ixv_if_media_status(if_ctx_t ctx, struct ifmediareq * ifmr) 747 { 748 struct adapter *adapter = iflib_get_softc(ctx); 749 750 INIT_DEBUGOUT("ixv_media_status: begin"); 751 752 iflib_admin_intr_deferred(ctx); 753 754 ifmr->ifm_status = IFM_AVALID; 755 ifmr->ifm_active = IFM_ETHER; 756 757 if (!adapter->link_active) 758 return; 759 760 ifmr->ifm_status |= IFM_ACTIVE; 761 762 switch (adapter->link_speed) { 763 case IXGBE_LINK_SPEED_1GB_FULL: 764 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 765 break; 766 case IXGBE_LINK_SPEED_10GB_FULL: 767 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 768 break; 769 case IXGBE_LINK_SPEED_100_FULL: 770 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 771 break; 772 case IXGBE_LINK_SPEED_10_FULL: 773 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 774 break; 775 } 776 } /* ixv_if_media_status */ 777 778 /************************************************************************ 779 * ixv_if_media_change - Media Ioctl callback 780 * 781 * Called when the user changes speed/duplex using 782 * media/mediopt option with ifconfig. 783 ************************************************************************/ 784 static int 785 ixv_if_media_change(if_ctx_t ctx) 786 { 787 struct adapter *adapter = iflib_get_softc(ctx); 788 struct ifmedia *ifm = iflib_get_media(ctx); 789 790 INIT_DEBUGOUT("ixv_media_change: begin"); 791 792 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 793 return (EINVAL); 794 795 switch (IFM_SUBTYPE(ifm->ifm_media)) { 796 case IFM_AUTO: 797 break; 798 default: 799 device_printf(adapter->dev, "Only auto media type\n"); 800 return (EINVAL); 801 } 802 803 return (0); 804 } /* ixv_if_media_change */ 805 806 807 /************************************************************************ 808 * ixv_negotiate_api 809 * 810 * Negotiate the Mailbox API with the PF; 811 * start with the most featured API first. 812 ************************************************************************/ 813 static int 814 ixv_negotiate_api(struct adapter *adapter) 815 { 816 struct ixgbe_hw *hw = &adapter->hw; 817 int mbx_api[] = { ixgbe_mbox_api_11, 818 ixgbe_mbox_api_10, 819 ixgbe_mbox_api_unknown }; 820 int i = 0; 821 822 while (mbx_api[i] != ixgbe_mbox_api_unknown) { 823 if (ixgbevf_negotiate_api_version(hw, mbx_api[i]) == 0) 824 return (0); 825 i++; 826 } 827 828 return (EINVAL); 829 } /* ixv_negotiate_api */ 830 831 832 /************************************************************************ 833 * ixv_if_multi_set - Multicast Update 834 * 835 * Called whenever multicast address list is updated. 836 ************************************************************************/ 837 static void 838 ixv_if_multi_set(if_ctx_t ctx) 839 { 840 u8 mta[MAX_NUM_MULTICAST_ADDRESSES * IXGBE_ETH_LENGTH_OF_ADDRESS]; 841 struct adapter *adapter = iflib_get_softc(ctx); 842 u8 *update_ptr; 843 struct ifmultiaddr *ifma; 844 if_t ifp = iflib_get_ifp(ctx); 845 int mcnt = 0; 846 847 IOCTL_DEBUGOUT("ixv_if_multi_set: begin"); 848 849 CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 850 if (ifma->ifma_addr->sa_family != AF_LINK) 851 continue; 852 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 853 &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS], 854 IXGBE_ETH_LENGTH_OF_ADDRESS); 855 mcnt++; 856 } 857 858 update_ptr = mta; 859 860 adapter->hw.mac.ops.update_mc_addr_list(&adapter->hw, update_ptr, mcnt, 861 ixv_mc_array_itr, TRUE); 862 } /* ixv_if_multi_set */ 863 864 /************************************************************************ 865 * ixv_mc_array_itr 866 * 867 * An iterator function needed by the multicast shared code. 868 * It feeds the shared code routine the addresses in the 869 * array of ixv_set_multi() one by one. 870 ************************************************************************/ 871 static u8 * 872 ixv_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 873 { 874 u8 *addr = *update_ptr; 875 u8 *newptr; 876 877 *vmdq = 0; 878 879 newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS; 880 *update_ptr = newptr; 881 882 return addr; 883 } /* ixv_mc_array_itr */ 884 885 /************************************************************************ 886 * ixv_if_local_timer - Timer routine 887 * 888 * Checks for link status, updates statistics, 889 * and runs the watchdog check. 890 ************************************************************************/ 891 static void 892 ixv_if_local_timer(if_ctx_t ctx, uint16_t qid) 893 { 894 if (qid != 0) 895 return; 896 897 /* Fire off the adminq task */ 898 iflib_admin_intr_deferred(ctx); 899 } /* ixv_if_local_timer */ 900 901 /************************************************************************ 902 * ixv_if_update_admin_status - Update OS on link state 903 * 904 * Note: Only updates the OS on the cached link state. 905 * The real check of the hardware only happens with 906 * a link interrupt. 907 ************************************************************************/ 908 static void 909 ixv_if_update_admin_status(if_ctx_t ctx) 910 { 911 struct adapter *adapter = iflib_get_softc(ctx); 912 device_t dev = iflib_get_dev(ctx); 913 s32 status; 914 915 adapter->hw.mac.get_link_status = TRUE; 916 917 status = ixgbe_check_link(&adapter->hw, &adapter->link_speed, 918 &adapter->link_up, FALSE); 919 920 if (status != IXGBE_SUCCESS && adapter->hw.adapter_stopped == FALSE) { 921 /* Mailbox's Clear To Send status is lost or timeout occurred. 922 * We need reinitialization. */ 923 iflib_get_ifp(ctx)->if_init(ctx); 924 } 925 926 if (adapter->link_up) { 927 if (adapter->link_active == FALSE) { 928 if (bootverbose) 929 device_printf(dev, "Link is up %d Gbps %s \n", 930 ((adapter->link_speed == 128) ? 10 : 1), 931 "Full Duplex"); 932 adapter->link_active = TRUE; 933 iflib_link_state_change(ctx, LINK_STATE_UP, 934 IF_Gbps(10)); 935 } 936 } else { /* Link down */ 937 if (adapter->link_active == TRUE) { 938 if (bootverbose) 939 device_printf(dev, "Link is Down\n"); 940 iflib_link_state_change(ctx, LINK_STATE_DOWN, 0); 941 adapter->link_active = FALSE; 942 } 943 } 944 945 /* Stats Update */ 946 ixv_update_stats(adapter); 947 } /* ixv_if_update_admin_status */ 948 949 950 /************************************************************************ 951 * ixv_if_stop - Stop the hardware 952 * 953 * Disables all traffic on the adapter by issuing a 954 * global reset on the MAC and deallocates TX/RX buffers. 955 ************************************************************************/ 956 static void 957 ixv_if_stop(if_ctx_t ctx) 958 { 959 struct adapter *adapter = iflib_get_softc(ctx); 960 struct ixgbe_hw *hw = &adapter->hw; 961 962 INIT_DEBUGOUT("ixv_stop: begin\n"); 963 964 ixv_if_disable_intr(ctx); 965 966 hw->mac.ops.reset_hw(hw); 967 adapter->hw.adapter_stopped = FALSE; 968 hw->mac.ops.stop_adapter(hw); 969 970 /* Update the stack */ 971 adapter->link_up = FALSE; 972 ixv_if_update_admin_status(ctx); 973 974 /* reprogram the RAR[0] in case user changed it. */ 975 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 976 } /* ixv_if_stop */ 977 978 979 /************************************************************************ 980 * ixv_identify_hardware - Determine hardware revision. 981 ************************************************************************/ 982 static void 983 ixv_identify_hardware(if_ctx_t ctx) 984 { 985 struct adapter *adapter = iflib_get_softc(ctx); 986 device_t dev = iflib_get_dev(ctx); 987 struct ixgbe_hw *hw = &adapter->hw; 988 989 /* Save off the information about this board */ 990 hw->vendor_id = pci_get_vendor(dev); 991 hw->device_id = pci_get_device(dev); 992 hw->revision_id = pci_get_revid(dev); 993 hw->subsystem_vendor_id = pci_get_subvendor(dev); 994 hw->subsystem_device_id = pci_get_subdevice(dev); 995 996 /* A subset of set_mac_type */ 997 switch (hw->device_id) { 998 case IXGBE_DEV_ID_82599_VF: 999 hw->mac.type = ixgbe_mac_82599_vf; 1000 break; 1001 case IXGBE_DEV_ID_X540_VF: 1002 hw->mac.type = ixgbe_mac_X540_vf; 1003 break; 1004 case IXGBE_DEV_ID_X550_VF: 1005 hw->mac.type = ixgbe_mac_X550_vf; 1006 break; 1007 case IXGBE_DEV_ID_X550EM_X_VF: 1008 hw->mac.type = ixgbe_mac_X550EM_x_vf; 1009 break; 1010 case IXGBE_DEV_ID_X550EM_A_VF: 1011 hw->mac.type = ixgbe_mac_X550EM_a_vf; 1012 break; 1013 default: 1014 device_printf(dev, "unknown mac type\n"); 1015 hw->mac.type = ixgbe_mac_unknown; 1016 break; 1017 } 1018 } /* ixv_identify_hardware */ 1019 1020 /************************************************************************ 1021 * ixv_if_msix_intr_assign - Setup MSI-X Interrupt resources and handlers 1022 ************************************************************************/ 1023 static int 1024 ixv_if_msix_intr_assign(if_ctx_t ctx, int msix) 1025 { 1026 struct adapter *adapter = iflib_get_softc(ctx); 1027 device_t dev = iflib_get_dev(ctx); 1028 struct ix_rx_queue *rx_que = adapter->rx_queues; 1029 struct ix_tx_queue *tx_que; 1030 int error, rid, vector = 0; 1031 char buf[16]; 1032 1033 for (int i = 0; i < adapter->num_rx_queues; i++, vector++, rx_que++) { 1034 rid = vector + 1; 1035 1036 snprintf(buf, sizeof(buf), "rxq%d", i); 1037 error = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid, 1038 IFLIB_INTR_RX, ixv_msix_que, rx_que, rx_que->rxr.me, buf); 1039 1040 if (error) { 1041 device_printf(iflib_get_dev(ctx), 1042 "Failed to allocate que int %d err: %d", i, error); 1043 adapter->num_rx_queues = i + 1; 1044 goto fail; 1045 } 1046 1047 rx_que->msix = vector; 1048 adapter->active_queues |= (u64)(1 << rx_que->msix); 1049 1050 } 1051 1052 for (int i = 0; i < adapter->num_tx_queues; i++) { 1053 snprintf(buf, sizeof(buf), "txq%d", i); 1054 tx_que = &adapter->tx_queues[i]; 1055 tx_que->msix = i % adapter->num_rx_queues; 1056 iflib_softirq_alloc_generic(ctx, 1057 &adapter->rx_queues[tx_que->msix].que_irq, 1058 IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf); 1059 } 1060 rid = vector + 1; 1061 error = iflib_irq_alloc_generic(ctx, &adapter->irq, rid, 1062 IFLIB_INTR_ADMIN, ixv_msix_mbx, adapter, 0, "aq"); 1063 if (error) { 1064 device_printf(iflib_get_dev(ctx), 1065 "Failed to register admin handler"); 1066 return (error); 1067 } 1068 1069 adapter->vector = vector; 1070 /* 1071 * Due to a broken design QEMU will fail to properly 1072 * enable the guest for MSIX unless the vectors in 1073 * the table are all set up, so we must rewrite the 1074 * ENABLE in the MSIX control register again at this 1075 * point to cause it to successfully initialize us. 1076 */ 1077 if (adapter->hw.mac.type == ixgbe_mac_82599_vf) { 1078 int msix_ctrl; 1079 pci_find_cap(dev, PCIY_MSIX, &rid); 1080 rid += PCIR_MSIX_CTRL; 1081 msix_ctrl = pci_read_config(dev, rid, 2); 1082 msix_ctrl |= PCIM_MSIXCTRL_MSIX_ENABLE; 1083 pci_write_config(dev, rid, msix_ctrl, 2); 1084 } 1085 1086 return (0); 1087 1088 fail: 1089 iflib_irq_free(ctx, &adapter->irq); 1090 rx_que = adapter->rx_queues; 1091 for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++) 1092 iflib_irq_free(ctx, &rx_que->que_irq); 1093 1094 return (error); 1095 } /* ixv_if_msix_intr_assign */ 1096 1097 /************************************************************************ 1098 * ixv_allocate_pci_resources 1099 ************************************************************************/ 1100 static int 1101 ixv_allocate_pci_resources(if_ctx_t ctx) 1102 { 1103 struct adapter *adapter = iflib_get_softc(ctx); 1104 device_t dev = iflib_get_dev(ctx); 1105 int rid; 1106 1107 rid = PCIR_BAR(0); 1108 adapter->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 1109 RF_ACTIVE); 1110 1111 if (!(adapter->pci_mem)) { 1112 device_printf(dev, "Unable to allocate bus resource: memory\n"); 1113 return (ENXIO); 1114 } 1115 1116 adapter->osdep.mem_bus_space_tag = rman_get_bustag(adapter->pci_mem); 1117 adapter->osdep.mem_bus_space_handle = 1118 rman_get_bushandle(adapter->pci_mem); 1119 adapter->hw.hw_addr = (u8 *)&adapter->osdep.mem_bus_space_handle; 1120 1121 return (0); 1122 } /* ixv_allocate_pci_resources */ 1123 1124 /************************************************************************ 1125 * ixv_free_pci_resources 1126 ************************************************************************/ 1127 static void 1128 ixv_free_pci_resources(if_ctx_t ctx) 1129 { 1130 struct adapter *adapter = iflib_get_softc(ctx); 1131 struct ix_rx_queue *que = adapter->rx_queues; 1132 device_t dev = iflib_get_dev(ctx); 1133 1134 /* Release all MSI-X queue resources */ 1135 if (adapter->intr_type == IFLIB_INTR_MSIX) 1136 iflib_irq_free(ctx, &adapter->irq); 1137 1138 if (que != NULL) { 1139 for (int i = 0; i < adapter->num_rx_queues; i++, que++) { 1140 iflib_irq_free(ctx, &que->que_irq); 1141 } 1142 } 1143 1144 if (adapter->pci_mem != NULL) 1145 bus_release_resource(dev, SYS_RES_MEMORY, 1146 rman_get_rid(adapter->pci_mem), adapter->pci_mem); 1147 } /* ixv_free_pci_resources */ 1148 1149 /************************************************************************ 1150 * ixv_setup_interface 1151 * 1152 * Setup networking device structure and register an interface. 1153 ************************************************************************/ 1154 static int 1155 ixv_setup_interface(if_ctx_t ctx) 1156 { 1157 struct adapter *adapter = iflib_get_softc(ctx); 1158 if_softc_ctx_t scctx = adapter->shared; 1159 struct ifnet *ifp = iflib_get_ifp(ctx); 1160 1161 INIT_DEBUGOUT("ixv_setup_interface: begin"); 1162 1163 if_setbaudrate(ifp, IF_Gbps(10)); 1164 ifp->if_snd.ifq_maxlen = scctx->isc_ntxd[0] - 2; 1165 1166 1167 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR; 1168 ifmedia_add(adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1169 ifmedia_set(adapter->media, IFM_ETHER | IFM_AUTO); 1170 1171 return 0; 1172 } /* ixv_setup_interface */ 1173 1174 /************************************************************************ 1175 * ixv_if_get_counter 1176 ************************************************************************/ 1177 static uint64_t 1178 ixv_if_get_counter(if_ctx_t ctx, ift_counter cnt) 1179 { 1180 struct adapter *adapter = iflib_get_softc(ctx); 1181 if_t ifp = iflib_get_ifp(ctx); 1182 1183 switch (cnt) { 1184 case IFCOUNTER_IPACKETS: 1185 return (adapter->ipackets); 1186 case IFCOUNTER_OPACKETS: 1187 return (adapter->opackets); 1188 case IFCOUNTER_IBYTES: 1189 return (adapter->ibytes); 1190 case IFCOUNTER_OBYTES: 1191 return (adapter->obytes); 1192 case IFCOUNTER_IMCASTS: 1193 return (adapter->imcasts); 1194 default: 1195 return (if_get_counter_default(ifp, cnt)); 1196 } 1197 } /* ixv_if_get_counter */ 1198 1199 /************************************************************************ 1200 * ixv_initialize_transmit_units - Enable transmit unit. 1201 ************************************************************************/ 1202 static void 1203 ixv_initialize_transmit_units(if_ctx_t ctx) 1204 { 1205 struct adapter *adapter = iflib_get_softc(ctx); 1206 struct ixgbe_hw *hw = &adapter->hw; 1207 if_softc_ctx_t scctx = adapter->shared; 1208 struct ix_tx_queue *que = adapter->tx_queues; 1209 int i; 1210 1211 for (i = 0; i < adapter->num_tx_queues; i++, que++) { 1212 struct tx_ring *txr = &que->txr; 1213 u64 tdba = txr->tx_paddr; 1214 u32 txctrl, txdctl; 1215 int j = txr->me; 1216 1217 /* Set WTHRESH to 8, burst writeback */ 1218 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1219 txdctl |= (8 << 16); 1220 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1221 1222 /* Set the HW Tx Head and Tail indices */ 1223 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(j), 0); 1224 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(j), 0); 1225 1226 /* Set Tx Tail register */ 1227 txr->tail = IXGBE_VFTDT(j); 1228 1229 txr->tx_rs_cidx = txr->tx_rs_pidx; 1230 /* Initialize the last processed descriptor to be the end of 1231 * the ring, rather than the start, so that we avoid an 1232 * off-by-one error when calculating how many descriptors are 1233 * done in the credits_update function. 1234 */ 1235 txr->tx_cidx_processed = scctx->isc_ntxd[0] - 1; 1236 for (int k = 0; k < scctx->isc_ntxd[0]; k++) 1237 txr->tx_rsq[k] = QIDX_INVALID; 1238 1239 /* Set Ring parameters */ 1240 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j), 1241 (tdba & 0x00000000ffffffffULL)); 1242 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32)); 1243 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j), 1244 scctx->isc_ntxd[0] * sizeof(struct ixgbe_legacy_tx_desc)); 1245 txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j)); 1246 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 1247 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl); 1248 1249 /* Now enable */ 1250 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1251 txdctl |= IXGBE_TXDCTL_ENABLE; 1252 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1253 } 1254 1255 return; 1256 } /* ixv_initialize_transmit_units */ 1257 1258 /************************************************************************ 1259 * ixv_initialize_rss_mapping 1260 ************************************************************************/ 1261 static void 1262 ixv_initialize_rss_mapping(struct adapter *adapter) 1263 { 1264 struct ixgbe_hw *hw = &adapter->hw; 1265 u32 reta = 0, mrqc, rss_key[10]; 1266 int queue_id; 1267 int i, j; 1268 u32 rss_hash_config; 1269 1270 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1271 /* Fetch the configured RSS key */ 1272 rss_getkey((uint8_t *)&rss_key); 1273 } else { 1274 /* set up random bits */ 1275 arc4rand(&rss_key, sizeof(rss_key), 0); 1276 } 1277 1278 /* Now fill out hash function seeds */ 1279 for (i = 0; i < 10; i++) 1280 IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]); 1281 1282 /* Set up the redirection table */ 1283 for (i = 0, j = 0; i < 64; i++, j++) { 1284 if (j == adapter->num_rx_queues) 1285 j = 0; 1286 1287 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1288 /* 1289 * Fetch the RSS bucket id for the given indirection 1290 * entry. Cap it at the number of configured buckets 1291 * (which is num_rx_queues.) 1292 */ 1293 queue_id = rss_get_indirection_to_bucket(i); 1294 queue_id = queue_id % adapter->num_rx_queues; 1295 } else 1296 queue_id = j; 1297 1298 /* 1299 * The low 8 bits are for hash value (n+0); 1300 * The next 8 bits are for hash value (n+1), etc. 1301 */ 1302 reta >>= 8; 1303 reta |= ((uint32_t)queue_id) << 24; 1304 if ((i & 3) == 3) { 1305 IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), reta); 1306 reta = 0; 1307 } 1308 } 1309 1310 /* Perform hash on these packet types */ 1311 if (adapter->feat_en & IXGBE_FEATURE_RSS) 1312 rss_hash_config = rss_gethashconfig(); 1313 else { 1314 /* 1315 * Disable UDP - IP fragments aren't currently being handled 1316 * and so we end up with a mix of 2-tuple and 4-tuple 1317 * traffic. 1318 */ 1319 rss_hash_config = RSS_HASHTYPE_RSS_IPV4 1320 | RSS_HASHTYPE_RSS_TCP_IPV4 1321 | RSS_HASHTYPE_RSS_IPV6 1322 | RSS_HASHTYPE_RSS_TCP_IPV6; 1323 } 1324 1325 mrqc = IXGBE_MRQC_RSSEN; 1326 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 1327 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 1328 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 1329 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 1330 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 1331 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 1332 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 1333 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 1334 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 1335 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_IPV6_EX defined, but not supported\n", 1336 __func__); 1337 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 1338 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_TCP_IPV6_EX defined, but not supported\n", 1339 __func__); 1340 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 1341 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 1342 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 1343 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 1344 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 1345 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_UDP_IPV6_EX defined, but not supported\n", 1346 __func__); 1347 IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, mrqc); 1348 } /* ixv_initialize_rss_mapping */ 1349 1350 1351 /************************************************************************ 1352 * ixv_initialize_receive_units - Setup receive registers and features. 1353 ************************************************************************/ 1354 static void 1355 ixv_initialize_receive_units(if_ctx_t ctx) 1356 { 1357 struct adapter *adapter = iflib_get_softc(ctx); 1358 if_softc_ctx_t scctx; 1359 struct ixgbe_hw *hw = &adapter->hw; 1360 struct ifnet *ifp = iflib_get_ifp(ctx); 1361 struct ix_rx_queue *que = adapter->rx_queues; 1362 u32 bufsz, psrtype; 1363 1364 if (ifp->if_mtu > ETHERMTU) 1365 bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1366 else 1367 bufsz = 2048 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1368 1369 psrtype = IXGBE_PSRTYPE_TCPHDR 1370 | IXGBE_PSRTYPE_UDPHDR 1371 | IXGBE_PSRTYPE_IPV4HDR 1372 | IXGBE_PSRTYPE_IPV6HDR 1373 | IXGBE_PSRTYPE_L2HDR; 1374 1375 if (adapter->num_rx_queues > 1) 1376 psrtype |= 1 << 29; 1377 1378 IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype); 1379 1380 /* Tell PF our max_frame size */ 1381 if (ixgbevf_rlpml_set_vf(hw, adapter->max_frame_size) != 0) { 1382 device_printf(adapter->dev, "There is a problem with the PF setup. It is likely the receive unit for this VF will not function correctly.\n"); 1383 } 1384 scctx = adapter->shared; 1385 1386 for (int i = 0; i < adapter->num_rx_queues; i++, que++) { 1387 struct rx_ring *rxr = &que->rxr; 1388 u64 rdba = rxr->rx_paddr; 1389 u32 reg, rxdctl; 1390 int j = rxr->me; 1391 1392 /* Disable the queue */ 1393 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)); 1394 rxdctl &= ~IXGBE_RXDCTL_ENABLE; 1395 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1396 for (int k = 0; k < 10; k++) { 1397 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1398 IXGBE_RXDCTL_ENABLE) 1399 msec_delay(1); 1400 else 1401 break; 1402 } 1403 wmb(); 1404 /* Setup the Base and Length of the Rx Descriptor Ring */ 1405 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j), 1406 (rdba & 0x00000000ffffffffULL)); 1407 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32)); 1408 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j), 1409 scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc)); 1410 1411 /* Reset the ring indices */ 1412 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0); 1413 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0); 1414 1415 /* Set up the SRRCTL register */ 1416 reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j)); 1417 reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 1418 reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 1419 reg |= bufsz; 1420 reg |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 1421 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg); 1422 1423 /* Capture Rx Tail index */ 1424 rxr->tail = IXGBE_VFRDT(rxr->me); 1425 1426 /* Do the queue enabling last */ 1427 rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME; 1428 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1429 for (int l = 0; l < 10; l++) { 1430 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1431 IXGBE_RXDCTL_ENABLE) 1432 break; 1433 msec_delay(1); 1434 } 1435 wmb(); 1436 1437 /* Set the Tail Pointer */ 1438 #ifdef DEV_NETMAP 1439 /* 1440 * In netmap mode, we must preserve the buffers made 1441 * available to userspace before the if_init() 1442 * (this is true by default on the TX side, because 1443 * init makes all buffers available to userspace). 1444 * 1445 * netmap_reset() and the device specific routines 1446 * (e.g. ixgbe_setup_receive_rings()) map these 1447 * buffers at the end of the NIC ring, so here we 1448 * must set the RDT (tail) register to make sure 1449 * they are not overwritten. 1450 * 1451 * In this driver the NIC ring starts at RDH = 0, 1452 * RDT points to the last slot available for reception (?), 1453 * so RDT = num_rx_desc - 1 means the whole ring is available. 1454 */ 1455 if (ifp->if_capenable & IFCAP_NETMAP) { 1456 struct netmap_adapter *na = NA(ifp); 1457 struct netmap_kring *kring = na->rx_rings[j]; 1458 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 1459 1460 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t); 1461 } else 1462 #endif /* DEV_NETMAP */ 1463 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 1464 scctx->isc_nrxd[0] - 1); 1465 } 1466 1467 ixv_initialize_rss_mapping(adapter); 1468 } /* ixv_initialize_receive_units */ 1469 1470 /************************************************************************ 1471 * ixv_setup_vlan_support 1472 ************************************************************************/ 1473 static void 1474 ixv_setup_vlan_support(if_ctx_t ctx) 1475 { 1476 struct ifnet *ifp = iflib_get_ifp(ctx); 1477 struct adapter *adapter = iflib_get_softc(ctx); 1478 struct ixgbe_hw *hw = &adapter->hw; 1479 u32 ctrl, vid, vfta, retry; 1480 1481 /* 1482 * We get here thru if_init, meaning 1483 * a soft reset, this has already cleared 1484 * the VFTA and other state, so if there 1485 * have been no vlan's registered do nothing. 1486 */ 1487 if (adapter->num_vlans == 0) 1488 return; 1489 1490 if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) { 1491 /* Enable the queues */ 1492 for (int i = 0; i < adapter->num_rx_queues; i++) { 1493 ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 1494 ctrl |= IXGBE_RXDCTL_VME; 1495 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), ctrl); 1496 /* 1497 * Let Rx path know that it needs to store VLAN tag 1498 * as part of extra mbuf info. 1499 */ 1500 adapter->rx_queues[i].rxr.vtag_strip = TRUE; 1501 } 1502 } 1503 1504 /* 1505 * If filtering VLAN tags is disabled, 1506 * there is no need to fill VLAN Filter Table Array (VFTA). 1507 */ 1508 if ((ifp->if_capenable & IFCAP_VLAN_HWFILTER) == 0) 1509 return; 1510 1511 /* 1512 * A soft reset zero's out the VFTA, so 1513 * we need to repopulate it now. 1514 */ 1515 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) { 1516 if (ixv_shadow_vfta[i] == 0) 1517 continue; 1518 vfta = ixv_shadow_vfta[i]; 1519 /* 1520 * Reconstruct the vlan id's 1521 * based on the bits set in each 1522 * of the array ints. 1523 */ 1524 for (int j = 0; j < 32; j++) { 1525 retry = 0; 1526 if ((vfta & (1 << j)) == 0) 1527 continue; 1528 vid = (i * 32) + j; 1529 /* Call the shared code mailbox routine */ 1530 while (hw->mac.ops.set_vfta(hw, vid, 0, TRUE, FALSE)) { 1531 if (++retry > 5) 1532 break; 1533 } 1534 } 1535 } 1536 } /* ixv_setup_vlan_support */ 1537 1538 /************************************************************************ 1539 * ixv_if_register_vlan 1540 * 1541 * Run via a vlan config EVENT, it enables us to use the 1542 * HW Filter table since we can get the vlan id. This just 1543 * creates the entry in the soft version of the VFTA, init 1544 * will repopulate the real table. 1545 ************************************************************************/ 1546 static void 1547 ixv_if_register_vlan(if_ctx_t ctx, u16 vtag) 1548 { 1549 struct adapter *adapter = iflib_get_softc(ctx); 1550 u16 index, bit; 1551 1552 index = (vtag >> 5) & 0x7F; 1553 bit = vtag & 0x1F; 1554 ixv_shadow_vfta[index] |= (1 << bit); 1555 ++adapter->num_vlans; 1556 } /* ixv_if_register_vlan */ 1557 1558 /************************************************************************ 1559 * ixv_if_unregister_vlan 1560 * 1561 * Run via a vlan unconfig EVENT, remove our entry 1562 * in the soft vfta. 1563 ************************************************************************/ 1564 static void 1565 ixv_if_unregister_vlan(if_ctx_t ctx, u16 vtag) 1566 { 1567 struct adapter *adapter = iflib_get_softc(ctx); 1568 u16 index, bit; 1569 1570 index = (vtag >> 5) & 0x7F; 1571 bit = vtag & 0x1F; 1572 ixv_shadow_vfta[index] &= ~(1 << bit); 1573 --adapter->num_vlans; 1574 } /* ixv_if_unregister_vlan */ 1575 1576 /************************************************************************ 1577 * ixv_if_enable_intr 1578 ************************************************************************/ 1579 static void 1580 ixv_if_enable_intr(if_ctx_t ctx) 1581 { 1582 struct adapter *adapter = iflib_get_softc(ctx); 1583 struct ixgbe_hw *hw = &adapter->hw; 1584 struct ix_rx_queue *que = adapter->rx_queues; 1585 u32 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 1586 1587 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask); 1588 1589 mask = IXGBE_EIMS_ENABLE_MASK; 1590 mask &= ~(IXGBE_EIMS_OTHER | IXGBE_EIMS_LSC); 1591 IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask); 1592 1593 for (int i = 0; i < adapter->num_rx_queues; i++, que++) 1594 ixv_enable_queue(adapter, que->msix); 1595 1596 IXGBE_WRITE_FLUSH(hw); 1597 } /* ixv_if_enable_intr */ 1598 1599 /************************************************************************ 1600 * ixv_if_disable_intr 1601 ************************************************************************/ 1602 static void 1603 ixv_if_disable_intr(if_ctx_t ctx) 1604 { 1605 struct adapter *adapter = iflib_get_softc(ctx); 1606 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIAC, 0); 1607 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIMC, ~0); 1608 IXGBE_WRITE_FLUSH(&adapter->hw); 1609 } /* ixv_if_disable_intr */ 1610 1611 /************************************************************************ 1612 * ixv_if_rx_queue_intr_enable 1613 ************************************************************************/ 1614 static int 1615 ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid) 1616 { 1617 struct adapter *adapter = iflib_get_softc(ctx); 1618 struct ix_rx_queue *que = &adapter->rx_queues[rxqid]; 1619 1620 ixv_enable_queue(adapter, que->rxr.me); 1621 1622 return (0); 1623 } /* ixv_if_rx_queue_intr_enable */ 1624 1625 /************************************************************************ 1626 * ixv_set_ivar 1627 * 1628 * Setup the correct IVAR register for a particular MSI-X interrupt 1629 * - entry is the register array entry 1630 * - vector is the MSI-X vector for this queue 1631 * - type is RX/TX/MISC 1632 ************************************************************************/ 1633 static void 1634 ixv_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 1635 { 1636 struct ixgbe_hw *hw = &adapter->hw; 1637 u32 ivar, index; 1638 1639 vector |= IXGBE_IVAR_ALLOC_VAL; 1640 1641 if (type == -1) { /* MISC IVAR */ 1642 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); 1643 ivar &= ~0xFF; 1644 ivar |= vector; 1645 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar); 1646 } else { /* RX/TX IVARS */ 1647 index = (16 * (entry & 1)) + (8 * type); 1648 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(entry >> 1)); 1649 ivar &= ~(0xFF << index); 1650 ivar |= (vector << index); 1651 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(entry >> 1), ivar); 1652 } 1653 } /* ixv_set_ivar */ 1654 1655 /************************************************************************ 1656 * ixv_configure_ivars 1657 ************************************************************************/ 1658 static void 1659 ixv_configure_ivars(struct adapter *adapter) 1660 { 1661 struct ix_rx_queue *que = adapter->rx_queues; 1662 1663 MPASS(adapter->num_rx_queues == adapter->num_tx_queues); 1664 1665 for (int i = 0; i < adapter->num_rx_queues; i++, que++) { 1666 /* First the RX queue entry */ 1667 ixv_set_ivar(adapter, i, que->msix, 0); 1668 /* ... and the TX */ 1669 ixv_set_ivar(adapter, i, que->msix, 1); 1670 /* Set an initial value in EITR */ 1671 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEITR(que->msix), 1672 IXGBE_EITR_DEFAULT); 1673 } 1674 1675 /* For the mailbox interrupt */ 1676 ixv_set_ivar(adapter, 1, adapter->vector, -1); 1677 } /* ixv_configure_ivars */ 1678 1679 /************************************************************************ 1680 * ixv_save_stats 1681 * 1682 * The VF stats registers never have a truly virgin 1683 * starting point, so this routine tries to make an 1684 * artificial one, marking ground zero on attach as 1685 * it were. 1686 ************************************************************************/ 1687 static void 1688 ixv_save_stats(struct adapter *adapter) 1689 { 1690 if (adapter->stats.vf.vfgprc || adapter->stats.vf.vfgptc) { 1691 adapter->stats.vf.saved_reset_vfgprc += 1692 adapter->stats.vf.vfgprc - adapter->stats.vf.base_vfgprc; 1693 adapter->stats.vf.saved_reset_vfgptc += 1694 adapter->stats.vf.vfgptc - adapter->stats.vf.base_vfgptc; 1695 adapter->stats.vf.saved_reset_vfgorc += 1696 adapter->stats.vf.vfgorc - adapter->stats.vf.base_vfgorc; 1697 adapter->stats.vf.saved_reset_vfgotc += 1698 adapter->stats.vf.vfgotc - adapter->stats.vf.base_vfgotc; 1699 adapter->stats.vf.saved_reset_vfmprc += 1700 adapter->stats.vf.vfmprc - adapter->stats.vf.base_vfmprc; 1701 } 1702 } /* ixv_save_stats */ 1703 1704 /************************************************************************ 1705 * ixv_init_stats 1706 ************************************************************************/ 1707 static void 1708 ixv_init_stats(struct adapter *adapter) 1709 { 1710 struct ixgbe_hw *hw = &adapter->hw; 1711 1712 adapter->stats.vf.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC); 1713 adapter->stats.vf.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB); 1714 adapter->stats.vf.last_vfgorc |= 1715 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32); 1716 1717 adapter->stats.vf.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC); 1718 adapter->stats.vf.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB); 1719 adapter->stats.vf.last_vfgotc |= 1720 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32); 1721 1722 adapter->stats.vf.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC); 1723 1724 adapter->stats.vf.base_vfgprc = adapter->stats.vf.last_vfgprc; 1725 adapter->stats.vf.base_vfgorc = adapter->stats.vf.last_vfgorc; 1726 adapter->stats.vf.base_vfgptc = adapter->stats.vf.last_vfgptc; 1727 adapter->stats.vf.base_vfgotc = adapter->stats.vf.last_vfgotc; 1728 adapter->stats.vf.base_vfmprc = adapter->stats.vf.last_vfmprc; 1729 } /* ixv_init_stats */ 1730 1731 #define UPDATE_STAT_32(reg, last, count) \ 1732 { \ 1733 u32 current = IXGBE_READ_REG(hw, reg); \ 1734 if (current < last) \ 1735 count += 0x100000000LL; \ 1736 last = current; \ 1737 count &= 0xFFFFFFFF00000000LL; \ 1738 count |= current; \ 1739 } 1740 1741 #define UPDATE_STAT_36(lsb, msb, last, count) \ 1742 { \ 1743 u64 cur_lsb = IXGBE_READ_REG(hw, lsb); \ 1744 u64 cur_msb = IXGBE_READ_REG(hw, msb); \ 1745 u64 current = ((cur_msb << 32) | cur_lsb); \ 1746 if (current < last) \ 1747 count += 0x1000000000LL; \ 1748 last = current; \ 1749 count &= 0xFFFFFFF000000000LL; \ 1750 count |= current; \ 1751 } 1752 1753 /************************************************************************ 1754 * ixv_update_stats - Update the board statistics counters. 1755 ************************************************************************/ 1756 void 1757 ixv_update_stats(struct adapter *adapter) 1758 { 1759 struct ixgbe_hw *hw = &adapter->hw; 1760 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 1761 1762 UPDATE_STAT_32(IXGBE_VFGPRC, adapter->stats.vf.last_vfgprc, 1763 adapter->stats.vf.vfgprc); 1764 UPDATE_STAT_32(IXGBE_VFGPTC, adapter->stats.vf.last_vfgptc, 1765 adapter->stats.vf.vfgptc); 1766 UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB, 1767 adapter->stats.vf.last_vfgorc, adapter->stats.vf.vfgorc); 1768 UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB, 1769 adapter->stats.vf.last_vfgotc, adapter->stats.vf.vfgotc); 1770 UPDATE_STAT_32(IXGBE_VFMPRC, adapter->stats.vf.last_vfmprc, 1771 adapter->stats.vf.vfmprc); 1772 1773 /* Fill out the OS statistics structure */ 1774 IXGBE_SET_IPACKETS(adapter, stats->vfgprc); 1775 IXGBE_SET_OPACKETS(adapter, stats->vfgptc); 1776 IXGBE_SET_IBYTES(adapter, stats->vfgorc); 1777 IXGBE_SET_OBYTES(adapter, stats->vfgotc); 1778 IXGBE_SET_IMCASTS(adapter, stats->vfmprc); 1779 } /* ixv_update_stats */ 1780 1781 /************************************************************************ 1782 * ixv_add_stats_sysctls - Add statistic sysctls for the VF. 1783 ************************************************************************/ 1784 static void 1785 ixv_add_stats_sysctls(struct adapter *adapter) 1786 { 1787 device_t dev = adapter->dev; 1788 struct ix_tx_queue *tx_que = adapter->tx_queues; 1789 struct ix_rx_queue *rx_que = adapter->rx_queues; 1790 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 1791 struct sysctl_oid *tree = device_get_sysctl_tree(dev); 1792 struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree); 1793 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 1794 struct sysctl_oid *stat_node, *queue_node; 1795 struct sysctl_oid_list *stat_list, *queue_list; 1796 1797 #define QUEUE_NAME_LEN 32 1798 char namebuf[QUEUE_NAME_LEN]; 1799 1800 /* Driver Statistics */ 1801 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "watchdog_events", 1802 CTLFLAG_RD, &adapter->watchdog_events, "Watchdog timeouts"); 1803 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq", 1804 CTLFLAG_RD, &adapter->link_irq, "Link MSI-X IRQ Handled"); 1805 1806 for (int i = 0; i < adapter->num_tx_queues; i++, tx_que++) { 1807 struct tx_ring *txr = &tx_que->txr; 1808 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i); 1809 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, 1810 CTLFLAG_RD, NULL, "Queue Name"); 1811 queue_list = SYSCTL_CHILDREN(queue_node); 1812 1813 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx", 1814 CTLFLAG_RD, &(txr->tso_tx), "TSO Packets"); 1815 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_packets", 1816 CTLFLAG_RD, &(txr->total_packets), "TX Packets"); 1817 } 1818 1819 for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++) { 1820 struct rx_ring *rxr = &rx_que->rxr; 1821 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i); 1822 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, 1823 CTLFLAG_RD, NULL, "Queue Name"); 1824 queue_list = SYSCTL_CHILDREN(queue_node); 1825 1826 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs", 1827 CTLFLAG_RD, &(rx_que->irqs), "IRQs on queue"); 1828 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets", 1829 CTLFLAG_RD, &(rxr->rx_packets), "RX packets"); 1830 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_bytes", 1831 CTLFLAG_RD, &(rxr->rx_bytes), "RX bytes"); 1832 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_discarded", 1833 CTLFLAG_RD, &(rxr->rx_discarded), "Discarded RX packets"); 1834 } 1835 1836 stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac", 1837 CTLFLAG_RD, NULL, "VF Statistics (read from HW registers)"); 1838 stat_list = SYSCTL_CHILDREN(stat_node); 1839 1840 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_rcvd", 1841 CTLFLAG_RD, &stats->vfgprc, "Good Packets Received"); 1842 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_rcvd", 1843 CTLFLAG_RD, &stats->vfgorc, "Good Octets Received"); 1844 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "mcast_pkts_rcvd", 1845 CTLFLAG_RD, &stats->vfmprc, "Multicast Packets Received"); 1846 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_txd", 1847 CTLFLAG_RD, &stats->vfgptc, "Good Packets Transmitted"); 1848 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_txd", 1849 CTLFLAG_RD, &stats->vfgotc, "Good Octets Transmitted"); 1850 } /* ixv_add_stats_sysctls */ 1851 1852 /************************************************************************ 1853 * ixv_print_debug_info 1854 * 1855 * Called only when em_display_debug_stats is enabled. 1856 * Provides a way to take a look at important statistics 1857 * maintained by the driver and hardware. 1858 ************************************************************************/ 1859 static void 1860 ixv_print_debug_info(struct adapter *adapter) 1861 { 1862 device_t dev = adapter->dev; 1863 struct ixgbe_hw *hw = &adapter->hw; 1864 1865 device_printf(dev, "Error Byte Count = %u \n", 1866 IXGBE_READ_REG(hw, IXGBE_ERRBC)); 1867 1868 device_printf(dev, "MBX IRQ Handled: %lu\n", (long)adapter->link_irq); 1869 } /* ixv_print_debug_info */ 1870 1871 /************************************************************************ 1872 * ixv_sysctl_debug 1873 ************************************************************************/ 1874 static int 1875 ixv_sysctl_debug(SYSCTL_HANDLER_ARGS) 1876 { 1877 struct adapter *adapter; 1878 int error, result; 1879 1880 result = -1; 1881 error = sysctl_handle_int(oidp, &result, 0, req); 1882 1883 if (error || !req->newptr) 1884 return (error); 1885 1886 if (result == 1) { 1887 adapter = (struct adapter *)arg1; 1888 ixv_print_debug_info(adapter); 1889 } 1890 1891 return error; 1892 } /* ixv_sysctl_debug */ 1893 1894 /************************************************************************ 1895 * ixv_init_device_features 1896 ************************************************************************/ 1897 static void 1898 ixv_init_device_features(struct adapter *adapter) 1899 { 1900 adapter->feat_cap = IXGBE_FEATURE_NETMAP 1901 | IXGBE_FEATURE_VF 1902 | IXGBE_FEATURE_RSS 1903 | IXGBE_FEATURE_LEGACY_TX; 1904 1905 /* A tad short on feature flags for VFs, atm. */ 1906 switch (adapter->hw.mac.type) { 1907 case ixgbe_mac_82599_vf: 1908 break; 1909 case ixgbe_mac_X540_vf: 1910 break; 1911 case ixgbe_mac_X550_vf: 1912 case ixgbe_mac_X550EM_x_vf: 1913 case ixgbe_mac_X550EM_a_vf: 1914 adapter->feat_cap |= IXGBE_FEATURE_NEEDS_CTXD; 1915 break; 1916 default: 1917 break; 1918 } 1919 1920 /* Enabled by default... */ 1921 /* Is a virtual function (VF) */ 1922 if (adapter->feat_cap & IXGBE_FEATURE_VF) 1923 adapter->feat_en |= IXGBE_FEATURE_VF; 1924 /* Netmap */ 1925 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 1926 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 1927 /* Receive-Side Scaling (RSS) */ 1928 if (adapter->feat_cap & IXGBE_FEATURE_RSS) 1929 adapter->feat_en |= IXGBE_FEATURE_RSS; 1930 /* Needs advanced context descriptor regardless of offloads req'd */ 1931 if (adapter->feat_cap & IXGBE_FEATURE_NEEDS_CTXD) 1932 adapter->feat_en |= IXGBE_FEATURE_NEEDS_CTXD; 1933 } /* ixv_init_device_features */ 1934 1935