ixv.c revision 1.136
1 /*$NetBSD: ixv.c,v 1.136 2019/09/13 07:55:07 msaitoh Exp $*/ 2 3 /****************************************************************************** 4 5 Copyright (c) 2001-2017, Intel Corporation 6 All rights reserved. 7 8 Redistribution and use in source and binary forms, with or without 9 modification, are permitted provided that the following conditions are met: 10 11 1. Redistributions of source code must retain the above copyright notice, 12 this list of conditions and the following disclaimer. 13 14 2. Redistributions in binary form must reproduce the above copyright 15 notice, this list of conditions and the following disclaimer in the 16 documentation and/or other materials provided with the distribution. 17 18 3. Neither the name of the Intel Corporation nor the names of its 19 contributors may be used to endorse or promote products derived from 20 this software without specific prior written permission. 21 22 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 23 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 26 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 POSSIBILITY OF SUCH DAMAGE. 33 34 ******************************************************************************/ 35 /*$FreeBSD: head/sys/dev/ixgbe/if_ixv.c 331224 2018-03-19 20:55:05Z erj $*/ 36 37 #ifdef _KERNEL_OPT 38 #include "opt_inet.h" 39 #include "opt_inet6.h" 40 #include "opt_net_mpsafe.h" 41 #endif 42 43 #include "ixgbe.h" 44 #include "vlan.h" 45 46 /************************************************************************ 47 * Driver version 48 ************************************************************************/ 49 static const char ixv_driver_version[] = "2.0.1-k"; 50 /* XXX NetBSD: + 1.5.17 */ 51 52 /************************************************************************ 53 * PCI Device ID Table 54 * 55 * Used by probe to select devices to load on 56 * Last field stores an index into ixv_strings 57 * Last entry must be all 0s 58 * 59 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 60 ************************************************************************/ 61 static const ixgbe_vendor_info_t ixv_vendor_info_array[] = 62 { 63 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, 0, 0, 0}, 64 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, 0, 0, 0}, 65 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, 0, 0, 0}, 66 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, 0, 0, 0}, 67 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, 0, 0, 0}, 68 /* required last entry */ 69 {0, 0, 0, 0, 0} 70 }; 71 72 /************************************************************************ 73 * Table of branding strings 74 ************************************************************************/ 75 static const char *ixv_strings[] = { 76 "Intel(R) PRO/10GbE Virtual Function Network Driver" 77 }; 78 79 /********************************************************************* 80 * Function prototypes 81 *********************************************************************/ 82 static int ixv_probe(device_t, cfdata_t, void *); 83 static void ixv_attach(device_t, device_t, void *); 84 static int ixv_detach(device_t, int); 85 #if 0 86 static int ixv_shutdown(device_t); 87 #endif 88 static int ixv_ifflags_cb(struct ethercom *); 89 static int ixv_ioctl(struct ifnet *, u_long, void *); 90 static int ixv_init(struct ifnet *); 91 static void ixv_init_locked(struct adapter *); 92 static void ixv_ifstop(struct ifnet *, int); 93 static void ixv_stop(void *); 94 static void ixv_init_device_features(struct adapter *); 95 static void ixv_media_status(struct ifnet *, struct ifmediareq *); 96 static int ixv_media_change(struct ifnet *); 97 static int ixv_allocate_pci_resources(struct adapter *, 98 const struct pci_attach_args *); 99 static int ixv_allocate_msix(struct adapter *, 100 const struct pci_attach_args *); 101 static int ixv_configure_interrupts(struct adapter *); 102 static void ixv_free_pci_resources(struct adapter *); 103 static void ixv_local_timer(void *); 104 static void ixv_local_timer_locked(void *); 105 static int ixv_setup_interface(device_t, struct adapter *); 106 static int ixv_negotiate_api(struct adapter *); 107 108 static void ixv_initialize_transmit_units(struct adapter *); 109 static void ixv_initialize_receive_units(struct adapter *); 110 static void ixv_initialize_rss_mapping(struct adapter *); 111 static s32 ixv_check_link(struct adapter *); 112 113 static void ixv_enable_intr(struct adapter *); 114 static void ixv_disable_intr(struct adapter *); 115 static void ixv_set_multi(struct adapter *); 116 static void ixv_update_link_status(struct adapter *); 117 static int ixv_sysctl_debug(SYSCTLFN_PROTO); 118 static void ixv_set_ivar(struct adapter *, u8, u8, s8); 119 static void ixv_configure_ivars(struct adapter *); 120 static u8 * ixv_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *); 121 static void ixv_eitr_write(struct adapter *, uint32_t, uint32_t); 122 123 static void ixv_setup_vlan_tagging(struct adapter *); 124 static int ixv_setup_vlan_support(struct adapter *); 125 static int ixv_vlan_cb(struct ethercom *, uint16_t, bool); 126 static int ixv_register_vlan(struct adapter *, u16); 127 static int ixv_unregister_vlan(struct adapter *, u16); 128 129 static void ixv_add_device_sysctls(struct adapter *); 130 static void ixv_save_stats(struct adapter *); 131 static void ixv_init_stats(struct adapter *); 132 static void ixv_update_stats(struct adapter *); 133 static void ixv_add_stats_sysctls(struct adapter *); 134 static void ixv_clear_evcnt(struct adapter *); 135 136 /* Sysctl handlers */ 137 static void ixv_set_sysctl_value(struct adapter *, const char *, 138 const char *, int *, int); 139 static int ixv_sysctl_interrupt_rate_handler(SYSCTLFN_PROTO); 140 static int ixv_sysctl_next_to_check_handler(SYSCTLFN_PROTO); 141 static int ixv_sysctl_rdh_handler(SYSCTLFN_PROTO); 142 static int ixv_sysctl_rdt_handler(SYSCTLFN_PROTO); 143 static int ixv_sysctl_tdt_handler(SYSCTLFN_PROTO); 144 static int ixv_sysctl_tdh_handler(SYSCTLFN_PROTO); 145 146 /* The MSI-X Interrupt handlers */ 147 static int ixv_msix_que(void *); 148 static int ixv_msix_mbx(void *); 149 150 /* Deferred interrupt tasklets */ 151 static void ixv_handle_que(void *); 152 static void ixv_handle_link(void *); 153 154 /* Workqueue handler for deferred work */ 155 static void ixv_handle_que_work(struct work *, void *); 156 157 const struct sysctlnode *ixv_sysctl_instance(struct adapter *); 158 static const ixgbe_vendor_info_t *ixv_lookup(const struct pci_attach_args *); 159 160 /************************************************************************ 161 * FreeBSD Device Interface Entry Points 162 ************************************************************************/ 163 CFATTACH_DECL3_NEW(ixv, sizeof(struct adapter), 164 ixv_probe, ixv_attach, ixv_detach, NULL, NULL, NULL, 165 DVF_DETACH_SHUTDOWN); 166 167 #if 0 168 static driver_t ixv_driver = { 169 "ixv", ixv_methods, sizeof(struct adapter), 170 }; 171 172 devclass_t ixv_devclass; 173 DRIVER_MODULE(ixv, pci, ixv_driver, ixv_devclass, 0, 0); 174 MODULE_DEPEND(ixv, pci, 1, 1, 1); 175 MODULE_DEPEND(ixv, ether, 1, 1, 1); 176 #endif 177 178 /* 179 * TUNEABLE PARAMETERS: 180 */ 181 182 /* Number of Queues - do not exceed MSI-X vectors - 1 */ 183 static int ixv_num_queues = 0; 184 #define TUNABLE_INT(__x, __y) 185 TUNABLE_INT("hw.ixv.num_queues", &ixv_num_queues); 186 187 /* 188 * AIM: Adaptive Interrupt Moderation 189 * which means that the interrupt rate 190 * is varied over time based on the 191 * traffic for that interrupt vector 192 */ 193 static bool ixv_enable_aim = false; 194 TUNABLE_INT("hw.ixv.enable_aim", &ixv_enable_aim); 195 196 static int ixv_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY); 197 TUNABLE_INT("hw.ixv.max_interrupt_rate", &ixv_max_interrupt_rate); 198 199 /* How many packets rxeof tries to clean at a time */ 200 static int ixv_rx_process_limit = 256; 201 TUNABLE_INT("hw.ixv.rx_process_limit", &ixv_rx_process_limit); 202 203 /* How many packets txeof tries to clean at a time */ 204 static int ixv_tx_process_limit = 256; 205 TUNABLE_INT("hw.ixv.tx_process_limit", &ixv_tx_process_limit); 206 207 /* Which packet processing uses workqueue or softint */ 208 static bool ixv_txrx_workqueue = false; 209 210 /* 211 * Number of TX descriptors per ring, 212 * setting higher than RX as this seems 213 * the better performing choice. 214 */ 215 static int ixv_txd = PERFORM_TXD; 216 TUNABLE_INT("hw.ixv.txd", &ixv_txd); 217 218 /* Number of RX descriptors per ring */ 219 static int ixv_rxd = PERFORM_RXD; 220 TUNABLE_INT("hw.ixv.rxd", &ixv_rxd); 221 222 /* Legacy Transmit (single queue) */ 223 static int ixv_enable_legacy_tx = 0; 224 TUNABLE_INT("hw.ixv.enable_legacy_tx", &ixv_enable_legacy_tx); 225 226 #ifdef NET_MPSAFE 227 #define IXGBE_MPSAFE 1 228 #define IXGBE_CALLOUT_FLAGS CALLOUT_MPSAFE 229 #define IXGBE_SOFTINFT_FLAGS SOFTINT_MPSAFE 230 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU | WQ_MPSAFE 231 #else 232 #define IXGBE_CALLOUT_FLAGS 0 233 #define IXGBE_SOFTINFT_FLAGS 0 234 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU 235 #endif 236 #define IXGBE_WORKQUEUE_PRI PRI_SOFTNET 237 238 #if 0 239 static int (*ixv_start_locked)(struct ifnet *, struct tx_ring *); 240 static int (*ixv_ring_empty)(struct ifnet *, struct buf_ring *); 241 #endif 242 243 /************************************************************************ 244 * ixv_probe - Device identification routine 245 * 246 * Determines if the driver should be loaded on 247 * adapter based on its PCI vendor/device ID. 248 * 249 * return BUS_PROBE_DEFAULT on success, positive on failure 250 ************************************************************************/ 251 static int 252 ixv_probe(device_t dev, cfdata_t cf, void *aux) 253 { 254 #ifdef __HAVE_PCI_MSI_MSIX 255 const struct pci_attach_args *pa = aux; 256 257 return (ixv_lookup(pa) != NULL) ? 1 : 0; 258 #else 259 return 0; 260 #endif 261 } /* ixv_probe */ 262 263 static const ixgbe_vendor_info_t * 264 ixv_lookup(const struct pci_attach_args *pa) 265 { 266 const ixgbe_vendor_info_t *ent; 267 pcireg_t subid; 268 269 INIT_DEBUGOUT("ixv_lookup: begin"); 270 271 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 272 return NULL; 273 274 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 275 276 for (ent = ixv_vendor_info_array; ent->vendor_id != 0; ent++) { 277 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 278 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 279 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 280 (ent->subvendor_id == 0)) && 281 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 282 (ent->subdevice_id == 0))) { 283 return ent; 284 } 285 } 286 287 return NULL; 288 } 289 290 /************************************************************************ 291 * ixv_attach - Device initialization routine 292 * 293 * Called when the driver is being loaded. 294 * Identifies the type of hardware, allocates all resources 295 * and initializes the hardware. 296 * 297 * return 0 on success, positive on failure 298 ************************************************************************/ 299 static void 300 ixv_attach(device_t parent, device_t dev, void *aux) 301 { 302 struct adapter *adapter; 303 struct ixgbe_hw *hw; 304 int error = 0; 305 pcireg_t id, subid; 306 const ixgbe_vendor_info_t *ent; 307 const struct pci_attach_args *pa = aux; 308 const char *apivstr; 309 const char *str; 310 char buf[256]; 311 312 INIT_DEBUGOUT("ixv_attach: begin"); 313 314 /* 315 * Make sure BUSMASTER is set, on a VM under 316 * KVM it may not be and will break things. 317 */ 318 ixgbe_pci_enable_busmaster(pa->pa_pc, pa->pa_tag); 319 320 /* Allocate, clear, and link in our adapter structure */ 321 adapter = device_private(dev); 322 adapter->dev = dev; 323 adapter->hw.back = adapter; 324 hw = &adapter->hw; 325 326 adapter->init_locked = ixv_init_locked; 327 adapter->stop_locked = ixv_stop; 328 329 adapter->osdep.pc = pa->pa_pc; 330 adapter->osdep.tag = pa->pa_tag; 331 if (pci_dma64_available(pa)) 332 adapter->osdep.dmat = pa->pa_dmat64; 333 else 334 adapter->osdep.dmat = pa->pa_dmat; 335 adapter->osdep.attached = false; 336 337 ent = ixv_lookup(pa); 338 339 KASSERT(ent != NULL); 340 341 aprint_normal(": %s, Version - %s\n", 342 ixv_strings[ent->index], ixv_driver_version); 343 344 /* Core Lock Init*/ 345 IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev)); 346 347 /* Do base PCI setup - map BAR0 */ 348 if (ixv_allocate_pci_resources(adapter, pa)) { 349 aprint_error_dev(dev, "ixv_allocate_pci_resources() failed!\n"); 350 error = ENXIO; 351 goto err_out; 352 } 353 354 /* SYSCTL APIs */ 355 ixv_add_device_sysctls(adapter); 356 357 /* Set up the timer callout */ 358 callout_init(&adapter->timer, IXGBE_CALLOUT_FLAGS); 359 360 /* Save off the information about this board */ 361 id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG); 362 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 363 hw->vendor_id = PCI_VENDOR(id); 364 hw->device_id = PCI_PRODUCT(id); 365 hw->revision_id = 366 PCI_REVISION(pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG)); 367 hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid); 368 hw->subsystem_device_id = PCI_SUBSYS_ID(subid); 369 370 /* A subset of set_mac_type */ 371 switch (hw->device_id) { 372 case IXGBE_DEV_ID_82599_VF: 373 hw->mac.type = ixgbe_mac_82599_vf; 374 str = "82599 VF"; 375 break; 376 case IXGBE_DEV_ID_X540_VF: 377 hw->mac.type = ixgbe_mac_X540_vf; 378 str = "X540 VF"; 379 break; 380 case IXGBE_DEV_ID_X550_VF: 381 hw->mac.type = ixgbe_mac_X550_vf; 382 str = "X550 VF"; 383 break; 384 case IXGBE_DEV_ID_X550EM_X_VF: 385 hw->mac.type = ixgbe_mac_X550EM_x_vf; 386 str = "X550EM X VF"; 387 break; 388 case IXGBE_DEV_ID_X550EM_A_VF: 389 hw->mac.type = ixgbe_mac_X550EM_a_vf; 390 str = "X550EM A VF"; 391 break; 392 default: 393 /* Shouldn't get here since probe succeeded */ 394 aprint_error_dev(dev, "Unknown device ID!\n"); 395 error = ENXIO; 396 goto err_out; 397 break; 398 } 399 aprint_normal_dev(dev, "device %s\n", str); 400 401 ixv_init_device_features(adapter); 402 403 /* Initialize the shared code */ 404 error = ixgbe_init_ops_vf(hw); 405 if (error) { 406 aprint_error_dev(dev, "ixgbe_init_ops_vf() failed!\n"); 407 error = EIO; 408 goto err_out; 409 } 410 411 /* Setup the mailbox */ 412 ixgbe_init_mbx_params_vf(hw); 413 414 /* Set the right number of segments */ 415 adapter->num_segs = IXGBE_82599_SCATTER; 416 417 /* Reset mbox api to 1.0 */ 418 error = hw->mac.ops.reset_hw(hw); 419 if (error == IXGBE_ERR_RESET_FAILED) 420 aprint_error_dev(dev, "...reset_hw() failure: Reset Failed!\n"); 421 else if (error) 422 aprint_error_dev(dev, "...reset_hw() failed with error %d\n", 423 error); 424 if (error) { 425 error = EIO; 426 goto err_out; 427 } 428 429 error = hw->mac.ops.init_hw(hw); 430 if (error) { 431 aprint_error_dev(dev, "...init_hw() failed!\n"); 432 error = EIO; 433 goto err_out; 434 } 435 436 /* Negotiate mailbox API version */ 437 error = ixv_negotiate_api(adapter); 438 if (error) 439 aprint_normal_dev(dev, 440 "MBX API negotiation failed during attach!\n"); 441 switch (hw->api_version) { 442 case ixgbe_mbox_api_10: 443 apivstr = "1.0"; 444 break; 445 case ixgbe_mbox_api_20: 446 apivstr = "2.0"; 447 break; 448 case ixgbe_mbox_api_11: 449 apivstr = "1.1"; 450 break; 451 case ixgbe_mbox_api_12: 452 apivstr = "1.2"; 453 break; 454 case ixgbe_mbox_api_13: 455 apivstr = "1.3"; 456 break; 457 default: 458 apivstr = "unknown"; 459 break; 460 } 461 aprint_normal_dev(dev, "Mailbox API %s\n", apivstr); 462 463 /* If no mac address was assigned, make a random one */ 464 if (!ixv_check_ether_addr(hw->mac.addr)) { 465 u8 addr[ETHER_ADDR_LEN]; 466 uint64_t rndval = cprng_strong64(); 467 468 memcpy(addr, &rndval, sizeof(addr)); 469 addr[0] &= 0xFE; 470 addr[0] |= 0x02; 471 bcopy(addr, hw->mac.addr, sizeof(addr)); 472 } 473 474 /* Register for VLAN events */ 475 ether_set_vlan_cb(&adapter->osdep.ec, ixv_vlan_cb); 476 477 /* Sysctls for limiting the amount of work done in the taskqueues */ 478 ixv_set_sysctl_value(adapter, "rx_processing_limit", 479 "max number of rx packets to process", 480 &adapter->rx_process_limit, ixv_rx_process_limit); 481 482 ixv_set_sysctl_value(adapter, "tx_processing_limit", 483 "max number of tx packets to process", 484 &adapter->tx_process_limit, ixv_tx_process_limit); 485 486 /* Do descriptor calc and sanity checks */ 487 if (((ixv_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 || 488 ixv_txd < MIN_TXD || ixv_txd > MAX_TXD) { 489 aprint_error_dev(dev, "TXD config issue, using default!\n"); 490 adapter->num_tx_desc = DEFAULT_TXD; 491 } else 492 adapter->num_tx_desc = ixv_txd; 493 494 if (((ixv_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 || 495 ixv_rxd < MIN_RXD || ixv_rxd > MAX_RXD) { 496 aprint_error_dev(dev, "RXD config issue, using default!\n"); 497 adapter->num_rx_desc = DEFAULT_RXD; 498 } else 499 adapter->num_rx_desc = ixv_rxd; 500 501 /* Setup MSI-X */ 502 error = ixv_configure_interrupts(adapter); 503 if (error) 504 goto err_out; 505 506 /* Allocate our TX/RX Queues */ 507 if (ixgbe_allocate_queues(adapter)) { 508 aprint_error_dev(dev, "ixgbe_allocate_queues() failed!\n"); 509 error = ENOMEM; 510 goto err_out; 511 } 512 513 /* hw.ix defaults init */ 514 adapter->enable_aim = ixv_enable_aim; 515 516 adapter->txrx_use_workqueue = ixv_txrx_workqueue; 517 518 error = ixv_allocate_msix(adapter, pa); 519 if (error) { 520 aprint_error_dev(dev, "ixv_allocate_msix() failed!\n"); 521 goto err_late; 522 } 523 524 /* Setup OS specific network interface */ 525 error = ixv_setup_interface(dev, adapter); 526 if (error != 0) { 527 aprint_error_dev(dev, "ixv_setup_interface() failed!\n"); 528 goto err_late; 529 } 530 531 /* Do the stats setup */ 532 ixv_save_stats(adapter); 533 ixv_init_stats(adapter); 534 ixv_add_stats_sysctls(adapter); 535 536 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 537 ixgbe_netmap_attach(adapter); 538 539 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_cap); 540 aprint_verbose_dev(dev, "feature cap %s\n", buf); 541 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_en); 542 aprint_verbose_dev(dev, "feature ena %s\n", buf); 543 544 INIT_DEBUGOUT("ixv_attach: end"); 545 adapter->osdep.attached = true; 546 547 return; 548 549 err_late: 550 ixgbe_free_transmit_structures(adapter); 551 ixgbe_free_receive_structures(adapter); 552 free(adapter->queues, M_DEVBUF); 553 err_out: 554 ixv_free_pci_resources(adapter); 555 IXGBE_CORE_LOCK_DESTROY(adapter); 556 557 return; 558 } /* ixv_attach */ 559 560 /************************************************************************ 561 * ixv_detach - Device removal routine 562 * 563 * Called when the driver is being removed. 564 * Stops the adapter and deallocates all the resources 565 * that were allocated for driver operation. 566 * 567 * return 0 on success, positive on failure 568 ************************************************************************/ 569 static int 570 ixv_detach(device_t dev, int flags) 571 { 572 struct adapter *adapter = device_private(dev); 573 struct ixgbe_hw *hw = &adapter->hw; 574 struct ix_queue *que = adapter->queues; 575 struct tx_ring *txr = adapter->tx_rings; 576 struct rx_ring *rxr = adapter->rx_rings; 577 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 578 579 INIT_DEBUGOUT("ixv_detach: begin"); 580 if (adapter->osdep.attached == false) 581 return 0; 582 583 /* Stop the interface. Callouts are stopped in it. */ 584 ixv_ifstop(adapter->ifp, 1); 585 586 #if NVLAN > 0 587 /* Make sure VLANs are not using driver */ 588 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 589 ; /* nothing to do: no VLANs */ 590 else if ((flags & (DETACH_SHUTDOWN | DETACH_FORCE)) != 0) 591 vlan_ifdetach(adapter->ifp); 592 else { 593 aprint_error_dev(dev, "VLANs in use, detach first\n"); 594 return EBUSY; 595 } 596 #endif 597 598 for (int i = 0; i < adapter->num_queues; i++, que++, txr++) { 599 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 600 softint_disestablish(txr->txr_si); 601 softint_disestablish(que->que_si); 602 } 603 if (adapter->txr_wq != NULL) 604 workqueue_destroy(adapter->txr_wq); 605 if (adapter->txr_wq_enqueued != NULL) 606 percpu_free(adapter->txr_wq_enqueued, sizeof(u_int)); 607 if (adapter->que_wq != NULL) 608 workqueue_destroy(adapter->que_wq); 609 610 /* Drain the Mailbox(link) queue */ 611 softint_disestablish(adapter->link_si); 612 613 ether_ifdetach(adapter->ifp); 614 callout_halt(&adapter->timer, NULL); 615 616 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 617 netmap_detach(adapter->ifp); 618 619 ixv_free_pci_resources(adapter); 620 #if 0 /* XXX the NetBSD port is probably missing something here */ 621 bus_generic_detach(dev); 622 #endif 623 if_detach(adapter->ifp); 624 if_percpuq_destroy(adapter->ipq); 625 626 sysctl_teardown(&adapter->sysctllog); 627 evcnt_detach(&adapter->efbig_tx_dma_setup); 628 evcnt_detach(&adapter->mbuf_defrag_failed); 629 evcnt_detach(&adapter->efbig2_tx_dma_setup); 630 evcnt_detach(&adapter->einval_tx_dma_setup); 631 evcnt_detach(&adapter->other_tx_dma_setup); 632 evcnt_detach(&adapter->eagain_tx_dma_setup); 633 evcnt_detach(&adapter->enomem_tx_dma_setup); 634 evcnt_detach(&adapter->watchdog_events); 635 evcnt_detach(&adapter->tso_err); 636 evcnt_detach(&adapter->link_irq); 637 638 txr = adapter->tx_rings; 639 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 640 evcnt_detach(&adapter->queues[i].irqs); 641 evcnt_detach(&adapter->queues[i].handleq); 642 evcnt_detach(&adapter->queues[i].req); 643 evcnt_detach(&txr->no_desc_avail); 644 evcnt_detach(&txr->total_packets); 645 evcnt_detach(&txr->tso_tx); 646 #ifndef IXGBE_LEGACY_TX 647 evcnt_detach(&txr->pcq_drops); 648 #endif 649 650 evcnt_detach(&rxr->rx_packets); 651 evcnt_detach(&rxr->rx_bytes); 652 evcnt_detach(&rxr->rx_copies); 653 evcnt_detach(&rxr->no_jmbuf); 654 evcnt_detach(&rxr->rx_discarded); 655 } 656 evcnt_detach(&stats->ipcs); 657 evcnt_detach(&stats->l4cs); 658 evcnt_detach(&stats->ipcs_bad); 659 evcnt_detach(&stats->l4cs_bad); 660 661 /* Packet Reception Stats */ 662 evcnt_detach(&stats->vfgorc); 663 evcnt_detach(&stats->vfgprc); 664 evcnt_detach(&stats->vfmprc); 665 666 /* Packet Transmission Stats */ 667 evcnt_detach(&stats->vfgotc); 668 evcnt_detach(&stats->vfgptc); 669 670 /* Mailbox Stats */ 671 evcnt_detach(&hw->mbx.stats.msgs_tx); 672 evcnt_detach(&hw->mbx.stats.msgs_rx); 673 evcnt_detach(&hw->mbx.stats.acks); 674 evcnt_detach(&hw->mbx.stats.reqs); 675 evcnt_detach(&hw->mbx.stats.rsts); 676 677 ixgbe_free_transmit_structures(adapter); 678 ixgbe_free_receive_structures(adapter); 679 for (int i = 0; i < adapter->num_queues; i++) { 680 struct ix_queue *lque = &adapter->queues[i]; 681 mutex_destroy(&lque->dc_mtx); 682 } 683 free(adapter->queues, M_DEVBUF); 684 685 IXGBE_CORE_LOCK_DESTROY(adapter); 686 687 return (0); 688 } /* ixv_detach */ 689 690 /************************************************************************ 691 * ixv_init_locked - Init entry point 692 * 693 * Used in two ways: It is used by the stack as an init entry 694 * point in network interface structure. It is also used 695 * by the driver as a hw/sw initialization routine to get 696 * to a consistent state. 697 * 698 * return 0 on success, positive on failure 699 ************************************************************************/ 700 static void 701 ixv_init_locked(struct adapter *adapter) 702 { 703 struct ifnet *ifp = adapter->ifp; 704 device_t dev = adapter->dev; 705 struct ixgbe_hw *hw = &adapter->hw; 706 struct ix_queue *que; 707 int error = 0; 708 uint32_t mask; 709 int i; 710 711 INIT_DEBUGOUT("ixv_init_locked: begin"); 712 KASSERT(mutex_owned(&adapter->core_mtx)); 713 hw->adapter_stopped = FALSE; 714 hw->mac.ops.stop_adapter(hw); 715 callout_stop(&adapter->timer); 716 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 717 que->disabled_count = 0; 718 719 /* reprogram the RAR[0] in case user changed it. */ 720 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 721 722 /* Get the latest mac address, User can use a LAA */ 723 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 724 IXGBE_ETH_LENGTH_OF_ADDRESS); 725 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1); 726 727 /* Prepare transmit descriptors and buffers */ 728 if (ixgbe_setup_transmit_structures(adapter)) { 729 aprint_error_dev(dev, "Could not setup transmit structures\n"); 730 ixv_stop(adapter); 731 return; 732 } 733 734 /* Reset VF and renegotiate mailbox API version */ 735 hw->mac.ops.reset_hw(hw); 736 hw->mac.ops.start_hw(hw); 737 error = ixv_negotiate_api(adapter); 738 if (error) 739 device_printf(dev, 740 "Mailbox API negotiation failed in init_locked!\n"); 741 742 ixv_initialize_transmit_units(adapter); 743 744 /* Setup Multicast table */ 745 ixv_set_multi(adapter); 746 747 /* 748 * Determine the correct mbuf pool 749 * for doing jumbo/headersplit 750 */ 751 if (ifp->if_mtu > ETHERMTU) 752 adapter->rx_mbuf_sz = MJUMPAGESIZE; 753 else 754 adapter->rx_mbuf_sz = MCLBYTES; 755 756 /* Prepare receive descriptors and buffers */ 757 if (ixgbe_setup_receive_structures(adapter)) { 758 device_printf(dev, "Could not setup receive structures\n"); 759 ixv_stop(adapter); 760 return; 761 } 762 763 /* Configure RX settings */ 764 ixv_initialize_receive_units(adapter); 765 766 #if 0 /* XXX isn't it required? -- msaitoh */ 767 /* Set the various hardware offload abilities */ 768 ifp->if_hwassist = 0; 769 if (ifp->if_capenable & IFCAP_TSO4) 770 ifp->if_hwassist |= CSUM_TSO; 771 if (ifp->if_capenable & IFCAP_TXCSUM) { 772 ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP); 773 #if __FreeBSD_version >= 800000 774 ifp->if_hwassist |= CSUM_SCTP; 775 #endif 776 } 777 #endif 778 779 /* Set up VLAN offload and filter */ 780 ixv_setup_vlan_support(adapter); 781 782 /* Set up MSI-X routing */ 783 ixv_configure_ivars(adapter); 784 785 /* Set up auto-mask */ 786 mask = (1 << adapter->vector); 787 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 788 mask |= (1 << que->msix); 789 IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, mask); 790 791 /* Set moderation on the Link interrupt */ 792 ixv_eitr_write(adapter, adapter->vector, IXGBE_LINK_ITR); 793 794 /* Stats init */ 795 ixv_init_stats(adapter); 796 797 /* Config/Enable Link */ 798 hw->mac.get_link_status = TRUE; 799 hw->mac.ops.check_link(hw, &adapter->link_speed, &adapter->link_up, 800 FALSE); 801 802 /* Start watchdog */ 803 callout_reset(&adapter->timer, hz, ixv_local_timer, adapter); 804 805 /* And now turn on interrupts */ 806 ixv_enable_intr(adapter); 807 808 /* Update saved flags. See ixgbe_ifflags_cb() */ 809 adapter->if_flags = ifp->if_flags; 810 adapter->ec_capenable = adapter->osdep.ec.ec_capenable; 811 812 /* Now inform the stack we're ready */ 813 ifp->if_flags |= IFF_RUNNING; 814 ifp->if_flags &= ~IFF_OACTIVE; 815 816 return; 817 } /* ixv_init_locked */ 818 819 /************************************************************************ 820 * ixv_enable_queue 821 ************************************************************************/ 822 static inline void 823 ixv_enable_queue(struct adapter *adapter, u32 vector) 824 { 825 struct ixgbe_hw *hw = &adapter->hw; 826 struct ix_queue *que = &adapter->queues[vector]; 827 u32 queue = 1UL << vector; 828 u32 mask; 829 830 mutex_enter(&que->dc_mtx); 831 if (que->disabled_count > 0 && --que->disabled_count > 0) 832 goto out; 833 834 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 835 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask); 836 out: 837 mutex_exit(&que->dc_mtx); 838 } /* ixv_enable_queue */ 839 840 /************************************************************************ 841 * ixv_disable_queue 842 ************************************************************************/ 843 static inline void 844 ixv_disable_queue(struct adapter *adapter, u32 vector) 845 { 846 struct ixgbe_hw *hw = &adapter->hw; 847 struct ix_queue *que = &adapter->queues[vector]; 848 u32 queue = 1UL << vector; 849 u32 mask; 850 851 mutex_enter(&que->dc_mtx); 852 if (que->disabled_count++ > 0) 853 goto out; 854 855 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 856 IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask); 857 out: 858 mutex_exit(&que->dc_mtx); 859 } /* ixv_disable_queue */ 860 861 #if 0 862 static inline void 863 ixv_rearm_queues(struct adapter *adapter, u64 queues) 864 { 865 u32 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 866 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEICS, mask); 867 } /* ixv_rearm_queues */ 868 #endif 869 870 871 /************************************************************************ 872 * ixv_msix_que - MSI-X Queue Interrupt Service routine 873 ************************************************************************/ 874 static int 875 ixv_msix_que(void *arg) 876 { 877 struct ix_queue *que = arg; 878 struct adapter *adapter = que->adapter; 879 struct tx_ring *txr = que->txr; 880 struct rx_ring *rxr = que->rxr; 881 bool more; 882 u32 newitr = 0; 883 884 ixv_disable_queue(adapter, que->msix); 885 ++que->irqs.ev_count; 886 887 #ifdef __NetBSD__ 888 /* Don't run ixgbe_rxeof in interrupt context */ 889 more = true; 890 #else 891 more = ixgbe_rxeof(que); 892 #endif 893 894 IXGBE_TX_LOCK(txr); 895 ixgbe_txeof(txr); 896 IXGBE_TX_UNLOCK(txr); 897 898 /* Do AIM now? */ 899 900 if (adapter->enable_aim == false) 901 goto no_calc; 902 /* 903 * Do Adaptive Interrupt Moderation: 904 * - Write out last calculated setting 905 * - Calculate based on average size over 906 * the last interval. 907 */ 908 if (que->eitr_setting) 909 ixv_eitr_write(adapter, que->msix, que->eitr_setting); 910 911 que->eitr_setting = 0; 912 913 /* Idle, do nothing */ 914 if ((txr->bytes == 0) && (rxr->bytes == 0)) 915 goto no_calc; 916 917 if ((txr->bytes) && (txr->packets)) 918 newitr = txr->bytes/txr->packets; 919 if ((rxr->bytes) && (rxr->packets)) 920 newitr = uimax(newitr, (rxr->bytes / rxr->packets)); 921 newitr += 24; /* account for hardware frame, crc */ 922 923 /* set an upper boundary */ 924 newitr = uimin(newitr, 3000); 925 926 /* Be nice to the mid range */ 927 if ((newitr > 300) && (newitr < 1200)) 928 newitr = (newitr / 3); 929 else 930 newitr = (newitr / 2); 931 932 /* 933 * When RSC is used, ITR interval must be larger than RSC_DELAY. 934 * Currently, we use 2us for RSC_DELAY. The minimum value is always 935 * greater than 2us on 100M (and 10M?(not documented)), but it's not 936 * on 1G and higher. 937 */ 938 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 939 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 940 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 941 newitr = IXGBE_MIN_RSC_EITR_10G1G; 942 } 943 944 /* save for next interrupt */ 945 que->eitr_setting = newitr; 946 947 /* Reset state */ 948 txr->bytes = 0; 949 txr->packets = 0; 950 rxr->bytes = 0; 951 rxr->packets = 0; 952 953 no_calc: 954 if (more) 955 softint_schedule(que->que_si); 956 else /* Re-enable this interrupt */ 957 ixv_enable_queue(adapter, que->msix); 958 959 return 1; 960 } /* ixv_msix_que */ 961 962 /************************************************************************ 963 * ixv_msix_mbx 964 ************************************************************************/ 965 static int 966 ixv_msix_mbx(void *arg) 967 { 968 struct adapter *adapter = arg; 969 struct ixgbe_hw *hw = &adapter->hw; 970 971 ++adapter->link_irq.ev_count; 972 /* NetBSD: We use auto-clear, so it's not required to write VTEICR */ 973 974 /* Link status change */ 975 hw->mac.get_link_status = TRUE; 976 softint_schedule(adapter->link_si); 977 978 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, (1 << adapter->vector)); 979 980 return 1; 981 } /* ixv_msix_mbx */ 982 983 static void 984 ixv_eitr_write(struct adapter *adapter, uint32_t index, uint32_t itr) 985 { 986 987 /* 988 * Newer devices than 82598 have VF function, so this function is 989 * simple. 990 */ 991 itr |= IXGBE_EITR_CNT_WDIS; 992 993 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEITR(index), itr); 994 } 995 996 997 /************************************************************************ 998 * ixv_media_status - Media Ioctl callback 999 * 1000 * Called whenever the user queries the status of 1001 * the interface using ifconfig. 1002 ************************************************************************/ 1003 static void 1004 ixv_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 1005 { 1006 struct adapter *adapter = ifp->if_softc; 1007 1008 INIT_DEBUGOUT("ixv_media_status: begin"); 1009 IXGBE_CORE_LOCK(adapter); 1010 ixv_update_link_status(adapter); 1011 1012 ifmr->ifm_status = IFM_AVALID; 1013 ifmr->ifm_active = IFM_ETHER; 1014 1015 if (adapter->link_active != LINK_STATE_UP) { 1016 ifmr->ifm_active |= IFM_NONE; 1017 IXGBE_CORE_UNLOCK(adapter); 1018 return; 1019 } 1020 1021 ifmr->ifm_status |= IFM_ACTIVE; 1022 1023 switch (adapter->link_speed) { 1024 case IXGBE_LINK_SPEED_10GB_FULL: 1025 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 1026 break; 1027 case IXGBE_LINK_SPEED_5GB_FULL: 1028 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 1029 break; 1030 case IXGBE_LINK_SPEED_2_5GB_FULL: 1031 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 1032 break; 1033 case IXGBE_LINK_SPEED_1GB_FULL: 1034 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 1035 break; 1036 case IXGBE_LINK_SPEED_100_FULL: 1037 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 1038 break; 1039 case IXGBE_LINK_SPEED_10_FULL: 1040 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 1041 break; 1042 } 1043 1044 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 1045 1046 IXGBE_CORE_UNLOCK(adapter); 1047 } /* ixv_media_status */ 1048 1049 /************************************************************************ 1050 * ixv_media_change - Media Ioctl callback 1051 * 1052 * Called when the user changes speed/duplex using 1053 * media/mediopt option with ifconfig. 1054 ************************************************************************/ 1055 static int 1056 ixv_media_change(struct ifnet *ifp) 1057 { 1058 struct adapter *adapter = ifp->if_softc; 1059 struct ifmedia *ifm = &adapter->media; 1060 1061 INIT_DEBUGOUT("ixv_media_change: begin"); 1062 1063 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 1064 return (EINVAL); 1065 1066 switch (IFM_SUBTYPE(ifm->ifm_media)) { 1067 case IFM_AUTO: 1068 break; 1069 default: 1070 device_printf(adapter->dev, "Only auto media type\n"); 1071 return (EINVAL); 1072 } 1073 1074 return (0); 1075 } /* ixv_media_change */ 1076 1077 1078 /************************************************************************ 1079 * ixv_negotiate_api 1080 * 1081 * Negotiate the Mailbox API with the PF; 1082 * start with the most featured API first. 1083 ************************************************************************/ 1084 static int 1085 ixv_negotiate_api(struct adapter *adapter) 1086 { 1087 struct ixgbe_hw *hw = &adapter->hw; 1088 int mbx_api[] = { ixgbe_mbox_api_13, 1089 ixgbe_mbox_api_12, 1090 ixgbe_mbox_api_11, 1091 ixgbe_mbox_api_10, 1092 ixgbe_mbox_api_unknown }; 1093 int i = 0; 1094 1095 while (mbx_api[i] != ixgbe_mbox_api_unknown) { 1096 if (ixgbevf_negotiate_api_version(hw, mbx_api[i]) == 0) 1097 return (0); 1098 i++; 1099 } 1100 1101 return (EINVAL); 1102 } /* ixv_negotiate_api */ 1103 1104 1105 /************************************************************************ 1106 * ixv_set_multi - Multicast Update 1107 * 1108 * Called whenever multicast address list is updated. 1109 ************************************************************************/ 1110 static void 1111 ixv_set_multi(struct adapter *adapter) 1112 { 1113 struct ixgbe_hw *hw = &adapter->hw; 1114 struct ether_multi *enm; 1115 struct ether_multistep step; 1116 struct ethercom *ec = &adapter->osdep.ec; 1117 u8 mta[IXGBE_MAX_VF_MC * IXGBE_ETH_LENGTH_OF_ADDRESS]; 1118 u8 *update_ptr; 1119 int mcnt = 0; 1120 bool overflow = false; 1121 bool allmulti = false; 1122 int error; 1123 1124 KASSERT(mutex_owned(&adapter->core_mtx)); 1125 IOCTL_DEBUGOUT("ixv_set_multi: begin"); 1126 1127 ETHER_LOCK(ec); 1128 ETHER_FIRST_MULTI(step, ec, enm); 1129 while (enm != NULL) { 1130 if (mcnt >= IXGBE_MAX_VF_MC) { 1131 overflow = true; 1132 break; 1133 } 1134 bcopy(enm->enm_addrlo, 1135 &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS], 1136 IXGBE_ETH_LENGTH_OF_ADDRESS); 1137 mcnt++; 1138 ETHER_NEXT_MULTI(step, enm); 1139 } 1140 ETHER_UNLOCK(ec); 1141 1142 if (overflow) { 1143 error = hw->mac.ops.update_xcast_mode(hw, 1144 IXGBEVF_XCAST_MODE_ALLMULTI); 1145 if (error == IXGBE_ERR_NOT_TRUSTED) { 1146 device_printf(adapter->dev, 1147 "this interface is not trusted\n"); 1148 error = EPERM; 1149 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 1150 device_printf(adapter->dev, 1151 "the PF doesn't support allmulti mode\n"); 1152 error = EOPNOTSUPP; 1153 } else if (error) { 1154 device_printf(adapter->dev, 1155 "number of Ethernet multicast addresses " 1156 "exceeds the limit (%d). error = %d\n", 1157 IXGBE_MAX_VF_MC, error); 1158 error = ENOSPC; 1159 } else { 1160 allmulti = true; 1161 ec->ec_flags |= ETHER_F_ALLMULTI; 1162 } 1163 } 1164 1165 if (!allmulti) { 1166 error = hw->mac.ops.update_xcast_mode(hw, 1167 IXGBEVF_XCAST_MODE_MULTI); 1168 if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 1169 /* normal operation */ 1170 error = 0; 1171 } else if (error) { 1172 device_printf(adapter->dev, 1173 "failed to set Ethernet multicast address " 1174 "operation to normal. error = %d\n", error); 1175 } 1176 ec->ec_flags &= ~ETHER_F_ALLMULTI; 1177 } 1178 1179 update_ptr = mta; 1180 1181 adapter->hw.mac.ops.update_mc_addr_list(&adapter->hw, update_ptr, mcnt, 1182 ixv_mc_array_itr, TRUE); 1183 } /* ixv_set_multi */ 1184 1185 /************************************************************************ 1186 * ixv_mc_array_itr 1187 * 1188 * An iterator function needed by the multicast shared code. 1189 * It feeds the shared code routine the addresses in the 1190 * array of ixv_set_multi() one by one. 1191 ************************************************************************/ 1192 static u8 * 1193 ixv_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 1194 { 1195 u8 *addr = *update_ptr; 1196 u8 *newptr; 1197 1198 *vmdq = 0; 1199 1200 newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS; 1201 *update_ptr = newptr; 1202 1203 return addr; 1204 } /* ixv_mc_array_itr */ 1205 1206 /************************************************************************ 1207 * ixv_local_timer - Timer routine 1208 * 1209 * Checks for link status, updates statistics, 1210 * and runs the watchdog check. 1211 ************************************************************************/ 1212 static void 1213 ixv_local_timer(void *arg) 1214 { 1215 struct adapter *adapter = arg; 1216 1217 IXGBE_CORE_LOCK(adapter); 1218 ixv_local_timer_locked(adapter); 1219 IXGBE_CORE_UNLOCK(adapter); 1220 } 1221 1222 static void 1223 ixv_local_timer_locked(void *arg) 1224 { 1225 struct adapter *adapter = arg; 1226 device_t dev = adapter->dev; 1227 struct ix_queue *que = adapter->queues; 1228 u64 queues = 0; 1229 u64 v0, v1, v2, v3, v4, v5, v6, v7; 1230 int hung = 0; 1231 int i; 1232 1233 KASSERT(mutex_owned(&adapter->core_mtx)); 1234 1235 if (ixv_check_link(adapter)) { 1236 ixv_init_locked(adapter); 1237 return; 1238 } 1239 1240 /* Stats Update */ 1241 ixv_update_stats(adapter); 1242 1243 /* Update some event counters */ 1244 v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0; 1245 que = adapter->queues; 1246 for (i = 0; i < adapter->num_queues; i++, que++) { 1247 struct tx_ring *txr = que->txr; 1248 1249 v0 += txr->q_efbig_tx_dma_setup; 1250 v1 += txr->q_mbuf_defrag_failed; 1251 v2 += txr->q_efbig2_tx_dma_setup; 1252 v3 += txr->q_einval_tx_dma_setup; 1253 v4 += txr->q_other_tx_dma_setup; 1254 v5 += txr->q_eagain_tx_dma_setup; 1255 v6 += txr->q_enomem_tx_dma_setup; 1256 v7 += txr->q_tso_err; 1257 } 1258 adapter->efbig_tx_dma_setup.ev_count = v0; 1259 adapter->mbuf_defrag_failed.ev_count = v1; 1260 adapter->efbig2_tx_dma_setup.ev_count = v2; 1261 adapter->einval_tx_dma_setup.ev_count = v3; 1262 adapter->other_tx_dma_setup.ev_count = v4; 1263 adapter->eagain_tx_dma_setup.ev_count = v5; 1264 adapter->enomem_tx_dma_setup.ev_count = v6; 1265 adapter->tso_err.ev_count = v7; 1266 1267 /* 1268 * Check the TX queues status 1269 * - mark hung queues so we don't schedule on them 1270 * - watchdog only if all queues show hung 1271 */ 1272 que = adapter->queues; 1273 for (i = 0; i < adapter->num_queues; i++, que++) { 1274 /* Keep track of queues with work for soft irq */ 1275 if (que->txr->busy) 1276 queues |= ((u64)1 << que->me); 1277 /* 1278 * Each time txeof runs without cleaning, but there 1279 * are uncleaned descriptors it increments busy. If 1280 * we get to the MAX we declare it hung. 1281 */ 1282 if (que->busy == IXGBE_QUEUE_HUNG) { 1283 ++hung; 1284 /* Mark the queue as inactive */ 1285 adapter->active_queues &= ~((u64)1 << que->me); 1286 continue; 1287 } else { 1288 /* Check if we've come back from hung */ 1289 if ((adapter->active_queues & ((u64)1 << que->me)) == 0) 1290 adapter->active_queues |= ((u64)1 << que->me); 1291 } 1292 if (que->busy >= IXGBE_MAX_TX_BUSY) { 1293 device_printf(dev, 1294 "Warning queue %d appears to be hung!\n", i); 1295 que->txr->busy = IXGBE_QUEUE_HUNG; 1296 ++hung; 1297 } 1298 } 1299 1300 /* Only truly watchdog if all queues show hung */ 1301 if (hung == adapter->num_queues) 1302 goto watchdog; 1303 #if 0 1304 else if (queues != 0) { /* Force an IRQ on queues with work */ 1305 ixv_rearm_queues(adapter, queues); 1306 } 1307 #endif 1308 1309 callout_reset(&adapter->timer, hz, ixv_local_timer, adapter); 1310 1311 return; 1312 1313 watchdog: 1314 1315 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 1316 adapter->ifp->if_flags &= ~IFF_RUNNING; 1317 adapter->watchdog_events.ev_count++; 1318 ixv_init_locked(adapter); 1319 } /* ixv_local_timer */ 1320 1321 /************************************************************************ 1322 * ixv_update_link_status - Update OS on link state 1323 * 1324 * Note: Only updates the OS on the cached link state. 1325 * The real check of the hardware only happens with 1326 * a link interrupt. 1327 ************************************************************************/ 1328 static void 1329 ixv_update_link_status(struct adapter *adapter) 1330 { 1331 struct ifnet *ifp = adapter->ifp; 1332 device_t dev = adapter->dev; 1333 1334 KASSERT(mutex_owned(&adapter->core_mtx)); 1335 1336 if (adapter->link_up) { 1337 if (adapter->link_active != LINK_STATE_UP) { 1338 if (bootverbose) { 1339 const char *bpsmsg; 1340 1341 switch (adapter->link_speed) { 1342 case IXGBE_LINK_SPEED_10GB_FULL: 1343 bpsmsg = "10 Gbps"; 1344 break; 1345 case IXGBE_LINK_SPEED_5GB_FULL: 1346 bpsmsg = "5 Gbps"; 1347 break; 1348 case IXGBE_LINK_SPEED_2_5GB_FULL: 1349 bpsmsg = "2.5 Gbps"; 1350 break; 1351 case IXGBE_LINK_SPEED_1GB_FULL: 1352 bpsmsg = "1 Gbps"; 1353 break; 1354 case IXGBE_LINK_SPEED_100_FULL: 1355 bpsmsg = "100 Mbps"; 1356 break; 1357 case IXGBE_LINK_SPEED_10_FULL: 1358 bpsmsg = "10 Mbps"; 1359 break; 1360 default: 1361 bpsmsg = "unknown speed"; 1362 break; 1363 } 1364 device_printf(dev, "Link is up %s %s \n", 1365 bpsmsg, "Full Duplex"); 1366 } 1367 adapter->link_active = LINK_STATE_UP; 1368 if_link_state_change(ifp, LINK_STATE_UP); 1369 } 1370 } else { 1371 /* 1372 * Do it when link active changes to DOWN. i.e. 1373 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN 1374 * b) LINK_STATE_UP -> LINK_STATE_DOWN 1375 */ 1376 if (adapter->link_active != LINK_STATE_DOWN) { 1377 if (bootverbose) 1378 device_printf(dev, "Link is Down\n"); 1379 if_link_state_change(ifp, LINK_STATE_DOWN); 1380 adapter->link_active = LINK_STATE_DOWN; 1381 } 1382 } 1383 } /* ixv_update_link_status */ 1384 1385 1386 /************************************************************************ 1387 * ixv_stop - Stop the hardware 1388 * 1389 * Disables all traffic on the adapter by issuing a 1390 * global reset on the MAC and deallocates TX/RX buffers. 1391 ************************************************************************/ 1392 static void 1393 ixv_ifstop(struct ifnet *ifp, int disable) 1394 { 1395 struct adapter *adapter = ifp->if_softc; 1396 1397 IXGBE_CORE_LOCK(adapter); 1398 ixv_stop(adapter); 1399 IXGBE_CORE_UNLOCK(adapter); 1400 } 1401 1402 static void 1403 ixv_stop(void *arg) 1404 { 1405 struct ifnet *ifp; 1406 struct adapter *adapter = arg; 1407 struct ixgbe_hw *hw = &adapter->hw; 1408 1409 ifp = adapter->ifp; 1410 1411 KASSERT(mutex_owned(&adapter->core_mtx)); 1412 1413 INIT_DEBUGOUT("ixv_stop: begin\n"); 1414 ixv_disable_intr(adapter); 1415 1416 /* Tell the stack that the interface is no longer active */ 1417 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1418 1419 hw->mac.ops.reset_hw(hw); 1420 adapter->hw.adapter_stopped = FALSE; 1421 hw->mac.ops.stop_adapter(hw); 1422 callout_stop(&adapter->timer); 1423 1424 /* reprogram the RAR[0] in case user changed it. */ 1425 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 1426 1427 return; 1428 } /* ixv_stop */ 1429 1430 1431 /************************************************************************ 1432 * ixv_allocate_pci_resources 1433 ************************************************************************/ 1434 static int 1435 ixv_allocate_pci_resources(struct adapter *adapter, 1436 const struct pci_attach_args *pa) 1437 { 1438 pcireg_t memtype, csr; 1439 device_t dev = adapter->dev; 1440 bus_addr_t addr; 1441 int flags; 1442 1443 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 1444 switch (memtype) { 1445 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 1446 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 1447 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 1448 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 1449 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 1450 goto map_err; 1451 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 1452 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 1453 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 1454 } 1455 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 1456 adapter->osdep.mem_size, flags, 1457 &adapter->osdep.mem_bus_space_handle) != 0) { 1458 map_err: 1459 adapter->osdep.mem_size = 0; 1460 aprint_error_dev(dev, "unable to map BAR0\n"); 1461 return ENXIO; 1462 } 1463 /* 1464 * Enable address decoding for memory range in case it's not 1465 * set. 1466 */ 1467 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, 1468 PCI_COMMAND_STATUS_REG); 1469 csr |= PCI_COMMAND_MEM_ENABLE; 1470 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 1471 csr); 1472 break; 1473 default: 1474 aprint_error_dev(dev, "unexpected type on BAR0\n"); 1475 return ENXIO; 1476 } 1477 1478 /* Pick up the tuneable queues */ 1479 adapter->num_queues = ixv_num_queues; 1480 1481 return (0); 1482 } /* ixv_allocate_pci_resources */ 1483 1484 /************************************************************************ 1485 * ixv_free_pci_resources 1486 ************************************************************************/ 1487 static void 1488 ixv_free_pci_resources(struct adapter * adapter) 1489 { 1490 struct ix_queue *que = adapter->queues; 1491 int rid; 1492 1493 /* 1494 * Release all msix queue resources: 1495 */ 1496 for (int i = 0; i < adapter->num_queues; i++, que++) { 1497 if (que->res != NULL) 1498 pci_intr_disestablish(adapter->osdep.pc, 1499 adapter->osdep.ihs[i]); 1500 } 1501 1502 1503 /* Clean the Mailbox interrupt last */ 1504 rid = adapter->vector; 1505 1506 if (adapter->osdep.ihs[rid] != NULL) { 1507 pci_intr_disestablish(adapter->osdep.pc, 1508 adapter->osdep.ihs[rid]); 1509 adapter->osdep.ihs[rid] = NULL; 1510 } 1511 1512 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1513 adapter->osdep.nintrs); 1514 1515 if (adapter->osdep.mem_size != 0) { 1516 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 1517 adapter->osdep.mem_bus_space_handle, 1518 adapter->osdep.mem_size); 1519 } 1520 1521 return; 1522 } /* ixv_free_pci_resources */ 1523 1524 /************************************************************************ 1525 * ixv_setup_interface 1526 * 1527 * Setup networking device structure and register an interface. 1528 ************************************************************************/ 1529 static int 1530 ixv_setup_interface(device_t dev, struct adapter *adapter) 1531 { 1532 struct ethercom *ec = &adapter->osdep.ec; 1533 struct ifnet *ifp; 1534 int rv; 1535 1536 INIT_DEBUGOUT("ixv_setup_interface: begin"); 1537 1538 ifp = adapter->ifp = &ec->ec_if; 1539 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 1540 ifp->if_baudrate = IF_Gbps(10); 1541 ifp->if_init = ixv_init; 1542 ifp->if_stop = ixv_ifstop; 1543 ifp->if_softc = adapter; 1544 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1545 #ifdef IXGBE_MPSAFE 1546 ifp->if_extflags = IFEF_MPSAFE; 1547 #endif 1548 ifp->if_ioctl = ixv_ioctl; 1549 if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) { 1550 #if 0 1551 ixv_start_locked = ixgbe_legacy_start_locked; 1552 #endif 1553 } else { 1554 ifp->if_transmit = ixgbe_mq_start; 1555 #if 0 1556 ixv_start_locked = ixgbe_mq_start_locked; 1557 #endif 1558 } 1559 ifp->if_start = ixgbe_legacy_start; 1560 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 1561 IFQ_SET_READY(&ifp->if_snd); 1562 1563 rv = if_initialize(ifp); 1564 if (rv != 0) { 1565 aprint_error_dev(dev, "if_initialize failed(%d)\n", rv); 1566 return rv; 1567 } 1568 adapter->ipq = if_percpuq_create(&adapter->osdep.ec.ec_if); 1569 ether_ifattach(ifp, adapter->hw.mac.addr); 1570 /* 1571 * We use per TX queue softint, so if_deferred_start_init() isn't 1572 * used. 1573 */ 1574 ether_set_ifflags_cb(ec, ixv_ifflags_cb); 1575 1576 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR; 1577 1578 /* 1579 * Tell the upper layer(s) we support long frames. 1580 */ 1581 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 1582 1583 /* Set capability flags */ 1584 ifp->if_capabilities |= IFCAP_HWCSUM 1585 | IFCAP_TSOv4 1586 | IFCAP_TSOv6; 1587 ifp->if_capenable = 0; 1588 1589 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER 1590 | ETHERCAP_VLAN_HWTAGGING 1591 | ETHERCAP_VLAN_HWCSUM 1592 | ETHERCAP_JUMBO_MTU 1593 | ETHERCAP_VLAN_MTU; 1594 1595 /* Enable the above capabilities by default */ 1596 ec->ec_capenable = ec->ec_capabilities; 1597 1598 /* Don't enable LRO by default */ 1599 #if 0 1600 /* NetBSD doesn't support LRO yet */ 1601 ifp->if_capabilities |= IFCAP_LRO; 1602 #endif 1603 1604 /* 1605 * Specify the media types supported by this adapter and register 1606 * callbacks to update media and link information 1607 */ 1608 ec->ec_ifmedia = &adapter->media; 1609 ifmedia_init(&adapter->media, IFM_IMASK, ixv_media_change, 1610 ixv_media_status); 1611 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1612 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1613 1614 if_register(ifp); 1615 1616 return 0; 1617 } /* ixv_setup_interface */ 1618 1619 1620 /************************************************************************ 1621 * ixv_initialize_transmit_units - Enable transmit unit. 1622 ************************************************************************/ 1623 static void 1624 ixv_initialize_transmit_units(struct adapter *adapter) 1625 { 1626 struct tx_ring *txr = adapter->tx_rings; 1627 struct ixgbe_hw *hw = &adapter->hw; 1628 int i; 1629 1630 for (i = 0; i < adapter->num_queues; i++, txr++) { 1631 u64 tdba = txr->txdma.dma_paddr; 1632 u32 txctrl, txdctl; 1633 int j = txr->me; 1634 1635 /* Set WTHRESH to 8, burst writeback */ 1636 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1637 txdctl |= (8 << 16); 1638 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1639 1640 /* Set the HW Tx Head and Tail indices */ 1641 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(j), 0); 1642 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(j), 0); 1643 1644 /* Set Tx Tail register */ 1645 txr->tail = IXGBE_VFTDT(j); 1646 1647 txr->txr_no_space = false; 1648 1649 /* Set Ring parameters */ 1650 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j), 1651 (tdba & 0x00000000ffffffffULL)); 1652 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32)); 1653 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j), 1654 adapter->num_tx_desc * sizeof(struct ixgbe_legacy_tx_desc)); 1655 txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j)); 1656 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 1657 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl); 1658 1659 /* Now enable */ 1660 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1661 txdctl |= IXGBE_TXDCTL_ENABLE; 1662 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1663 } 1664 1665 return; 1666 } /* ixv_initialize_transmit_units */ 1667 1668 1669 /************************************************************************ 1670 * ixv_initialize_rss_mapping 1671 ************************************************************************/ 1672 static void 1673 ixv_initialize_rss_mapping(struct adapter *adapter) 1674 { 1675 struct ixgbe_hw *hw = &adapter->hw; 1676 u32 reta = 0, mrqc, rss_key[10]; 1677 int queue_id; 1678 int i, j; 1679 u32 rss_hash_config; 1680 1681 /* force use default RSS key. */ 1682 #ifdef __NetBSD__ 1683 rss_getkey((uint8_t *) &rss_key); 1684 #else 1685 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1686 /* Fetch the configured RSS key */ 1687 rss_getkey((uint8_t *)&rss_key); 1688 } else { 1689 /* set up random bits */ 1690 cprng_fast(&rss_key, sizeof(rss_key)); 1691 } 1692 #endif 1693 1694 /* Now fill out hash function seeds */ 1695 for (i = 0; i < 10; i++) 1696 IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]); 1697 1698 /* Set up the redirection table */ 1699 for (i = 0, j = 0; i < 64; i++, j++) { 1700 if (j == adapter->num_queues) 1701 j = 0; 1702 1703 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1704 /* 1705 * Fetch the RSS bucket id for the given indirection 1706 * entry. Cap it at the number of configured buckets 1707 * (which is num_queues.) 1708 */ 1709 queue_id = rss_get_indirection_to_bucket(i); 1710 queue_id = queue_id % adapter->num_queues; 1711 } else 1712 queue_id = j; 1713 1714 /* 1715 * The low 8 bits are for hash value (n+0); 1716 * The next 8 bits are for hash value (n+1), etc. 1717 */ 1718 reta >>= 8; 1719 reta |= ((uint32_t)queue_id) << 24; 1720 if ((i & 3) == 3) { 1721 IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), reta); 1722 reta = 0; 1723 } 1724 } 1725 1726 /* Perform hash on these packet types */ 1727 if (adapter->feat_en & IXGBE_FEATURE_RSS) 1728 rss_hash_config = rss_gethashconfig(); 1729 else { 1730 /* 1731 * Disable UDP - IP fragments aren't currently being handled 1732 * and so we end up with a mix of 2-tuple and 4-tuple 1733 * traffic. 1734 */ 1735 rss_hash_config = RSS_HASHTYPE_RSS_IPV4 1736 | RSS_HASHTYPE_RSS_TCP_IPV4 1737 | RSS_HASHTYPE_RSS_IPV6 1738 | RSS_HASHTYPE_RSS_TCP_IPV6; 1739 } 1740 1741 mrqc = IXGBE_MRQC_RSSEN; 1742 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 1743 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 1744 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 1745 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 1746 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 1747 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 1748 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 1749 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 1750 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 1751 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_IPV6_EX defined, but not supported\n", 1752 __func__); 1753 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 1754 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_TCP_IPV6_EX defined, but not supported\n", 1755 __func__); 1756 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 1757 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 1758 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 1759 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 1760 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 1761 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_UDP_IPV6_EX defined, but not supported\n", 1762 __func__); 1763 IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, mrqc); 1764 } /* ixv_initialize_rss_mapping */ 1765 1766 1767 /************************************************************************ 1768 * ixv_initialize_receive_units - Setup receive registers and features. 1769 ************************************************************************/ 1770 static void 1771 ixv_initialize_receive_units(struct adapter *adapter) 1772 { 1773 struct rx_ring *rxr = adapter->rx_rings; 1774 struct ixgbe_hw *hw = &adapter->hw; 1775 struct ifnet *ifp = adapter->ifp; 1776 u32 bufsz, psrtype; 1777 1778 if (ifp->if_mtu > ETHERMTU) 1779 bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1780 else 1781 bufsz = 2048 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1782 1783 psrtype = IXGBE_PSRTYPE_TCPHDR 1784 | IXGBE_PSRTYPE_UDPHDR 1785 | IXGBE_PSRTYPE_IPV4HDR 1786 | IXGBE_PSRTYPE_IPV6HDR 1787 | IXGBE_PSRTYPE_L2HDR; 1788 1789 if (adapter->num_queues > 1) 1790 psrtype |= 1 << 29; 1791 1792 IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype); 1793 1794 /* Tell PF our max_frame size */ 1795 if (ixgbevf_rlpml_set_vf(hw, adapter->max_frame_size) != 0) { 1796 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"); 1797 } 1798 1799 for (int i = 0; i < adapter->num_queues; i++, rxr++) { 1800 u64 rdba = rxr->rxdma.dma_paddr; 1801 u32 reg, rxdctl; 1802 int j = rxr->me; 1803 1804 /* Disable the queue */ 1805 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)); 1806 rxdctl &= ~IXGBE_RXDCTL_ENABLE; 1807 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1808 for (int k = 0; k < 10; k++) { 1809 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1810 IXGBE_RXDCTL_ENABLE) 1811 msec_delay(1); 1812 else 1813 break; 1814 } 1815 wmb(); 1816 /* Setup the Base and Length of the Rx Descriptor Ring */ 1817 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j), 1818 (rdba & 0x00000000ffffffffULL)); 1819 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32)); 1820 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j), 1821 adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc)); 1822 1823 /* Reset the ring indices */ 1824 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0); 1825 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0); 1826 1827 /* Set up the SRRCTL register */ 1828 reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j)); 1829 reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 1830 reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 1831 reg |= bufsz; 1832 reg |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 1833 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg); 1834 1835 /* Capture Rx Tail index */ 1836 rxr->tail = IXGBE_VFRDT(rxr->me); 1837 1838 /* Do the queue enabling last */ 1839 rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME; 1840 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1841 for (int k = 0; k < 10; k++) { 1842 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1843 IXGBE_RXDCTL_ENABLE) 1844 break; 1845 msec_delay(1); 1846 } 1847 wmb(); 1848 1849 /* Set the Tail Pointer */ 1850 #ifdef DEV_NETMAP 1851 /* 1852 * In netmap mode, we must preserve the buffers made 1853 * available to userspace before the if_init() 1854 * (this is true by default on the TX side, because 1855 * init makes all buffers available to userspace). 1856 * 1857 * netmap_reset() and the device specific routines 1858 * (e.g. ixgbe_setup_receive_rings()) map these 1859 * buffers at the end of the NIC ring, so here we 1860 * must set the RDT (tail) register to make sure 1861 * they are not overwritten. 1862 * 1863 * In this driver the NIC ring starts at RDH = 0, 1864 * RDT points to the last slot available for reception (?), 1865 * so RDT = num_rx_desc - 1 means the whole ring is available. 1866 */ 1867 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 1868 (ifp->if_capenable & IFCAP_NETMAP)) { 1869 struct netmap_adapter *na = NA(adapter->ifp); 1870 struct netmap_kring *kring = na->rx_rings[i]; 1871 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 1872 1873 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t); 1874 } else 1875 #endif /* DEV_NETMAP */ 1876 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 1877 adapter->num_rx_desc - 1); 1878 } 1879 1880 ixv_initialize_rss_mapping(adapter); 1881 } /* ixv_initialize_receive_units */ 1882 1883 /************************************************************************ 1884 * ixv_sysctl_tdh_handler - Transmit Descriptor Head handler function 1885 * 1886 * Retrieves the TDH value from the hardware 1887 ************************************************************************/ 1888 static int 1889 ixv_sysctl_tdh_handler(SYSCTLFN_ARGS) 1890 { 1891 struct sysctlnode node = *rnode; 1892 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 1893 uint32_t val; 1894 1895 if (!txr) 1896 return (0); 1897 1898 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_VFTDH(txr->me)); 1899 node.sysctl_data = &val; 1900 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1901 } /* ixv_sysctl_tdh_handler */ 1902 1903 /************************************************************************ 1904 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 1905 * 1906 * Retrieves the TDT value from the hardware 1907 ************************************************************************/ 1908 static int 1909 ixv_sysctl_tdt_handler(SYSCTLFN_ARGS) 1910 { 1911 struct sysctlnode node = *rnode; 1912 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 1913 uint32_t val; 1914 1915 if (!txr) 1916 return (0); 1917 1918 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_VFTDT(txr->me)); 1919 node.sysctl_data = &val; 1920 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1921 } /* ixv_sysctl_tdt_handler */ 1922 1923 /************************************************************************ 1924 * ixv_sysctl_next_to_check_handler - Receive Descriptor next to check 1925 * handler function 1926 * 1927 * Retrieves the next_to_check value 1928 ************************************************************************/ 1929 static int 1930 ixv_sysctl_next_to_check_handler(SYSCTLFN_ARGS) 1931 { 1932 struct sysctlnode node = *rnode; 1933 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 1934 uint32_t val; 1935 1936 if (!rxr) 1937 return (0); 1938 1939 val = rxr->next_to_check; 1940 node.sysctl_data = &val; 1941 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1942 } /* ixv_sysctl_next_to_check_handler */ 1943 1944 /************************************************************************ 1945 * ixv_sysctl_rdh_handler - Receive Descriptor Head handler function 1946 * 1947 * Retrieves the RDH value from the hardware 1948 ************************************************************************/ 1949 static int 1950 ixv_sysctl_rdh_handler(SYSCTLFN_ARGS) 1951 { 1952 struct sysctlnode node = *rnode; 1953 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 1954 uint32_t val; 1955 1956 if (!rxr) 1957 return (0); 1958 1959 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_VFRDH(rxr->me)); 1960 node.sysctl_data = &val; 1961 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1962 } /* ixv_sysctl_rdh_handler */ 1963 1964 /************************************************************************ 1965 * ixv_sysctl_rdt_handler - Receive Descriptor Tail handler function 1966 * 1967 * Retrieves the RDT value from the hardware 1968 ************************************************************************/ 1969 static int 1970 ixv_sysctl_rdt_handler(SYSCTLFN_ARGS) 1971 { 1972 struct sysctlnode node = *rnode; 1973 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 1974 uint32_t val; 1975 1976 if (!rxr) 1977 return (0); 1978 1979 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_VFRDT(rxr->me)); 1980 node.sysctl_data = &val; 1981 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1982 } /* ixv_sysctl_rdt_handler */ 1983 1984 static void 1985 ixv_setup_vlan_tagging(struct adapter *adapter) 1986 { 1987 struct ethercom *ec = &adapter->osdep.ec; 1988 struct ixgbe_hw *hw = &adapter->hw; 1989 struct rx_ring *rxr; 1990 u32 ctrl; 1991 int i; 1992 bool hwtagging; 1993 1994 /* Enable HW tagging only if any vlan is attached */ 1995 hwtagging = (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) 1996 && VLAN_ATTACHED(ec); 1997 1998 /* Enable the queues */ 1999 for (i = 0; i < adapter->num_queues; i++) { 2000 rxr = &adapter->rx_rings[i]; 2001 ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(rxr->me)); 2002 if (hwtagging) 2003 ctrl |= IXGBE_RXDCTL_VME; 2004 else 2005 ctrl &= ~IXGBE_RXDCTL_VME; 2006 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(rxr->me), ctrl); 2007 /* 2008 * Let Rx path know that it needs to store VLAN tag 2009 * as part of extra mbuf info. 2010 */ 2011 rxr->vtag_strip = hwtagging ? TRUE : FALSE; 2012 } 2013 } /* ixv_setup_vlan_tagging */ 2014 2015 /************************************************************************ 2016 * ixv_setup_vlan_support 2017 ************************************************************************/ 2018 static int 2019 ixv_setup_vlan_support(struct adapter *adapter) 2020 { 2021 struct ethercom *ec = &adapter->osdep.ec; 2022 struct ixgbe_hw *hw = &adapter->hw; 2023 u32 vid, vfta, retry; 2024 struct vlanid_list *vlanidp; 2025 int rv, error = 0; 2026 2027 /* 2028 * This function is called from both if_init and ifflags_cb() 2029 * on NetBSD. 2030 */ 2031 2032 /* 2033 * Part 1: 2034 * Setup VLAN HW tagging 2035 */ 2036 ixv_setup_vlan_tagging(adapter); 2037 2038 if (!VLAN_ATTACHED(ec)) 2039 return 0; 2040 2041 /* 2042 * Part 2: 2043 * Setup VLAN HW filter 2044 */ 2045 /* Cleanup shadow_vfta */ 2046 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) 2047 adapter->shadow_vfta[i] = 0; 2048 /* Generate shadow_vfta from ec_vids */ 2049 ETHER_LOCK(ec); 2050 SIMPLEQ_FOREACH(vlanidp, &ec->ec_vids, vid_list) { 2051 uint32_t idx; 2052 2053 idx = vlanidp->vid / 32; 2054 KASSERT(idx < IXGBE_VFTA_SIZE); 2055 adapter->shadow_vfta[idx] |= (u32)1 << (vlanidp->vid % 32); 2056 } 2057 ETHER_UNLOCK(ec); 2058 2059 /* 2060 * A soft reset zero's out the VFTA, so 2061 * we need to repopulate it now. 2062 */ 2063 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) { 2064 if (adapter->shadow_vfta[i] == 0) 2065 continue; 2066 vfta = adapter->shadow_vfta[i]; 2067 /* 2068 * Reconstruct the vlan id's 2069 * based on the bits set in each 2070 * of the array ints. 2071 */ 2072 for (int j = 0; j < 32; j++) { 2073 retry = 0; 2074 if ((vfta & ((u32)1 << j)) == 0) 2075 continue; 2076 vid = (i * 32) + j; 2077 2078 /* Call the shared code mailbox routine */ 2079 while ((rv = hw->mac.ops.set_vfta(hw, vid, 0, TRUE, 2080 FALSE)) != 0) { 2081 if (++retry > 5) { 2082 device_printf(adapter->dev, 2083 "%s: max retry exceeded\n", 2084 __func__); 2085 break; 2086 } 2087 } 2088 if (rv != 0) { 2089 device_printf(adapter->dev, 2090 "failed to set vlan %d\n", vid); 2091 error = EACCES; 2092 } 2093 } 2094 } 2095 return error; 2096 } /* ixv_setup_vlan_support */ 2097 2098 static int 2099 ixv_vlan_cb(struct ethercom *ec, uint16_t vid, bool set) 2100 { 2101 struct ifnet *ifp = &ec->ec_if; 2102 struct adapter *adapter = ifp->if_softc; 2103 int rv; 2104 2105 if (set) 2106 rv = ixv_register_vlan(adapter, vid); 2107 else 2108 rv = ixv_unregister_vlan(adapter, vid); 2109 2110 if (rv != 0) 2111 return rv; 2112 2113 /* 2114 * Control VLAN HW tagging when ec_nvlan is changed from 1 to 0 2115 * or 0 to 1. 2116 */ 2117 if ((set && (ec->ec_nvlans == 1)) || (!set && (ec->ec_nvlans == 0))) 2118 ixv_setup_vlan_tagging(adapter); 2119 2120 return rv; 2121 } 2122 2123 /************************************************************************ 2124 * ixv_register_vlan 2125 * 2126 * Run via a vlan config EVENT, it enables us to use the 2127 * HW Filter table since we can get the vlan id. This just 2128 * creates the entry in the soft version of the VFTA, init 2129 * will repopulate the real table. 2130 ************************************************************************/ 2131 static int 2132 ixv_register_vlan(struct adapter *adapter, u16 vtag) 2133 { 2134 struct ixgbe_hw *hw = &adapter->hw; 2135 u16 index, bit; 2136 int error; 2137 2138 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2139 return EINVAL; 2140 IXGBE_CORE_LOCK(adapter); 2141 index = (vtag >> 5) & 0x7F; 2142 bit = vtag & 0x1F; 2143 adapter->shadow_vfta[index] |= ((u32)1 << bit); 2144 error = hw->mac.ops.set_vfta(hw, vtag, 0, true, false); 2145 IXGBE_CORE_UNLOCK(adapter); 2146 2147 if (error != 0) { 2148 device_printf(adapter->dev, "failed to register vlan %hu\n", 2149 vtag); 2150 error = EACCES; 2151 } 2152 return error; 2153 } /* ixv_register_vlan */ 2154 2155 /************************************************************************ 2156 * ixv_unregister_vlan 2157 * 2158 * Run via a vlan unconfig EVENT, remove our entry 2159 * in the soft vfta. 2160 ************************************************************************/ 2161 static int 2162 ixv_unregister_vlan(struct adapter *adapter, u16 vtag) 2163 { 2164 struct ixgbe_hw *hw = &adapter->hw; 2165 u16 index, bit; 2166 int error; 2167 2168 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2169 return EINVAL; 2170 2171 IXGBE_CORE_LOCK(adapter); 2172 index = (vtag >> 5) & 0x7F; 2173 bit = vtag & 0x1F; 2174 adapter->shadow_vfta[index] &= ~((u32)1 << bit); 2175 error = hw->mac.ops.set_vfta(hw, vtag, 0, false, false); 2176 IXGBE_CORE_UNLOCK(adapter); 2177 2178 if (error != 0) { 2179 device_printf(adapter->dev, "failed to unregister vlan %hu\n", 2180 vtag); 2181 error = EIO; 2182 } 2183 return error; 2184 } /* ixv_unregister_vlan */ 2185 2186 /************************************************************************ 2187 * ixv_enable_intr 2188 ************************************************************************/ 2189 static void 2190 ixv_enable_intr(struct adapter *adapter) 2191 { 2192 struct ixgbe_hw *hw = &adapter->hw; 2193 struct ix_queue *que = adapter->queues; 2194 u32 mask; 2195 int i; 2196 2197 /* For VTEIAC */ 2198 mask = (1 << adapter->vector); 2199 for (i = 0; i < adapter->num_queues; i++, que++) 2200 mask |= (1 << que->msix); 2201 IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask); 2202 2203 /* For VTEIMS */ 2204 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, (1 << adapter->vector)); 2205 que = adapter->queues; 2206 for (i = 0; i < adapter->num_queues; i++, que++) 2207 ixv_enable_queue(adapter, que->msix); 2208 2209 IXGBE_WRITE_FLUSH(hw); 2210 } /* ixv_enable_intr */ 2211 2212 /************************************************************************ 2213 * ixv_disable_intr 2214 ************************************************************************/ 2215 static void 2216 ixv_disable_intr(struct adapter *adapter) 2217 { 2218 struct ix_queue *que = adapter->queues; 2219 2220 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIAC, 0); 2221 2222 /* disable interrupts other than queues */ 2223 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIMC, adapter->vector); 2224 2225 for (int i = 0; i < adapter->num_queues; i++, que++) 2226 ixv_disable_queue(adapter, que->msix); 2227 2228 IXGBE_WRITE_FLUSH(&adapter->hw); 2229 } /* ixv_disable_intr */ 2230 2231 /************************************************************************ 2232 * ixv_set_ivar 2233 * 2234 * Setup the correct IVAR register for a particular MSI-X interrupt 2235 * - entry is the register array entry 2236 * - vector is the MSI-X vector for this queue 2237 * - type is RX/TX/MISC 2238 ************************************************************************/ 2239 static void 2240 ixv_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 2241 { 2242 struct ixgbe_hw *hw = &adapter->hw; 2243 u32 ivar, index; 2244 2245 vector |= IXGBE_IVAR_ALLOC_VAL; 2246 2247 if (type == -1) { /* MISC IVAR */ 2248 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); 2249 ivar &= ~0xFF; 2250 ivar |= vector; 2251 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar); 2252 } else { /* RX/TX IVARS */ 2253 index = (16 * (entry & 1)) + (8 * type); 2254 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(entry >> 1)); 2255 ivar &= ~(0xffUL << index); 2256 ivar |= ((u32)vector << index); 2257 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(entry >> 1), ivar); 2258 } 2259 } /* ixv_set_ivar */ 2260 2261 /************************************************************************ 2262 * ixv_configure_ivars 2263 ************************************************************************/ 2264 static void 2265 ixv_configure_ivars(struct adapter *adapter) 2266 { 2267 struct ix_queue *que = adapter->queues; 2268 2269 /* XXX We should sync EITR value calculation with ixgbe.c? */ 2270 2271 for (int i = 0; i < adapter->num_queues; i++, que++) { 2272 /* First the RX queue entry */ 2273 ixv_set_ivar(adapter, i, que->msix, 0); 2274 /* ... and the TX */ 2275 ixv_set_ivar(adapter, i, que->msix, 1); 2276 /* Set an initial value in EITR */ 2277 ixv_eitr_write(adapter, que->msix, IXGBE_EITR_DEFAULT); 2278 } 2279 2280 /* For the mailbox interrupt */ 2281 ixv_set_ivar(adapter, 1, adapter->vector, -1); 2282 } /* ixv_configure_ivars */ 2283 2284 2285 /************************************************************************ 2286 * ixv_save_stats 2287 * 2288 * The VF stats registers never have a truly virgin 2289 * starting point, so this routine tries to make an 2290 * artificial one, marking ground zero on attach as 2291 * it were. 2292 ************************************************************************/ 2293 static void 2294 ixv_save_stats(struct adapter *adapter) 2295 { 2296 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2297 2298 if (stats->vfgprc.ev_count || stats->vfgptc.ev_count) { 2299 stats->saved_reset_vfgprc += 2300 stats->vfgprc.ev_count - stats->base_vfgprc; 2301 stats->saved_reset_vfgptc += 2302 stats->vfgptc.ev_count - stats->base_vfgptc; 2303 stats->saved_reset_vfgorc += 2304 stats->vfgorc.ev_count - stats->base_vfgorc; 2305 stats->saved_reset_vfgotc += 2306 stats->vfgotc.ev_count - stats->base_vfgotc; 2307 stats->saved_reset_vfmprc += 2308 stats->vfmprc.ev_count - stats->base_vfmprc; 2309 } 2310 } /* ixv_save_stats */ 2311 2312 /************************************************************************ 2313 * ixv_init_stats 2314 ************************************************************************/ 2315 static void 2316 ixv_init_stats(struct adapter *adapter) 2317 { 2318 struct ixgbe_hw *hw = &adapter->hw; 2319 2320 adapter->stats.vf.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC); 2321 adapter->stats.vf.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB); 2322 adapter->stats.vf.last_vfgorc |= 2323 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32); 2324 2325 adapter->stats.vf.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC); 2326 adapter->stats.vf.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB); 2327 adapter->stats.vf.last_vfgotc |= 2328 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32); 2329 2330 adapter->stats.vf.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC); 2331 2332 adapter->stats.vf.base_vfgprc = adapter->stats.vf.last_vfgprc; 2333 adapter->stats.vf.base_vfgorc = adapter->stats.vf.last_vfgorc; 2334 adapter->stats.vf.base_vfgptc = adapter->stats.vf.last_vfgptc; 2335 adapter->stats.vf.base_vfgotc = adapter->stats.vf.last_vfgotc; 2336 adapter->stats.vf.base_vfmprc = adapter->stats.vf.last_vfmprc; 2337 } /* ixv_init_stats */ 2338 2339 #define UPDATE_STAT_32(reg, last, count) \ 2340 { \ 2341 u32 current = IXGBE_READ_REG(hw, (reg)); \ 2342 if (current < (last)) \ 2343 count.ev_count += 0x100000000LL; \ 2344 (last) = current; \ 2345 count.ev_count &= 0xFFFFFFFF00000000LL; \ 2346 count.ev_count |= current; \ 2347 } 2348 2349 #define UPDATE_STAT_36(lsb, msb, last, count) \ 2350 { \ 2351 u64 cur_lsb = IXGBE_READ_REG(hw, (lsb)); \ 2352 u64 cur_msb = IXGBE_READ_REG(hw, (msb)); \ 2353 u64 current = ((cur_msb << 32) | cur_lsb); \ 2354 if (current < (last)) \ 2355 count.ev_count += 0x1000000000LL; \ 2356 (last) = current; \ 2357 count.ev_count &= 0xFFFFFFF000000000LL; \ 2358 count.ev_count |= current; \ 2359 } 2360 2361 /************************************************************************ 2362 * ixv_update_stats - Update the board statistics counters. 2363 ************************************************************************/ 2364 void 2365 ixv_update_stats(struct adapter *adapter) 2366 { 2367 struct ixgbe_hw *hw = &adapter->hw; 2368 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2369 2370 UPDATE_STAT_32(IXGBE_VFGPRC, stats->last_vfgprc, stats->vfgprc); 2371 UPDATE_STAT_32(IXGBE_VFGPTC, stats->last_vfgptc, stats->vfgptc); 2372 UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB, stats->last_vfgorc, 2373 stats->vfgorc); 2374 UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB, stats->last_vfgotc, 2375 stats->vfgotc); 2376 UPDATE_STAT_32(IXGBE_VFMPRC, stats->last_vfmprc, stats->vfmprc); 2377 2378 /* Fill out the OS statistics structure */ 2379 /* 2380 * NetBSD: Don't override if_{i|o}{packets|bytes|mcasts} with 2381 * adapter->stats counters. It's required to make ifconfig -z 2382 * (SOICZIFDATA) work. 2383 */ 2384 } /* ixv_update_stats */ 2385 2386 /************************************************************************ 2387 * ixv_sysctl_interrupt_rate_handler 2388 ************************************************************************/ 2389 static int 2390 ixv_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 2391 { 2392 struct sysctlnode node = *rnode; 2393 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 2394 struct adapter *adapter = que->adapter; 2395 uint32_t reg, usec, rate; 2396 int error; 2397 2398 if (que == NULL) 2399 return 0; 2400 reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_VTEITR(que->msix)); 2401 usec = ((reg & 0x0FF8) >> 3); 2402 if (usec > 0) 2403 rate = 500000 / usec; 2404 else 2405 rate = 0; 2406 node.sysctl_data = &rate; 2407 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 2408 if (error || newp == NULL) 2409 return error; 2410 reg &= ~0xfff; /* default, no limitation */ 2411 if (rate > 0 && rate < 500000) { 2412 if (rate < 1000) 2413 rate = 1000; 2414 reg |= ((4000000/rate) & 0xff8); 2415 /* 2416 * When RSC is used, ITR interval must be larger than 2417 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 2418 * The minimum value is always greater than 2us on 100M 2419 * (and 10M?(not documented)), but it's not on 1G and higher. 2420 */ 2421 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2422 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2423 if ((adapter->num_queues > 1) 2424 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 2425 return EINVAL; 2426 } 2427 ixv_max_interrupt_rate = rate; 2428 } else 2429 ixv_max_interrupt_rate = 0; 2430 ixv_eitr_write(adapter, que->msix, reg); 2431 2432 return (0); 2433 } /* ixv_sysctl_interrupt_rate_handler */ 2434 2435 const struct sysctlnode * 2436 ixv_sysctl_instance(struct adapter *adapter) 2437 { 2438 const char *dvname; 2439 struct sysctllog **log; 2440 int rc; 2441 const struct sysctlnode *rnode; 2442 2443 log = &adapter->sysctllog; 2444 dvname = device_xname(adapter->dev); 2445 2446 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 2447 0, CTLTYPE_NODE, dvname, 2448 SYSCTL_DESCR("ixv information and settings"), 2449 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 2450 goto err; 2451 2452 return rnode; 2453 err: 2454 device_printf(adapter->dev, 2455 "%s: sysctl_createv failed, rc = %d\n", __func__, rc); 2456 return NULL; 2457 } 2458 2459 static void 2460 ixv_add_device_sysctls(struct adapter *adapter) 2461 { 2462 struct sysctllog **log; 2463 const struct sysctlnode *rnode, *cnode; 2464 device_t dev; 2465 2466 dev = adapter->dev; 2467 log = &adapter->sysctllog; 2468 2469 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2470 aprint_error_dev(dev, "could not create sysctl root\n"); 2471 return; 2472 } 2473 2474 if (sysctl_createv(log, 0, &rnode, &cnode, 2475 CTLFLAG_READWRITE, CTLTYPE_INT, 2476 "debug", SYSCTL_DESCR("Debug Info"), 2477 ixv_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 2478 aprint_error_dev(dev, "could not create sysctl\n"); 2479 2480 if (sysctl_createv(log, 0, &rnode, &cnode, 2481 CTLFLAG_READWRITE, CTLTYPE_BOOL, 2482 "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 2483 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 2484 aprint_error_dev(dev, "could not create sysctl\n"); 2485 2486 if (sysctl_createv(log, 0, &rnode, &cnode, 2487 CTLFLAG_READWRITE, CTLTYPE_BOOL, 2488 "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"), 2489 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0) 2490 aprint_error_dev(dev, "could not create sysctl\n"); 2491 } 2492 2493 /************************************************************************ 2494 * ixv_add_stats_sysctls - Add statistic sysctls for the VF. 2495 ************************************************************************/ 2496 static void 2497 ixv_add_stats_sysctls(struct adapter *adapter) 2498 { 2499 device_t dev = adapter->dev; 2500 struct tx_ring *txr = adapter->tx_rings; 2501 struct rx_ring *rxr = adapter->rx_rings; 2502 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2503 struct ixgbe_hw *hw = &adapter->hw; 2504 const struct sysctlnode *rnode, *cnode; 2505 struct sysctllog **log = &adapter->sysctllog; 2506 const char *xname = device_xname(dev); 2507 2508 /* Driver Statistics */ 2509 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 2510 NULL, xname, "Driver tx dma soft fail EFBIG"); 2511 evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC, 2512 NULL, xname, "m_defrag() failed"); 2513 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 2514 NULL, xname, "Driver tx dma hard fail EFBIG"); 2515 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 2516 NULL, xname, "Driver tx dma hard fail EINVAL"); 2517 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 2518 NULL, xname, "Driver tx dma hard fail other"); 2519 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 2520 NULL, xname, "Driver tx dma soft fail EAGAIN"); 2521 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 2522 NULL, xname, "Driver tx dma soft fail ENOMEM"); 2523 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 2524 NULL, xname, "Watchdog timeouts"); 2525 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 2526 NULL, xname, "TSO errors"); 2527 evcnt_attach_dynamic(&adapter->link_irq, EVCNT_TYPE_INTR, 2528 NULL, xname, "Link MSI-X IRQ Handled"); 2529 2530 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2531 snprintf(adapter->queues[i].evnamebuf, 2532 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 2533 xname, i); 2534 snprintf(adapter->queues[i].namebuf, 2535 sizeof(adapter->queues[i].namebuf), "q%d", i); 2536 2537 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2538 aprint_error_dev(dev, "could not create sysctl root\n"); 2539 break; 2540 } 2541 2542 if (sysctl_createv(log, 0, &rnode, &rnode, 2543 0, CTLTYPE_NODE, 2544 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 2545 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 2546 break; 2547 2548 if (sysctl_createv(log, 0, &rnode, &cnode, 2549 CTLFLAG_READWRITE, CTLTYPE_INT, 2550 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 2551 ixv_sysctl_interrupt_rate_handler, 0, 2552 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 2553 break; 2554 2555 if (sysctl_createv(log, 0, &rnode, &cnode, 2556 CTLFLAG_READONLY, CTLTYPE_INT, 2557 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 2558 ixv_sysctl_tdh_handler, 0, (void *)txr, 2559 0, CTL_CREATE, CTL_EOL) != 0) 2560 break; 2561 2562 if (sysctl_createv(log, 0, &rnode, &cnode, 2563 CTLFLAG_READONLY, CTLTYPE_INT, 2564 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 2565 ixv_sysctl_tdt_handler, 0, (void *)txr, 2566 0, CTL_CREATE, CTL_EOL) != 0) 2567 break; 2568 2569 evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR, 2570 NULL, adapter->queues[i].evnamebuf, "IRQs on queue"); 2571 evcnt_attach_dynamic(&adapter->queues[i].handleq, 2572 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 2573 "Handled queue in softint"); 2574 evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC, 2575 NULL, adapter->queues[i].evnamebuf, "Requeued in softint"); 2576 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 2577 NULL, adapter->queues[i].evnamebuf, "TSO"); 2578 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 2579 NULL, adapter->queues[i].evnamebuf, 2580 "Queue No Descriptor Available"); 2581 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 2582 NULL, adapter->queues[i].evnamebuf, 2583 "Queue Packets Transmitted"); 2584 #ifndef IXGBE_LEGACY_TX 2585 evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC, 2586 NULL, adapter->queues[i].evnamebuf, 2587 "Packets dropped in pcq"); 2588 #endif 2589 2590 #ifdef LRO 2591 struct lro_ctrl *lro = &rxr->lro; 2592 #endif /* LRO */ 2593 2594 if (sysctl_createv(log, 0, &rnode, &cnode, 2595 CTLFLAG_READONLY, 2596 CTLTYPE_INT, 2597 "rxd_nxck", SYSCTL_DESCR("Receive Descriptor next to check"), 2598 ixv_sysctl_next_to_check_handler, 0, (void *)rxr, 0, 2599 CTL_CREATE, CTL_EOL) != 0) 2600 break; 2601 2602 if (sysctl_createv(log, 0, &rnode, &cnode, 2603 CTLFLAG_READONLY, 2604 CTLTYPE_INT, 2605 "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"), 2606 ixv_sysctl_rdh_handler, 0, (void *)rxr, 0, 2607 CTL_CREATE, CTL_EOL) != 0) 2608 break; 2609 2610 if (sysctl_createv(log, 0, &rnode, &cnode, 2611 CTLFLAG_READONLY, 2612 CTLTYPE_INT, 2613 "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"), 2614 ixv_sysctl_rdt_handler, 0, (void *)rxr, 0, 2615 CTL_CREATE, CTL_EOL) != 0) 2616 break; 2617 2618 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 2619 NULL, adapter->queues[i].evnamebuf, "Queue Packets Received"); 2620 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 2621 NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received"); 2622 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 2623 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 2624 evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC, 2625 NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf"); 2626 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 2627 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 2628 #ifdef LRO 2629 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 2630 CTLFLAG_RD, &lro->lro_queued, 0, 2631 "LRO Queued"); 2632 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 2633 CTLFLAG_RD, &lro->lro_flushed, 0, 2634 "LRO Flushed"); 2635 #endif /* LRO */ 2636 } 2637 2638 /* MAC stats get their own sub node */ 2639 2640 snprintf(stats->namebuf, 2641 sizeof(stats->namebuf), "%s MAC Statistics", xname); 2642 2643 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 2644 stats->namebuf, "rx csum offload - IP"); 2645 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 2646 stats->namebuf, "rx csum offload - L4"); 2647 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 2648 stats->namebuf, "rx csum offload - IP bad"); 2649 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 2650 stats->namebuf, "rx csum offload - L4 bad"); 2651 2652 /* Packet Reception Stats */ 2653 evcnt_attach_dynamic(&stats->vfgprc, EVCNT_TYPE_MISC, NULL, 2654 xname, "Good Packets Received"); 2655 evcnt_attach_dynamic(&stats->vfgorc, EVCNT_TYPE_MISC, NULL, 2656 xname, "Good Octets Received"); 2657 evcnt_attach_dynamic(&stats->vfmprc, EVCNT_TYPE_MISC, NULL, 2658 xname, "Multicast Packets Received"); 2659 evcnt_attach_dynamic(&stats->vfgptc, EVCNT_TYPE_MISC, NULL, 2660 xname, "Good Packets Transmitted"); 2661 evcnt_attach_dynamic(&stats->vfgotc, EVCNT_TYPE_MISC, NULL, 2662 xname, "Good Octets Transmitted"); 2663 2664 /* Mailbox Stats */ 2665 evcnt_attach_dynamic(&hw->mbx.stats.msgs_tx, EVCNT_TYPE_MISC, NULL, 2666 xname, "message TXs"); 2667 evcnt_attach_dynamic(&hw->mbx.stats.msgs_rx, EVCNT_TYPE_MISC, NULL, 2668 xname, "message RXs"); 2669 evcnt_attach_dynamic(&hw->mbx.stats.acks, EVCNT_TYPE_MISC, NULL, 2670 xname, "ACKs"); 2671 evcnt_attach_dynamic(&hw->mbx.stats.reqs, EVCNT_TYPE_MISC, NULL, 2672 xname, "REQs"); 2673 evcnt_attach_dynamic(&hw->mbx.stats.rsts, EVCNT_TYPE_MISC, NULL, 2674 xname, "RSTs"); 2675 2676 } /* ixv_add_stats_sysctls */ 2677 2678 static void 2679 ixv_clear_evcnt(struct adapter *adapter) 2680 { 2681 struct tx_ring *txr = adapter->tx_rings; 2682 struct rx_ring *rxr = adapter->rx_rings; 2683 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2684 struct ixgbe_hw *hw = &adapter->hw; 2685 int i; 2686 2687 /* Driver Statistics */ 2688 adapter->efbig_tx_dma_setup.ev_count = 0; 2689 adapter->mbuf_defrag_failed.ev_count = 0; 2690 adapter->efbig2_tx_dma_setup.ev_count = 0; 2691 adapter->einval_tx_dma_setup.ev_count = 0; 2692 adapter->other_tx_dma_setup.ev_count = 0; 2693 adapter->eagain_tx_dma_setup.ev_count = 0; 2694 adapter->enomem_tx_dma_setup.ev_count = 0; 2695 adapter->watchdog_events.ev_count = 0; 2696 adapter->tso_err.ev_count = 0; 2697 adapter->link_irq.ev_count = 0; 2698 2699 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2700 adapter->queues[i].irqs.ev_count = 0; 2701 adapter->queues[i].handleq.ev_count = 0; 2702 adapter->queues[i].req.ev_count = 0; 2703 txr->tso_tx.ev_count = 0; 2704 txr->no_desc_avail.ev_count = 0; 2705 txr->total_packets.ev_count = 0; 2706 #ifndef IXGBE_LEGACY_TX 2707 txr->pcq_drops.ev_count = 0; 2708 #endif 2709 txr->q_efbig_tx_dma_setup = 0; 2710 txr->q_mbuf_defrag_failed = 0; 2711 txr->q_efbig2_tx_dma_setup = 0; 2712 txr->q_einval_tx_dma_setup = 0; 2713 txr->q_other_tx_dma_setup = 0; 2714 txr->q_eagain_tx_dma_setup = 0; 2715 txr->q_enomem_tx_dma_setup = 0; 2716 txr->q_tso_err = 0; 2717 2718 rxr->rx_packets.ev_count = 0; 2719 rxr->rx_bytes.ev_count = 0; 2720 rxr->rx_copies.ev_count = 0; 2721 rxr->no_jmbuf.ev_count = 0; 2722 rxr->rx_discarded.ev_count = 0; 2723 } 2724 2725 /* MAC stats get their own sub node */ 2726 2727 stats->ipcs.ev_count = 0; 2728 stats->l4cs.ev_count = 0; 2729 stats->ipcs_bad.ev_count = 0; 2730 stats->l4cs_bad.ev_count = 0; 2731 2732 /* Packet Reception Stats */ 2733 stats->vfgprc.ev_count = 0; 2734 stats->vfgorc.ev_count = 0; 2735 stats->vfmprc.ev_count = 0; 2736 stats->vfgptc.ev_count = 0; 2737 stats->vfgotc.ev_count = 0; 2738 2739 /* Mailbox Stats */ 2740 hw->mbx.stats.msgs_tx.ev_count = 0; 2741 hw->mbx.stats.msgs_rx.ev_count = 0; 2742 hw->mbx.stats.acks.ev_count = 0; 2743 hw->mbx.stats.reqs.ev_count = 0; 2744 hw->mbx.stats.rsts.ev_count = 0; 2745 2746 } /* ixv_clear_evcnt */ 2747 2748 /************************************************************************ 2749 * ixv_set_sysctl_value 2750 ************************************************************************/ 2751 static void 2752 ixv_set_sysctl_value(struct adapter *adapter, const char *name, 2753 const char *description, int *limit, int value) 2754 { 2755 device_t dev = adapter->dev; 2756 struct sysctllog **log; 2757 const struct sysctlnode *rnode, *cnode; 2758 2759 log = &adapter->sysctllog; 2760 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2761 aprint_error_dev(dev, "could not create sysctl root\n"); 2762 return; 2763 } 2764 if (sysctl_createv(log, 0, &rnode, &cnode, 2765 CTLFLAG_READWRITE, CTLTYPE_INT, 2766 name, SYSCTL_DESCR(description), 2767 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 2768 aprint_error_dev(dev, "could not create sysctl\n"); 2769 *limit = value; 2770 } /* ixv_set_sysctl_value */ 2771 2772 /************************************************************************ 2773 * ixv_print_debug_info 2774 * 2775 * Called only when em_display_debug_stats is enabled. 2776 * Provides a way to take a look at important statistics 2777 * maintained by the driver and hardware. 2778 ************************************************************************/ 2779 static void 2780 ixv_print_debug_info(struct adapter *adapter) 2781 { 2782 device_t dev = adapter->dev; 2783 struct ix_queue *que = adapter->queues; 2784 struct rx_ring *rxr; 2785 struct tx_ring *txr; 2786 #ifdef LRO 2787 struct lro_ctrl *lro; 2788 #endif /* LRO */ 2789 2790 for (int i = 0; i < adapter->num_queues; i++, que++) { 2791 txr = que->txr; 2792 rxr = que->rxr; 2793 #ifdef LRO 2794 lro = &rxr->lro; 2795 #endif /* LRO */ 2796 device_printf(dev, "QUE(%d) IRQs Handled: %lu\n", 2797 que->msix, (long)que->irqs.ev_count); 2798 device_printf(dev, "RX(%d) Packets Received: %lld\n", 2799 rxr->me, (long long)rxr->rx_packets.ev_count); 2800 device_printf(dev, "RX(%d) Bytes Received: %lu\n", 2801 rxr->me, (long)rxr->rx_bytes.ev_count); 2802 #ifdef LRO 2803 device_printf(dev, "RX(%d) LRO Queued= %ju\n", 2804 rxr->me, (uintmax_t)lro->lro_queued); 2805 device_printf(dev, "RX(%d) LRO Flushed= %ju\n", 2806 rxr->me, (uintmax_t)lro->lro_flushed); 2807 #endif /* LRO */ 2808 device_printf(dev, "TX(%d) Packets Sent: %lu\n", 2809 txr->me, (long)txr->total_packets.ev_count); 2810 device_printf(dev, "TX(%d) NO Desc Avail: %lu\n", 2811 txr->me, (long)txr->no_desc_avail.ev_count); 2812 } 2813 2814 device_printf(dev, "MBX IRQ Handled: %lu\n", 2815 (long)adapter->link_irq.ev_count); 2816 } /* ixv_print_debug_info */ 2817 2818 /************************************************************************ 2819 * ixv_sysctl_debug 2820 ************************************************************************/ 2821 static int 2822 ixv_sysctl_debug(SYSCTLFN_ARGS) 2823 { 2824 struct sysctlnode node = *rnode; 2825 struct adapter *adapter = (struct adapter *)node.sysctl_data; 2826 int error, result; 2827 2828 node.sysctl_data = &result; 2829 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 2830 2831 if (error || newp == NULL) 2832 return error; 2833 2834 if (result == 1) 2835 ixv_print_debug_info(adapter); 2836 2837 return 0; 2838 } /* ixv_sysctl_debug */ 2839 2840 /************************************************************************ 2841 * ixv_init_device_features 2842 ************************************************************************/ 2843 static void 2844 ixv_init_device_features(struct adapter *adapter) 2845 { 2846 adapter->feat_cap = IXGBE_FEATURE_NETMAP 2847 | IXGBE_FEATURE_VF 2848 | IXGBE_FEATURE_RSS 2849 | IXGBE_FEATURE_LEGACY_TX; 2850 2851 /* A tad short on feature flags for VFs, atm. */ 2852 switch (adapter->hw.mac.type) { 2853 case ixgbe_mac_82599_vf: 2854 break; 2855 case ixgbe_mac_X540_vf: 2856 break; 2857 case ixgbe_mac_X550_vf: 2858 case ixgbe_mac_X550EM_x_vf: 2859 case ixgbe_mac_X550EM_a_vf: 2860 adapter->feat_cap |= IXGBE_FEATURE_NEEDS_CTXD; 2861 break; 2862 default: 2863 break; 2864 } 2865 2866 /* Enabled by default... */ 2867 /* Is a virtual function (VF) */ 2868 if (adapter->feat_cap & IXGBE_FEATURE_VF) 2869 adapter->feat_en |= IXGBE_FEATURE_VF; 2870 /* Netmap */ 2871 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 2872 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 2873 /* Receive-Side Scaling (RSS) */ 2874 if (adapter->feat_cap & IXGBE_FEATURE_RSS) 2875 adapter->feat_en |= IXGBE_FEATURE_RSS; 2876 /* Needs advanced context descriptor regardless of offloads req'd */ 2877 if (adapter->feat_cap & IXGBE_FEATURE_NEEDS_CTXD) 2878 adapter->feat_en |= IXGBE_FEATURE_NEEDS_CTXD; 2879 2880 /* Enabled via sysctl... */ 2881 /* Legacy (single queue) transmit */ 2882 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 2883 ixv_enable_legacy_tx) 2884 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 2885 } /* ixv_init_device_features */ 2886 2887 /************************************************************************ 2888 * ixv_shutdown - Shutdown entry point 2889 ************************************************************************/ 2890 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 2891 static int 2892 ixv_shutdown(device_t dev) 2893 { 2894 struct adapter *adapter = device_private(dev); 2895 IXGBE_CORE_LOCK(adapter); 2896 ixv_stop(adapter); 2897 IXGBE_CORE_UNLOCK(adapter); 2898 2899 return (0); 2900 } /* ixv_shutdown */ 2901 #endif 2902 2903 static int 2904 ixv_ifflags_cb(struct ethercom *ec) 2905 { 2906 struct ifnet *ifp = &ec->ec_if; 2907 struct adapter *adapter = ifp->if_softc; 2908 u_short change; 2909 int rv = 0; 2910 2911 IXGBE_CORE_LOCK(adapter); 2912 2913 change = ifp->if_flags ^ adapter->if_flags; 2914 if (change != 0) 2915 adapter->if_flags = ifp->if_flags; 2916 2917 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) { 2918 rv = ENETRESET; 2919 goto out; 2920 } 2921 2922 /* Check for ec_capenable. */ 2923 change = ec->ec_capenable ^ adapter->ec_capenable; 2924 adapter->ec_capenable = ec->ec_capenable; 2925 if ((change & ~(ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING 2926 | ETHERCAP_VLAN_HWFILTER)) != 0) { 2927 rv = ENETRESET; 2928 goto out; 2929 } 2930 2931 /* 2932 * Special handling is not required for ETHERCAP_VLAN_MTU. 2933 * PF's MAXFRS(MHADD) does not include the 4bytes of the VLAN header. 2934 */ 2935 2936 /* Set up VLAN support and filter */ 2937 if ((change & (ETHERCAP_VLAN_HWTAGGING | ETHERCAP_VLAN_HWFILTER)) != 0) 2938 rv = ixv_setup_vlan_support(adapter); 2939 2940 out: 2941 IXGBE_CORE_UNLOCK(adapter); 2942 2943 return rv; 2944 } 2945 2946 2947 /************************************************************************ 2948 * ixv_ioctl - Ioctl entry point 2949 * 2950 * Called when the user wants to configure the interface. 2951 * 2952 * return 0 on success, positive on failure 2953 ************************************************************************/ 2954 static int 2955 ixv_ioctl(struct ifnet *ifp, u_long command, void *data) 2956 { 2957 struct adapter *adapter = ifp->if_softc; 2958 struct ixgbe_hw *hw = &adapter->hw; 2959 struct ifcapreq *ifcr = data; 2960 int error; 2961 int l4csum_en; 2962 const int l4csum = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx | 2963 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx; 2964 2965 switch (command) { 2966 case SIOCSIFFLAGS: 2967 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 2968 break; 2969 case SIOCADDMULTI: { 2970 struct ether_multi *enm; 2971 struct ether_multistep step; 2972 struct ethercom *ec = &adapter->osdep.ec; 2973 bool overflow = false; 2974 int mcnt = 0; 2975 2976 /* 2977 * Check the number of multicast address. If it exceeds, 2978 * return ENOSPC. 2979 * Update this code when we support API 1.3. 2980 */ 2981 ETHER_LOCK(ec); 2982 ETHER_FIRST_MULTI(step, ec, enm); 2983 while (enm != NULL) { 2984 mcnt++; 2985 2986 /* 2987 * This code is before adding, so one room is required 2988 * at least. 2989 */ 2990 if (mcnt > (IXGBE_MAX_VF_MC - 1)) { 2991 overflow = true; 2992 break; 2993 } 2994 ETHER_NEXT_MULTI(step, enm); 2995 } 2996 ETHER_UNLOCK(ec); 2997 error = 0; 2998 if (overflow && ((ec->ec_flags & ETHER_F_ALLMULTI) == 0)) { 2999 error = hw->mac.ops.update_xcast_mode(hw, 3000 IXGBEVF_XCAST_MODE_ALLMULTI); 3001 if (error == IXGBE_ERR_NOT_TRUSTED) { 3002 device_printf(adapter->dev, 3003 "this interface is not trusted\n"); 3004 error = EPERM; 3005 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 3006 device_printf(adapter->dev, 3007 "the PF doesn't support allmulti mode\n"); 3008 error = EOPNOTSUPP; 3009 } else if (error) { 3010 device_printf(adapter->dev, 3011 "number of Ethernet multicast addresses " 3012 "exceeds the limit (%d). error = %d\n", 3013 IXGBE_MAX_VF_MC, error); 3014 error = ENOSPC; 3015 } else 3016 ec->ec_flags |= ETHER_F_ALLMULTI; 3017 } 3018 if (error) 3019 return error; 3020 } 3021 /*FALLTHROUGH*/ 3022 case SIOCDELMULTI: 3023 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 3024 break; 3025 case SIOCSIFMEDIA: 3026 case SIOCGIFMEDIA: 3027 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 3028 break; 3029 case SIOCSIFCAP: 3030 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 3031 break; 3032 case SIOCSIFMTU: 3033 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 3034 break; 3035 case SIOCZIFDATA: 3036 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 3037 ixv_update_stats(adapter); 3038 ixv_clear_evcnt(adapter); 3039 break; 3040 default: 3041 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 3042 break; 3043 } 3044 3045 switch (command) { 3046 case SIOCSIFCAP: 3047 /* Layer-4 Rx checksum offload has to be turned on and 3048 * off as a unit. 3049 */ 3050 l4csum_en = ifcr->ifcr_capenable & l4csum; 3051 if (l4csum_en != l4csum && l4csum_en != 0) 3052 return EINVAL; 3053 /*FALLTHROUGH*/ 3054 case SIOCADDMULTI: 3055 case SIOCDELMULTI: 3056 case SIOCSIFFLAGS: 3057 case SIOCSIFMTU: 3058 default: 3059 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 3060 return error; 3061 if ((ifp->if_flags & IFF_RUNNING) == 0) 3062 ; 3063 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 3064 IXGBE_CORE_LOCK(adapter); 3065 ixv_init_locked(adapter); 3066 IXGBE_CORE_UNLOCK(adapter); 3067 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 3068 /* 3069 * Multicast list has changed; set the hardware filter 3070 * accordingly. 3071 */ 3072 IXGBE_CORE_LOCK(adapter); 3073 ixv_disable_intr(adapter); 3074 ixv_set_multi(adapter); 3075 ixv_enable_intr(adapter); 3076 IXGBE_CORE_UNLOCK(adapter); 3077 } 3078 return 0; 3079 } 3080 } /* ixv_ioctl */ 3081 3082 /************************************************************************ 3083 * ixv_init 3084 ************************************************************************/ 3085 static int 3086 ixv_init(struct ifnet *ifp) 3087 { 3088 struct adapter *adapter = ifp->if_softc; 3089 3090 IXGBE_CORE_LOCK(adapter); 3091 ixv_init_locked(adapter); 3092 IXGBE_CORE_UNLOCK(adapter); 3093 3094 return 0; 3095 } /* ixv_init */ 3096 3097 /************************************************************************ 3098 * ixv_handle_que 3099 ************************************************************************/ 3100 static void 3101 ixv_handle_que(void *context) 3102 { 3103 struct ix_queue *que = context; 3104 struct adapter *adapter = que->adapter; 3105 struct tx_ring *txr = que->txr; 3106 struct ifnet *ifp = adapter->ifp; 3107 bool more; 3108 3109 que->handleq.ev_count++; 3110 3111 if (ifp->if_flags & IFF_RUNNING) { 3112 more = ixgbe_rxeof(que); 3113 IXGBE_TX_LOCK(txr); 3114 more |= ixgbe_txeof(txr); 3115 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 3116 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 3117 ixgbe_mq_start_locked(ifp, txr); 3118 /* Only for queue 0 */ 3119 /* NetBSD still needs this for CBQ */ 3120 if ((&adapter->queues[0] == que) 3121 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 3122 ixgbe_legacy_start_locked(ifp, txr); 3123 IXGBE_TX_UNLOCK(txr); 3124 if (more) { 3125 que->req.ev_count++; 3126 if (adapter->txrx_use_workqueue) { 3127 /* 3128 * "enqueued flag" is not required here 3129 * the same as ixg(4). See ixgbe_msix_que(). 3130 */ 3131 workqueue_enqueue(adapter->que_wq, 3132 &que->wq_cookie, curcpu()); 3133 } else 3134 softint_schedule(que->que_si); 3135 return; 3136 } 3137 } 3138 3139 /* Re-enable this interrupt */ 3140 ixv_enable_queue(adapter, que->msix); 3141 3142 return; 3143 } /* ixv_handle_que */ 3144 3145 /************************************************************************ 3146 * ixv_handle_que_work 3147 ************************************************************************/ 3148 static void 3149 ixv_handle_que_work(struct work *wk, void *context) 3150 { 3151 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 3152 3153 /* 3154 * "enqueued flag" is not required here the same as ixg(4). 3155 * See ixgbe_msix_que(). 3156 */ 3157 ixv_handle_que(que); 3158 } 3159 3160 /************************************************************************ 3161 * ixv_allocate_msix - Setup MSI-X Interrupt resources and handlers 3162 ************************************************************************/ 3163 static int 3164 ixv_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 3165 { 3166 device_t dev = adapter->dev; 3167 struct ix_queue *que = adapter->queues; 3168 struct tx_ring *txr = adapter->tx_rings; 3169 int error, msix_ctrl, rid, vector = 0; 3170 pci_chipset_tag_t pc; 3171 pcitag_t tag; 3172 char intrbuf[PCI_INTRSTR_LEN]; 3173 char wqname[MAXCOMLEN]; 3174 char intr_xname[32]; 3175 const char *intrstr = NULL; 3176 kcpuset_t *affinity; 3177 int cpu_id = 0; 3178 3179 pc = adapter->osdep.pc; 3180 tag = adapter->osdep.tag; 3181 3182 adapter->osdep.nintrs = adapter->num_queues + 1; 3183 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 3184 adapter->osdep.nintrs) != 0) { 3185 aprint_error_dev(dev, 3186 "failed to allocate MSI-X interrupt\n"); 3187 return (ENXIO); 3188 } 3189 3190 kcpuset_create(&affinity, false); 3191 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 3192 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 3193 device_xname(dev), i); 3194 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 3195 sizeof(intrbuf)); 3196 #ifdef IXGBE_MPSAFE 3197 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 3198 true); 3199 #endif 3200 /* Set the handler function */ 3201 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 3202 adapter->osdep.intrs[i], IPL_NET, ixv_msix_que, que, 3203 intr_xname); 3204 if (que->res == NULL) { 3205 pci_intr_release(pc, adapter->osdep.intrs, 3206 adapter->osdep.nintrs); 3207 aprint_error_dev(dev, 3208 "Failed to register QUE handler\n"); 3209 kcpuset_destroy(affinity); 3210 return (ENXIO); 3211 } 3212 que->msix = vector; 3213 adapter->active_queues |= (u64)(1 << que->msix); 3214 3215 cpu_id = i; 3216 /* Round-robin affinity */ 3217 kcpuset_zero(affinity); 3218 kcpuset_set(affinity, cpu_id % ncpu); 3219 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 3220 NULL); 3221 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 3222 intrstr); 3223 if (error == 0) 3224 aprint_normal(", bound queue %d to cpu %d\n", 3225 i, cpu_id % ncpu); 3226 else 3227 aprint_normal("\n"); 3228 3229 #ifndef IXGBE_LEGACY_TX 3230 txr->txr_si 3231 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 3232 ixgbe_deferred_mq_start, txr); 3233 #endif 3234 que->que_si 3235 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 3236 ixv_handle_que, que); 3237 if (que->que_si == NULL) { 3238 aprint_error_dev(dev, 3239 "could not establish software interrupt\n"); 3240 } 3241 } 3242 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 3243 error = workqueue_create(&adapter->txr_wq, wqname, 3244 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 3245 IXGBE_WORKQUEUE_FLAGS); 3246 if (error) { 3247 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 3248 } 3249 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 3250 3251 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 3252 error = workqueue_create(&adapter->que_wq, wqname, 3253 ixv_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 3254 IXGBE_WORKQUEUE_FLAGS); 3255 if (error) { 3256 aprint_error_dev(dev, 3257 "couldn't create workqueue\n"); 3258 } 3259 3260 /* and Mailbox */ 3261 cpu_id++; 3262 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 3263 adapter->vector = vector; 3264 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 3265 sizeof(intrbuf)); 3266 #ifdef IXGBE_MPSAFE 3267 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 3268 true); 3269 #endif 3270 /* Set the mbx handler function */ 3271 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 3272 adapter->osdep.intrs[vector], IPL_NET, ixv_msix_mbx, adapter, 3273 intr_xname); 3274 if (adapter->osdep.ihs[vector] == NULL) { 3275 aprint_error_dev(dev, "Failed to register LINK handler\n"); 3276 kcpuset_destroy(affinity); 3277 return (ENXIO); 3278 } 3279 /* Round-robin affinity */ 3280 kcpuset_zero(affinity); 3281 kcpuset_set(affinity, cpu_id % ncpu); 3282 error = interrupt_distribute(adapter->osdep.ihs[vector], 3283 affinity, NULL); 3284 3285 aprint_normal_dev(dev, 3286 "for link, interrupting at %s", intrstr); 3287 if (error == 0) 3288 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 3289 else 3290 aprint_normal("\n"); 3291 3292 /* Tasklets for Mailbox */ 3293 adapter->link_si = softint_establish(SOFTINT_NET |IXGBE_SOFTINFT_FLAGS, 3294 ixv_handle_link, adapter); 3295 /* 3296 * Due to a broken design QEMU will fail to properly 3297 * enable the guest for MSI-X unless the vectors in 3298 * the table are all set up, so we must rewrite the 3299 * ENABLE in the MSI-X control register again at this 3300 * point to cause it to successfully initialize us. 3301 */ 3302 if (adapter->hw.mac.type == ixgbe_mac_82599_vf) { 3303 pci_get_capability(pc, tag, PCI_CAP_MSIX, &rid, NULL); 3304 rid += PCI_MSIX_CTL; 3305 msix_ctrl = pci_conf_read(pc, tag, rid); 3306 msix_ctrl |= PCI_MSIX_CTL_ENABLE; 3307 pci_conf_write(pc, tag, rid, msix_ctrl); 3308 } 3309 3310 kcpuset_destroy(affinity); 3311 return (0); 3312 } /* ixv_allocate_msix */ 3313 3314 /************************************************************************ 3315 * ixv_configure_interrupts - Setup MSI-X resources 3316 * 3317 * Note: The VF device MUST use MSI-X, there is no fallback. 3318 ************************************************************************/ 3319 static int 3320 ixv_configure_interrupts(struct adapter *adapter) 3321 { 3322 device_t dev = adapter->dev; 3323 int want, queues, msgs; 3324 3325 /* Must have at least 2 MSI-X vectors */ 3326 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 3327 if (msgs < 2) { 3328 aprint_error_dev(dev, "MSIX config error\n"); 3329 return (ENXIO); 3330 } 3331 msgs = MIN(msgs, IXG_MAX_NINTR); 3332 3333 /* Figure out a reasonable auto config value */ 3334 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 3335 3336 if (ixv_num_queues != 0) 3337 queues = ixv_num_queues; 3338 else if ((ixv_num_queues == 0) && (queues > IXGBE_VF_MAX_TX_QUEUES)) 3339 queues = IXGBE_VF_MAX_TX_QUEUES; 3340 3341 /* 3342 * Want vectors for the queues, 3343 * plus an additional for mailbox. 3344 */ 3345 want = queues + 1; 3346 if (msgs >= want) 3347 msgs = want; 3348 else { 3349 aprint_error_dev(dev, 3350 "MSI-X Configuration Problem, " 3351 "%d vectors but %d queues wanted!\n", 3352 msgs, want); 3353 return -1; 3354 } 3355 3356 adapter->msix_mem = (void *)1; /* XXX */ 3357 aprint_normal_dev(dev, 3358 "Using MSI-X interrupts with %d vectors\n", msgs); 3359 adapter->num_queues = queues; 3360 3361 return (0); 3362 } /* ixv_configure_interrupts */ 3363 3364 3365 /************************************************************************ 3366 * ixv_handle_link - Tasklet handler for MSI-X MBX interrupts 3367 * 3368 * Done outside of interrupt context since the driver might sleep 3369 ************************************************************************/ 3370 static void 3371 ixv_handle_link(void *context) 3372 { 3373 struct adapter *adapter = context; 3374 3375 IXGBE_CORE_LOCK(adapter); 3376 3377 adapter->hw.mac.ops.check_link(&adapter->hw, &adapter->link_speed, 3378 &adapter->link_up, FALSE); 3379 ixv_update_link_status(adapter); 3380 3381 IXGBE_CORE_UNLOCK(adapter); 3382 } /* ixv_handle_link */ 3383 3384 /************************************************************************ 3385 * ixv_check_link - Used in the local timer to poll for link changes 3386 ************************************************************************/ 3387 static s32 3388 ixv_check_link(struct adapter *adapter) 3389 { 3390 s32 error; 3391 3392 KASSERT(mutex_owned(&adapter->core_mtx)); 3393 3394 adapter->hw.mac.get_link_status = TRUE; 3395 3396 error = adapter->hw.mac.ops.check_link(&adapter->hw, 3397 &adapter->link_speed, &adapter->link_up, FALSE); 3398 ixv_update_link_status(adapter); 3399 3400 return error; 3401 } /* ixv_check_link */ 3402
Indexes created Tue Sep 30 20:09:53 GMT 2025