ixv.c revision 1.142
1 /*$NetBSD: ixv.c,v 1.142 2019/12/16 02:50:54 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 int ixv_set_rxfilter(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 adapter->max_frame_size = 720 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 721 722 /* reprogram the RAR[0] in case user changed it. */ 723 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 724 725 /* Get the latest mac address, User can use a LAA */ 726 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 727 IXGBE_ETH_LENGTH_OF_ADDRESS); 728 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1); 729 730 /* Prepare transmit descriptors and buffers */ 731 if (ixgbe_setup_transmit_structures(adapter)) { 732 aprint_error_dev(dev, "Could not setup transmit structures\n"); 733 ixv_stop(adapter); 734 return; 735 } 736 737 /* Reset VF and renegotiate mailbox API version */ 738 hw->mac.ops.reset_hw(hw); 739 hw->mac.ops.start_hw(hw); 740 error = ixv_negotiate_api(adapter); 741 if (error) 742 device_printf(dev, 743 "Mailbox API negotiation failed in init_locked!\n"); 744 745 ixv_initialize_transmit_units(adapter); 746 747 /* Setup Multicast table */ 748 ixv_set_rxfilter(adapter); 749 750 /* 751 * Determine the correct mbuf pool 752 * for doing jumbo/headersplit 753 */ 754 if (adapter->max_frame_size <= MCLBYTES) 755 adapter->rx_mbuf_sz = MCLBYTES; 756 else 757 adapter->rx_mbuf_sz = MJUMPAGESIZE; 758 759 /* Prepare receive descriptors and buffers */ 760 if (ixgbe_setup_receive_structures(adapter)) { 761 device_printf(dev, "Could not setup receive structures\n"); 762 ixv_stop(adapter); 763 return; 764 } 765 766 /* Configure RX settings */ 767 ixv_initialize_receive_units(adapter); 768 769 /* Set up VLAN offload and filter */ 770 ixv_setup_vlan_support(adapter); 771 772 /* Set up MSI-X routing */ 773 ixv_configure_ivars(adapter); 774 775 /* Set up auto-mask */ 776 mask = (1 << adapter->vector); 777 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 778 mask |= (1 << que->msix); 779 IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, mask); 780 781 /* Set moderation on the Link interrupt */ 782 ixv_eitr_write(adapter, adapter->vector, IXGBE_LINK_ITR); 783 784 /* Stats init */ 785 ixv_init_stats(adapter); 786 787 /* Config/Enable Link */ 788 hw->mac.get_link_status = TRUE; 789 hw->mac.ops.check_link(hw, &adapter->link_speed, &adapter->link_up, 790 FALSE); 791 792 /* Start watchdog */ 793 callout_reset(&adapter->timer, hz, ixv_local_timer, adapter); 794 795 /* And now turn on interrupts */ 796 ixv_enable_intr(adapter); 797 798 /* Update saved flags. See ixgbe_ifflags_cb() */ 799 adapter->if_flags = ifp->if_flags; 800 adapter->ec_capenable = adapter->osdep.ec.ec_capenable; 801 802 /* Now inform the stack we're ready */ 803 ifp->if_flags |= IFF_RUNNING; 804 ifp->if_flags &= ~IFF_OACTIVE; 805 806 return; 807 } /* ixv_init_locked */ 808 809 /************************************************************************ 810 * ixv_enable_queue 811 ************************************************************************/ 812 static inline void 813 ixv_enable_queue(struct adapter *adapter, u32 vector) 814 { 815 struct ixgbe_hw *hw = &adapter->hw; 816 struct ix_queue *que = &adapter->queues[vector]; 817 u32 queue = 1UL << vector; 818 u32 mask; 819 820 mutex_enter(&que->dc_mtx); 821 if (que->disabled_count > 0 && --que->disabled_count > 0) 822 goto out; 823 824 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 825 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask); 826 out: 827 mutex_exit(&que->dc_mtx); 828 } /* ixv_enable_queue */ 829 830 /************************************************************************ 831 * ixv_disable_queue 832 ************************************************************************/ 833 static inline void 834 ixv_disable_queue(struct adapter *adapter, u32 vector) 835 { 836 struct ixgbe_hw *hw = &adapter->hw; 837 struct ix_queue *que = &adapter->queues[vector]; 838 u32 queue = 1UL << vector; 839 u32 mask; 840 841 mutex_enter(&que->dc_mtx); 842 if (que->disabled_count++ > 0) 843 goto out; 844 845 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 846 IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask); 847 out: 848 mutex_exit(&que->dc_mtx); 849 } /* ixv_disable_queue */ 850 851 #if 0 852 static inline void 853 ixv_rearm_queues(struct adapter *adapter, u64 queues) 854 { 855 u32 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 856 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEICS, mask); 857 } /* ixv_rearm_queues */ 858 #endif 859 860 861 /************************************************************************ 862 * ixv_msix_que - MSI-X Queue Interrupt Service routine 863 ************************************************************************/ 864 static int 865 ixv_msix_que(void *arg) 866 { 867 struct ix_queue *que = arg; 868 struct adapter *adapter = que->adapter; 869 struct tx_ring *txr = que->txr; 870 struct rx_ring *rxr = que->rxr; 871 bool more; 872 u32 newitr = 0; 873 874 ixv_disable_queue(adapter, que->msix); 875 ++que->irqs.ev_count; 876 877 #ifdef __NetBSD__ 878 /* Don't run ixgbe_rxeof in interrupt context */ 879 more = true; 880 #else 881 more = ixgbe_rxeof(que); 882 #endif 883 884 IXGBE_TX_LOCK(txr); 885 ixgbe_txeof(txr); 886 IXGBE_TX_UNLOCK(txr); 887 888 /* Do AIM now? */ 889 890 if (adapter->enable_aim == false) 891 goto no_calc; 892 /* 893 * Do Adaptive Interrupt Moderation: 894 * - Write out last calculated setting 895 * - Calculate based on average size over 896 * the last interval. 897 */ 898 if (que->eitr_setting) 899 ixv_eitr_write(adapter, que->msix, que->eitr_setting); 900 901 que->eitr_setting = 0; 902 903 /* Idle, do nothing */ 904 if ((txr->bytes == 0) && (rxr->bytes == 0)) 905 goto no_calc; 906 907 if ((txr->bytes) && (txr->packets)) 908 newitr = txr->bytes/txr->packets; 909 if ((rxr->bytes) && (rxr->packets)) 910 newitr = uimax(newitr, (rxr->bytes / rxr->packets)); 911 newitr += 24; /* account for hardware frame, crc */ 912 913 /* set an upper boundary */ 914 newitr = uimin(newitr, 3000); 915 916 /* Be nice to the mid range */ 917 if ((newitr > 300) && (newitr < 1200)) 918 newitr = (newitr / 3); 919 else 920 newitr = (newitr / 2); 921 922 /* 923 * When RSC is used, ITR interval must be larger than RSC_DELAY. 924 * Currently, we use 2us for RSC_DELAY. The minimum value is always 925 * greater than 2us on 100M (and 10M?(not documented)), but it's not 926 * on 1G and higher. 927 */ 928 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 929 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 930 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 931 newitr = IXGBE_MIN_RSC_EITR_10G1G; 932 } 933 934 /* save for next interrupt */ 935 que->eitr_setting = newitr; 936 937 /* Reset state */ 938 txr->bytes = 0; 939 txr->packets = 0; 940 rxr->bytes = 0; 941 rxr->packets = 0; 942 943 no_calc: 944 if (more) 945 softint_schedule(que->que_si); 946 else /* Re-enable this interrupt */ 947 ixv_enable_queue(adapter, que->msix); 948 949 return 1; 950 } /* ixv_msix_que */ 951 952 /************************************************************************ 953 * ixv_msix_mbx 954 ************************************************************************/ 955 static int 956 ixv_msix_mbx(void *arg) 957 { 958 struct adapter *adapter = arg; 959 struct ixgbe_hw *hw = &adapter->hw; 960 961 ++adapter->link_irq.ev_count; 962 /* NetBSD: We use auto-clear, so it's not required to write VTEICR */ 963 964 /* Link status change */ 965 hw->mac.get_link_status = TRUE; 966 softint_schedule(adapter->link_si); 967 968 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, (1 << adapter->vector)); 969 970 return 1; 971 } /* ixv_msix_mbx */ 972 973 static void 974 ixv_eitr_write(struct adapter *adapter, uint32_t index, uint32_t itr) 975 { 976 977 /* 978 * Newer devices than 82598 have VF function, so this function is 979 * simple. 980 */ 981 itr |= IXGBE_EITR_CNT_WDIS; 982 983 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEITR(index), itr); 984 } 985 986 987 /************************************************************************ 988 * ixv_media_status - Media Ioctl callback 989 * 990 * Called whenever the user queries the status of 991 * the interface using ifconfig. 992 ************************************************************************/ 993 static void 994 ixv_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 995 { 996 struct adapter *adapter = ifp->if_softc; 997 998 INIT_DEBUGOUT("ixv_media_status: begin"); 999 IXGBE_CORE_LOCK(adapter); 1000 ixv_update_link_status(adapter); 1001 1002 ifmr->ifm_status = IFM_AVALID; 1003 ifmr->ifm_active = IFM_ETHER; 1004 1005 if (adapter->link_active != LINK_STATE_UP) { 1006 ifmr->ifm_active |= IFM_NONE; 1007 IXGBE_CORE_UNLOCK(adapter); 1008 return; 1009 } 1010 1011 ifmr->ifm_status |= IFM_ACTIVE; 1012 1013 switch (adapter->link_speed) { 1014 case IXGBE_LINK_SPEED_10GB_FULL: 1015 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 1016 break; 1017 case IXGBE_LINK_SPEED_5GB_FULL: 1018 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 1019 break; 1020 case IXGBE_LINK_SPEED_2_5GB_FULL: 1021 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 1022 break; 1023 case IXGBE_LINK_SPEED_1GB_FULL: 1024 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 1025 break; 1026 case IXGBE_LINK_SPEED_100_FULL: 1027 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 1028 break; 1029 case IXGBE_LINK_SPEED_10_FULL: 1030 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 1031 break; 1032 } 1033 1034 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 1035 1036 IXGBE_CORE_UNLOCK(adapter); 1037 } /* ixv_media_status */ 1038 1039 /************************************************************************ 1040 * ixv_media_change - Media Ioctl callback 1041 * 1042 * Called when the user changes speed/duplex using 1043 * media/mediopt option with ifconfig. 1044 ************************************************************************/ 1045 static int 1046 ixv_media_change(struct ifnet *ifp) 1047 { 1048 struct adapter *adapter = ifp->if_softc; 1049 struct ifmedia *ifm = &adapter->media; 1050 1051 INIT_DEBUGOUT("ixv_media_change: begin"); 1052 1053 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 1054 return (EINVAL); 1055 1056 switch (IFM_SUBTYPE(ifm->ifm_media)) { 1057 case IFM_AUTO: 1058 break; 1059 default: 1060 device_printf(adapter->dev, "Only auto media type\n"); 1061 return (EINVAL); 1062 } 1063 1064 return (0); 1065 } /* ixv_media_change */ 1066 1067 /************************************************************************ 1068 * ixv_negotiate_api 1069 * 1070 * Negotiate the Mailbox API with the PF; 1071 * start with the most featured API first. 1072 ************************************************************************/ 1073 static int 1074 ixv_negotiate_api(struct adapter *adapter) 1075 { 1076 struct ixgbe_hw *hw = &adapter->hw; 1077 int mbx_api[] = { ixgbe_mbox_api_13, 1078 ixgbe_mbox_api_12, 1079 ixgbe_mbox_api_11, 1080 ixgbe_mbox_api_10, 1081 ixgbe_mbox_api_unknown }; 1082 int i = 0; 1083 1084 while (mbx_api[i] != ixgbe_mbox_api_unknown) { 1085 if (ixgbevf_negotiate_api_version(hw, mbx_api[i]) == 0) 1086 return (0); 1087 i++; 1088 } 1089 1090 return (EINVAL); 1091 } /* ixv_negotiate_api */ 1092 1093 1094 /************************************************************************ 1095 * ixv_set_multi - Multicast Update 1096 * 1097 * Called whenever multicast address list is updated. 1098 ************************************************************************/ 1099 static int 1100 ixv_set_rxfilter(struct adapter *adapter) 1101 { 1102 u8 mta[IXGBE_MAX_VF_MC * IXGBE_ETH_LENGTH_OF_ADDRESS]; 1103 struct ifnet *ifp = adapter->ifp; 1104 struct ixgbe_hw *hw = &adapter->hw; 1105 u8 *update_ptr; 1106 int mcnt = 0; 1107 struct ethercom *ec = &adapter->osdep.ec; 1108 struct ether_multi *enm; 1109 struct ether_multistep step; 1110 bool overflow = false; 1111 int error, rc = 0; 1112 1113 KASSERT(mutex_owned(&adapter->core_mtx)); 1114 IOCTL_DEBUGOUT("ixv_set_rxfilter: begin"); 1115 1116 /* 1: For PROMISC */ 1117 if (ifp->if_flags & IFF_PROMISC) { 1118 error = hw->mac.ops.update_xcast_mode(hw, 1119 IXGBEVF_XCAST_MODE_PROMISC); 1120 if (error == IXGBE_ERR_NOT_TRUSTED) { 1121 device_printf(adapter->dev, 1122 "this interface is not trusted\n"); 1123 error = EPERM; 1124 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 1125 device_printf(adapter->dev, 1126 "the PF doesn't support promisc mode\n"); 1127 error = EOPNOTSUPP; 1128 } else if (error == IXGBE_ERR_NOT_IN_PROMISC) { 1129 device_printf(adapter->dev, 1130 "the PF may not in promisc mode\n"); 1131 error = EINVAL; 1132 } else if (error) { 1133 device_printf(adapter->dev, 1134 "failed to set promisc mode. error = %d\n", 1135 error); 1136 error = EIO; 1137 } else 1138 return 0; 1139 rc = error; 1140 } 1141 1142 /* 2: For ALLMULTI or normal */ 1143 ETHER_LOCK(ec); 1144 ETHER_FIRST_MULTI(step, ec, enm); 1145 while (enm != NULL) { 1146 if ((mcnt >= IXGBE_MAX_VF_MC) || 1147 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 1148 ETHER_ADDR_LEN) != 0)) { 1149 overflow = true; 1150 break; 1151 } 1152 bcopy(enm->enm_addrlo, 1153 &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS], 1154 IXGBE_ETH_LENGTH_OF_ADDRESS); 1155 mcnt++; 1156 ETHER_NEXT_MULTI(step, enm); 1157 } 1158 ETHER_UNLOCK(ec); 1159 1160 /* 3: For ALLMULTI */ 1161 if (overflow) { 1162 error = hw->mac.ops.update_xcast_mode(hw, 1163 IXGBEVF_XCAST_MODE_ALLMULTI); 1164 if (error == IXGBE_ERR_NOT_TRUSTED) { 1165 device_printf(adapter->dev, 1166 "this interface is not trusted\n"); 1167 error = EPERM; 1168 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 1169 device_printf(adapter->dev, 1170 "the PF doesn't support allmulti mode\n"); 1171 error = EOPNOTSUPP; 1172 } else if (error) { 1173 device_printf(adapter->dev, 1174 "number of Ethernet multicast addresses " 1175 "exceeds the limit (%d). error = %d\n", 1176 IXGBE_MAX_VF_MC, error); 1177 error = ENOSPC; 1178 } else { 1179 ETHER_LOCK(ec); 1180 ec->ec_flags |= ETHER_F_ALLMULTI; 1181 ETHER_UNLOCK(ec); 1182 return rc; /* Promisc might failed */ 1183 } 1184 1185 if (rc == 0) 1186 rc = error; 1187 1188 /* Continue to update the multicast table as many as we can */ 1189 } 1190 1191 /* 4: For normal operation */ 1192 error = hw->mac.ops.update_xcast_mode(hw, IXGBEVF_XCAST_MODE_MULTI); 1193 if ((error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) || (error == 0)) { 1194 /* Normal operation */ 1195 ETHER_LOCK(ec); 1196 ec->ec_flags &= ~ETHER_F_ALLMULTI; 1197 ETHER_UNLOCK(ec); 1198 error = 0; 1199 } else if (error) { 1200 device_printf(adapter->dev, 1201 "failed to set Ethernet multicast address " 1202 "operation to normal. error = %d\n", error); 1203 } 1204 1205 update_ptr = mta; 1206 1207 error = adapter->hw.mac.ops.update_mc_addr_list(&adapter->hw, 1208 update_ptr, mcnt, ixv_mc_array_itr, TRUE); 1209 if (rc == 0) 1210 rc = error; 1211 1212 return rc; 1213 } /* ixv_set_rxfilter */ 1214 1215 /************************************************************************ 1216 * ixv_mc_array_itr 1217 * 1218 * An iterator function needed by the multicast shared code. 1219 * It feeds the shared code routine the addresses in the 1220 * array of ixv_set_rxfilter() one by one. 1221 ************************************************************************/ 1222 static u8 * 1223 ixv_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 1224 { 1225 u8 *addr = *update_ptr; 1226 u8 *newptr; 1227 1228 *vmdq = 0; 1229 1230 newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS; 1231 *update_ptr = newptr; 1232 1233 return addr; 1234 } /* ixv_mc_array_itr */ 1235 1236 /************************************************************************ 1237 * ixv_local_timer - Timer routine 1238 * 1239 * Checks for link status, updates statistics, 1240 * and runs the watchdog check. 1241 ************************************************************************/ 1242 static void 1243 ixv_local_timer(void *arg) 1244 { 1245 struct adapter *adapter = arg; 1246 1247 IXGBE_CORE_LOCK(adapter); 1248 ixv_local_timer_locked(adapter); 1249 IXGBE_CORE_UNLOCK(adapter); 1250 } 1251 1252 static void 1253 ixv_local_timer_locked(void *arg) 1254 { 1255 struct adapter *adapter = arg; 1256 device_t dev = adapter->dev; 1257 struct ix_queue *que = adapter->queues; 1258 u64 queues = 0; 1259 u64 v0, v1, v2, v3, v4, v5, v6, v7; 1260 int hung = 0; 1261 int i; 1262 1263 KASSERT(mutex_owned(&adapter->core_mtx)); 1264 1265 if (ixv_check_link(adapter)) { 1266 ixv_init_locked(adapter); 1267 return; 1268 } 1269 1270 /* Stats Update */ 1271 ixv_update_stats(adapter); 1272 1273 /* Update some event counters */ 1274 v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0; 1275 que = adapter->queues; 1276 for (i = 0; i < adapter->num_queues; i++, que++) { 1277 struct tx_ring *txr = que->txr; 1278 1279 v0 += txr->q_efbig_tx_dma_setup; 1280 v1 += txr->q_mbuf_defrag_failed; 1281 v2 += txr->q_efbig2_tx_dma_setup; 1282 v3 += txr->q_einval_tx_dma_setup; 1283 v4 += txr->q_other_tx_dma_setup; 1284 v5 += txr->q_eagain_tx_dma_setup; 1285 v6 += txr->q_enomem_tx_dma_setup; 1286 v7 += txr->q_tso_err; 1287 } 1288 adapter->efbig_tx_dma_setup.ev_count = v0; 1289 adapter->mbuf_defrag_failed.ev_count = v1; 1290 adapter->efbig2_tx_dma_setup.ev_count = v2; 1291 adapter->einval_tx_dma_setup.ev_count = v3; 1292 adapter->other_tx_dma_setup.ev_count = v4; 1293 adapter->eagain_tx_dma_setup.ev_count = v5; 1294 adapter->enomem_tx_dma_setup.ev_count = v6; 1295 adapter->tso_err.ev_count = v7; 1296 1297 /* 1298 * Check the TX queues status 1299 * - mark hung queues so we don't schedule on them 1300 * - watchdog only if all queues show hung 1301 */ 1302 que = adapter->queues; 1303 for (i = 0; i < adapter->num_queues; i++, que++) { 1304 /* Keep track of queues with work for soft irq */ 1305 if (que->txr->busy) 1306 queues |= ((u64)1 << que->me); 1307 /* 1308 * Each time txeof runs without cleaning, but there 1309 * are uncleaned descriptors it increments busy. If 1310 * we get to the MAX we declare it hung. 1311 */ 1312 if (que->busy == IXGBE_QUEUE_HUNG) { 1313 ++hung; 1314 /* Mark the queue as inactive */ 1315 adapter->active_queues &= ~((u64)1 << que->me); 1316 continue; 1317 } else { 1318 /* Check if we've come back from hung */ 1319 if ((adapter->active_queues & ((u64)1 << que->me)) == 0) 1320 adapter->active_queues |= ((u64)1 << que->me); 1321 } 1322 if (que->busy >= IXGBE_MAX_TX_BUSY) { 1323 device_printf(dev, 1324 "Warning queue %d appears to be hung!\n", i); 1325 que->txr->busy = IXGBE_QUEUE_HUNG; 1326 ++hung; 1327 } 1328 } 1329 1330 /* Only truly watchdog if all queues show hung */ 1331 if (hung == adapter->num_queues) 1332 goto watchdog; 1333 #if 0 1334 else if (queues != 0) { /* Force an IRQ on queues with work */ 1335 ixv_rearm_queues(adapter, queues); 1336 } 1337 #endif 1338 1339 callout_reset(&adapter->timer, hz, ixv_local_timer, adapter); 1340 1341 return; 1342 1343 watchdog: 1344 1345 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 1346 adapter->ifp->if_flags &= ~IFF_RUNNING; 1347 adapter->watchdog_events.ev_count++; 1348 ixv_init_locked(adapter); 1349 } /* ixv_local_timer */ 1350 1351 /************************************************************************ 1352 * ixv_update_link_status - Update OS on link state 1353 * 1354 * Note: Only updates the OS on the cached link state. 1355 * The real check of the hardware only happens with 1356 * a link interrupt. 1357 ************************************************************************/ 1358 static void 1359 ixv_update_link_status(struct adapter *adapter) 1360 { 1361 struct ifnet *ifp = adapter->ifp; 1362 device_t dev = adapter->dev; 1363 1364 KASSERT(mutex_owned(&adapter->core_mtx)); 1365 1366 if (adapter->link_up) { 1367 if (adapter->link_active != LINK_STATE_UP) { 1368 if (bootverbose) { 1369 const char *bpsmsg; 1370 1371 switch (adapter->link_speed) { 1372 case IXGBE_LINK_SPEED_10GB_FULL: 1373 bpsmsg = "10 Gbps"; 1374 break; 1375 case IXGBE_LINK_SPEED_5GB_FULL: 1376 bpsmsg = "5 Gbps"; 1377 break; 1378 case IXGBE_LINK_SPEED_2_5GB_FULL: 1379 bpsmsg = "2.5 Gbps"; 1380 break; 1381 case IXGBE_LINK_SPEED_1GB_FULL: 1382 bpsmsg = "1 Gbps"; 1383 break; 1384 case IXGBE_LINK_SPEED_100_FULL: 1385 bpsmsg = "100 Mbps"; 1386 break; 1387 case IXGBE_LINK_SPEED_10_FULL: 1388 bpsmsg = "10 Mbps"; 1389 break; 1390 default: 1391 bpsmsg = "unknown speed"; 1392 break; 1393 } 1394 device_printf(dev, "Link is up %s %s \n", 1395 bpsmsg, "Full Duplex"); 1396 } 1397 adapter->link_active = LINK_STATE_UP; 1398 if_link_state_change(ifp, LINK_STATE_UP); 1399 } 1400 } else { 1401 /* 1402 * Do it when link active changes to DOWN. i.e. 1403 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN 1404 * b) LINK_STATE_UP -> LINK_STATE_DOWN 1405 */ 1406 if (adapter->link_active != LINK_STATE_DOWN) { 1407 if (bootverbose) 1408 device_printf(dev, "Link is Down\n"); 1409 if_link_state_change(ifp, LINK_STATE_DOWN); 1410 adapter->link_active = LINK_STATE_DOWN; 1411 } 1412 } 1413 } /* ixv_update_link_status */ 1414 1415 1416 /************************************************************************ 1417 * ixv_stop - Stop the hardware 1418 * 1419 * Disables all traffic on the adapter by issuing a 1420 * global reset on the MAC and deallocates TX/RX buffers. 1421 ************************************************************************/ 1422 static void 1423 ixv_ifstop(struct ifnet *ifp, int disable) 1424 { 1425 struct adapter *adapter = ifp->if_softc; 1426 1427 IXGBE_CORE_LOCK(adapter); 1428 ixv_stop(adapter); 1429 IXGBE_CORE_UNLOCK(adapter); 1430 } 1431 1432 static void 1433 ixv_stop(void *arg) 1434 { 1435 struct ifnet *ifp; 1436 struct adapter *adapter = arg; 1437 struct ixgbe_hw *hw = &adapter->hw; 1438 1439 ifp = adapter->ifp; 1440 1441 KASSERT(mutex_owned(&adapter->core_mtx)); 1442 1443 INIT_DEBUGOUT("ixv_stop: begin\n"); 1444 ixv_disable_intr(adapter); 1445 1446 /* Tell the stack that the interface is no longer active */ 1447 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1448 1449 hw->mac.ops.reset_hw(hw); 1450 adapter->hw.adapter_stopped = FALSE; 1451 hw->mac.ops.stop_adapter(hw); 1452 callout_stop(&adapter->timer); 1453 1454 /* reprogram the RAR[0] in case user changed it. */ 1455 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 1456 1457 return; 1458 } /* ixv_stop */ 1459 1460 1461 /************************************************************************ 1462 * ixv_allocate_pci_resources 1463 ************************************************************************/ 1464 static int 1465 ixv_allocate_pci_resources(struct adapter *adapter, 1466 const struct pci_attach_args *pa) 1467 { 1468 pcireg_t memtype, csr; 1469 device_t dev = adapter->dev; 1470 bus_addr_t addr; 1471 int flags; 1472 1473 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 1474 switch (memtype) { 1475 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 1476 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 1477 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 1478 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 1479 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 1480 goto map_err; 1481 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 1482 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 1483 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 1484 } 1485 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 1486 adapter->osdep.mem_size, flags, 1487 &adapter->osdep.mem_bus_space_handle) != 0) { 1488 map_err: 1489 adapter->osdep.mem_size = 0; 1490 aprint_error_dev(dev, "unable to map BAR0\n"); 1491 return ENXIO; 1492 } 1493 /* 1494 * Enable address decoding for memory range in case it's not 1495 * set. 1496 */ 1497 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, 1498 PCI_COMMAND_STATUS_REG); 1499 csr |= PCI_COMMAND_MEM_ENABLE; 1500 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 1501 csr); 1502 break; 1503 default: 1504 aprint_error_dev(dev, "unexpected type on BAR0\n"); 1505 return ENXIO; 1506 } 1507 1508 /* Pick up the tuneable queues */ 1509 adapter->num_queues = ixv_num_queues; 1510 1511 return (0); 1512 } /* ixv_allocate_pci_resources */ 1513 1514 /************************************************************************ 1515 * ixv_free_pci_resources 1516 ************************************************************************/ 1517 static void 1518 ixv_free_pci_resources(struct adapter * adapter) 1519 { 1520 struct ix_queue *que = adapter->queues; 1521 int rid; 1522 1523 /* 1524 * Release all msix queue resources: 1525 */ 1526 for (int i = 0; i < adapter->num_queues; i++, que++) { 1527 if (que->res != NULL) 1528 pci_intr_disestablish(adapter->osdep.pc, 1529 adapter->osdep.ihs[i]); 1530 } 1531 1532 1533 /* Clean the Mailbox interrupt last */ 1534 rid = adapter->vector; 1535 1536 if (adapter->osdep.ihs[rid] != NULL) { 1537 pci_intr_disestablish(adapter->osdep.pc, 1538 adapter->osdep.ihs[rid]); 1539 adapter->osdep.ihs[rid] = NULL; 1540 } 1541 1542 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1543 adapter->osdep.nintrs); 1544 1545 if (adapter->osdep.mem_size != 0) { 1546 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 1547 adapter->osdep.mem_bus_space_handle, 1548 adapter->osdep.mem_size); 1549 } 1550 1551 return; 1552 } /* ixv_free_pci_resources */ 1553 1554 /************************************************************************ 1555 * ixv_setup_interface 1556 * 1557 * Setup networking device structure and register an interface. 1558 ************************************************************************/ 1559 static int 1560 ixv_setup_interface(device_t dev, struct adapter *adapter) 1561 { 1562 struct ethercom *ec = &adapter->osdep.ec; 1563 struct ifnet *ifp; 1564 int rv; 1565 1566 INIT_DEBUGOUT("ixv_setup_interface: begin"); 1567 1568 ifp = adapter->ifp = &ec->ec_if; 1569 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 1570 ifp->if_baudrate = IF_Gbps(10); 1571 ifp->if_init = ixv_init; 1572 ifp->if_stop = ixv_ifstop; 1573 ifp->if_softc = adapter; 1574 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1575 #ifdef IXGBE_MPSAFE 1576 ifp->if_extflags = IFEF_MPSAFE; 1577 #endif 1578 ifp->if_ioctl = ixv_ioctl; 1579 if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) { 1580 #if 0 1581 ixv_start_locked = ixgbe_legacy_start_locked; 1582 #endif 1583 } else { 1584 ifp->if_transmit = ixgbe_mq_start; 1585 #if 0 1586 ixv_start_locked = ixgbe_mq_start_locked; 1587 #endif 1588 } 1589 ifp->if_start = ixgbe_legacy_start; 1590 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 1591 IFQ_SET_READY(&ifp->if_snd); 1592 1593 rv = if_initialize(ifp); 1594 if (rv != 0) { 1595 aprint_error_dev(dev, "if_initialize failed(%d)\n", rv); 1596 return rv; 1597 } 1598 adapter->ipq = if_percpuq_create(&adapter->osdep.ec.ec_if); 1599 ether_ifattach(ifp, adapter->hw.mac.addr); 1600 aprint_normal_dev(dev, "Ethernet address %s\n", 1601 ether_sprintf(adapter->hw.mac.addr)); 1602 /* 1603 * We use per TX queue softint, so if_deferred_start_init() isn't 1604 * used. 1605 */ 1606 ether_set_ifflags_cb(ec, ixv_ifflags_cb); 1607 1608 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR; 1609 1610 /* 1611 * Tell the upper layer(s) we support long frames. 1612 */ 1613 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 1614 1615 /* Set capability flags */ 1616 ifp->if_capabilities |= IFCAP_HWCSUM 1617 | IFCAP_TSOv4 1618 | IFCAP_TSOv6; 1619 ifp->if_capenable = 0; 1620 1621 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER 1622 | ETHERCAP_VLAN_HWTAGGING 1623 | ETHERCAP_VLAN_HWCSUM 1624 | ETHERCAP_JUMBO_MTU 1625 | ETHERCAP_VLAN_MTU; 1626 1627 /* Enable the above capabilities by default */ 1628 ec->ec_capenable = ec->ec_capabilities; 1629 1630 /* Don't enable LRO by default */ 1631 #if 0 1632 /* NetBSD doesn't support LRO yet */ 1633 ifp->if_capabilities |= IFCAP_LRO; 1634 #endif 1635 1636 /* 1637 * Specify the media types supported by this adapter and register 1638 * callbacks to update media and link information 1639 */ 1640 ec->ec_ifmedia = &adapter->media; 1641 ifmedia_init(&adapter->media, IFM_IMASK, ixv_media_change, 1642 ixv_media_status); 1643 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1644 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1645 1646 if_register(ifp); 1647 1648 return 0; 1649 } /* ixv_setup_interface */ 1650 1651 1652 /************************************************************************ 1653 * ixv_initialize_transmit_units - Enable transmit unit. 1654 ************************************************************************/ 1655 static void 1656 ixv_initialize_transmit_units(struct adapter *adapter) 1657 { 1658 struct tx_ring *txr = adapter->tx_rings; 1659 struct ixgbe_hw *hw = &adapter->hw; 1660 int i; 1661 1662 for (i = 0; i < adapter->num_queues; i++, txr++) { 1663 u64 tdba = txr->txdma.dma_paddr; 1664 u32 txctrl, txdctl; 1665 int j = txr->me; 1666 1667 /* Set WTHRESH to 8, burst writeback */ 1668 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1669 txdctl |= (8 << 16); 1670 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1671 1672 /* Set the HW Tx Head and Tail indices */ 1673 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(j), 0); 1674 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(j), 0); 1675 1676 /* Set Tx Tail register */ 1677 txr->tail = IXGBE_VFTDT(j); 1678 1679 txr->txr_no_space = false; 1680 1681 /* Set Ring parameters */ 1682 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j), 1683 (tdba & 0x00000000ffffffffULL)); 1684 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32)); 1685 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j), 1686 adapter->num_tx_desc * sizeof(struct ixgbe_legacy_tx_desc)); 1687 txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j)); 1688 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 1689 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl); 1690 1691 /* Now enable */ 1692 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1693 txdctl |= IXGBE_TXDCTL_ENABLE; 1694 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1695 } 1696 1697 return; 1698 } /* ixv_initialize_transmit_units */ 1699 1700 1701 /************************************************************************ 1702 * ixv_initialize_rss_mapping 1703 ************************************************************************/ 1704 static void 1705 ixv_initialize_rss_mapping(struct adapter *adapter) 1706 { 1707 struct ixgbe_hw *hw = &adapter->hw; 1708 u32 reta = 0, mrqc, rss_key[10]; 1709 int queue_id; 1710 int i, j; 1711 u32 rss_hash_config; 1712 1713 /* force use default RSS key. */ 1714 #ifdef __NetBSD__ 1715 rss_getkey((uint8_t *) &rss_key); 1716 #else 1717 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1718 /* Fetch the configured RSS key */ 1719 rss_getkey((uint8_t *)&rss_key); 1720 } else { 1721 /* set up random bits */ 1722 cprng_fast(&rss_key, sizeof(rss_key)); 1723 } 1724 #endif 1725 1726 /* Now fill out hash function seeds */ 1727 for (i = 0; i < 10; i++) 1728 IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]); 1729 1730 /* Set up the redirection table */ 1731 for (i = 0, j = 0; i < 64; i++, j++) { 1732 if (j == adapter->num_queues) 1733 j = 0; 1734 1735 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1736 /* 1737 * Fetch the RSS bucket id for the given indirection 1738 * entry. Cap it at the number of configured buckets 1739 * (which is num_queues.) 1740 */ 1741 queue_id = rss_get_indirection_to_bucket(i); 1742 queue_id = queue_id % adapter->num_queues; 1743 } else 1744 queue_id = j; 1745 1746 /* 1747 * The low 8 bits are for hash value (n+0); 1748 * The next 8 bits are for hash value (n+1), etc. 1749 */ 1750 reta >>= 8; 1751 reta |= ((uint32_t)queue_id) << 24; 1752 if ((i & 3) == 3) { 1753 IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), reta); 1754 reta = 0; 1755 } 1756 } 1757 1758 /* Perform hash on these packet types */ 1759 if (adapter->feat_en & IXGBE_FEATURE_RSS) 1760 rss_hash_config = rss_gethashconfig(); 1761 else { 1762 /* 1763 * Disable UDP - IP fragments aren't currently being handled 1764 * and so we end up with a mix of 2-tuple and 4-tuple 1765 * traffic. 1766 */ 1767 rss_hash_config = RSS_HASHTYPE_RSS_IPV4 1768 | RSS_HASHTYPE_RSS_TCP_IPV4 1769 | RSS_HASHTYPE_RSS_IPV6 1770 | RSS_HASHTYPE_RSS_TCP_IPV6; 1771 } 1772 1773 mrqc = IXGBE_MRQC_RSSEN; 1774 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 1775 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 1776 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 1777 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 1778 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 1779 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 1780 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 1781 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 1782 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 1783 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_IPV6_EX defined, but not supported\n", 1784 __func__); 1785 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 1786 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_TCP_IPV6_EX defined, but not supported\n", 1787 __func__); 1788 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 1789 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 1790 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 1791 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 1792 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 1793 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_UDP_IPV6_EX defined, but not supported\n", 1794 __func__); 1795 IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, mrqc); 1796 } /* ixv_initialize_rss_mapping */ 1797 1798 1799 /************************************************************************ 1800 * ixv_initialize_receive_units - Setup receive registers and features. 1801 ************************************************************************/ 1802 static void 1803 ixv_initialize_receive_units(struct adapter *adapter) 1804 { 1805 struct rx_ring *rxr = adapter->rx_rings; 1806 struct ixgbe_hw *hw = &adapter->hw; 1807 struct ifnet *ifp = adapter->ifp; 1808 u32 bufsz, psrtype; 1809 1810 if (ifp->if_mtu > ETHERMTU) 1811 bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1812 else 1813 bufsz = 2048 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1814 1815 psrtype = IXGBE_PSRTYPE_TCPHDR 1816 | IXGBE_PSRTYPE_UDPHDR 1817 | IXGBE_PSRTYPE_IPV4HDR 1818 | IXGBE_PSRTYPE_IPV6HDR 1819 | IXGBE_PSRTYPE_L2HDR; 1820 1821 if (adapter->num_queues > 1) 1822 psrtype |= 1 << 29; 1823 1824 IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype); 1825 1826 /* Tell PF our max_frame size */ 1827 if (ixgbevf_rlpml_set_vf(hw, adapter->max_frame_size) != 0) { 1828 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"); 1829 } 1830 1831 for (int i = 0; i < adapter->num_queues; i++, rxr++) { 1832 u64 rdba = rxr->rxdma.dma_paddr; 1833 u32 reg, rxdctl; 1834 int j = rxr->me; 1835 1836 /* Disable the queue */ 1837 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)); 1838 rxdctl &= ~IXGBE_RXDCTL_ENABLE; 1839 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1840 for (int k = 0; k < 10; k++) { 1841 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1842 IXGBE_RXDCTL_ENABLE) 1843 msec_delay(1); 1844 else 1845 break; 1846 } 1847 wmb(); 1848 /* Setup the Base and Length of the Rx Descriptor Ring */ 1849 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j), 1850 (rdba & 0x00000000ffffffffULL)); 1851 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32)); 1852 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j), 1853 adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc)); 1854 1855 /* Reset the ring indices */ 1856 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0); 1857 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0); 1858 1859 /* Set up the SRRCTL register */ 1860 reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j)); 1861 reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 1862 reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 1863 reg |= bufsz; 1864 reg |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 1865 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg); 1866 1867 /* Capture Rx Tail index */ 1868 rxr->tail = IXGBE_VFRDT(rxr->me); 1869 1870 /* Do the queue enabling last */ 1871 rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME; 1872 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1873 for (int k = 0; k < 10; k++) { 1874 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1875 IXGBE_RXDCTL_ENABLE) 1876 break; 1877 msec_delay(1); 1878 } 1879 wmb(); 1880 1881 /* Set the Tail Pointer */ 1882 #ifdef DEV_NETMAP 1883 /* 1884 * In netmap mode, we must preserve the buffers made 1885 * available to userspace before the if_init() 1886 * (this is true by default on the TX side, because 1887 * init makes all buffers available to userspace). 1888 * 1889 * netmap_reset() and the device specific routines 1890 * (e.g. ixgbe_setup_receive_rings()) map these 1891 * buffers at the end of the NIC ring, so here we 1892 * must set the RDT (tail) register to make sure 1893 * they are not overwritten. 1894 * 1895 * In this driver the NIC ring starts at RDH = 0, 1896 * RDT points to the last slot available for reception (?), 1897 * so RDT = num_rx_desc - 1 means the whole ring is available. 1898 */ 1899 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 1900 (ifp->if_capenable & IFCAP_NETMAP)) { 1901 struct netmap_adapter *na = NA(adapter->ifp); 1902 struct netmap_kring *kring = na->rx_rings[i]; 1903 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 1904 1905 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t); 1906 } else 1907 #endif /* DEV_NETMAP */ 1908 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 1909 adapter->num_rx_desc - 1); 1910 } 1911 1912 if (adapter->hw.mac.type >= ixgbe_mac_X550_vf) 1913 ixv_initialize_rss_mapping(adapter); 1914 } /* ixv_initialize_receive_units */ 1915 1916 /************************************************************************ 1917 * ixv_sysctl_tdh_handler - Transmit Descriptor Head handler function 1918 * 1919 * Retrieves the TDH value from the hardware 1920 ************************************************************************/ 1921 static int 1922 ixv_sysctl_tdh_handler(SYSCTLFN_ARGS) 1923 { 1924 struct sysctlnode node = *rnode; 1925 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 1926 uint32_t val; 1927 1928 if (!txr) 1929 return (0); 1930 1931 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_VFTDH(txr->me)); 1932 node.sysctl_data = &val; 1933 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1934 } /* ixv_sysctl_tdh_handler */ 1935 1936 /************************************************************************ 1937 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 1938 * 1939 * Retrieves the TDT value from the hardware 1940 ************************************************************************/ 1941 static int 1942 ixv_sysctl_tdt_handler(SYSCTLFN_ARGS) 1943 { 1944 struct sysctlnode node = *rnode; 1945 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 1946 uint32_t val; 1947 1948 if (!txr) 1949 return (0); 1950 1951 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_VFTDT(txr->me)); 1952 node.sysctl_data = &val; 1953 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1954 } /* ixv_sysctl_tdt_handler */ 1955 1956 /************************************************************************ 1957 * ixv_sysctl_next_to_check_handler - Receive Descriptor next to check 1958 * handler function 1959 * 1960 * Retrieves the next_to_check value 1961 ************************************************************************/ 1962 static int 1963 ixv_sysctl_next_to_check_handler(SYSCTLFN_ARGS) 1964 { 1965 struct sysctlnode node = *rnode; 1966 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 1967 uint32_t val; 1968 1969 if (!rxr) 1970 return (0); 1971 1972 val = rxr->next_to_check; 1973 node.sysctl_data = &val; 1974 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1975 } /* ixv_sysctl_next_to_check_handler */ 1976 1977 /************************************************************************ 1978 * ixv_sysctl_rdh_handler - Receive Descriptor Head handler function 1979 * 1980 * Retrieves the RDH value from the hardware 1981 ************************************************************************/ 1982 static int 1983 ixv_sysctl_rdh_handler(SYSCTLFN_ARGS) 1984 { 1985 struct sysctlnode node = *rnode; 1986 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 1987 uint32_t val; 1988 1989 if (!rxr) 1990 return (0); 1991 1992 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_VFRDH(rxr->me)); 1993 node.sysctl_data = &val; 1994 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1995 } /* ixv_sysctl_rdh_handler */ 1996 1997 /************************************************************************ 1998 * ixv_sysctl_rdt_handler - Receive Descriptor Tail handler function 1999 * 2000 * Retrieves the RDT value from the hardware 2001 ************************************************************************/ 2002 static int 2003 ixv_sysctl_rdt_handler(SYSCTLFN_ARGS) 2004 { 2005 struct sysctlnode node = *rnode; 2006 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2007 uint32_t val; 2008 2009 if (!rxr) 2010 return (0); 2011 2012 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_VFRDT(rxr->me)); 2013 node.sysctl_data = &val; 2014 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2015 } /* ixv_sysctl_rdt_handler */ 2016 2017 static void 2018 ixv_setup_vlan_tagging(struct adapter *adapter) 2019 { 2020 struct ethercom *ec = &adapter->osdep.ec; 2021 struct ixgbe_hw *hw = &adapter->hw; 2022 struct rx_ring *rxr; 2023 u32 ctrl; 2024 int i; 2025 bool hwtagging; 2026 2027 /* Enable HW tagging only if any vlan is attached */ 2028 hwtagging = (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) 2029 && VLAN_ATTACHED(ec); 2030 2031 /* Enable the queues */ 2032 for (i = 0; i < adapter->num_queues; i++) { 2033 rxr = &adapter->rx_rings[i]; 2034 ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(rxr->me)); 2035 if (hwtagging) 2036 ctrl |= IXGBE_RXDCTL_VME; 2037 else 2038 ctrl &= ~IXGBE_RXDCTL_VME; 2039 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(rxr->me), ctrl); 2040 /* 2041 * Let Rx path know that it needs to store VLAN tag 2042 * as part of extra mbuf info. 2043 */ 2044 rxr->vtag_strip = hwtagging ? TRUE : FALSE; 2045 } 2046 } /* ixv_setup_vlan_tagging */ 2047 2048 /************************************************************************ 2049 * ixv_setup_vlan_support 2050 ************************************************************************/ 2051 static int 2052 ixv_setup_vlan_support(struct adapter *adapter) 2053 { 2054 struct ethercom *ec = &adapter->osdep.ec; 2055 struct ixgbe_hw *hw = &adapter->hw; 2056 u32 vid, vfta, retry; 2057 struct vlanid_list *vlanidp; 2058 int rv, error = 0; 2059 2060 /* 2061 * This function is called from both if_init and ifflags_cb() 2062 * on NetBSD. 2063 */ 2064 2065 /* 2066 * Part 1: 2067 * Setup VLAN HW tagging 2068 */ 2069 ixv_setup_vlan_tagging(adapter); 2070 2071 if (!VLAN_ATTACHED(ec)) 2072 return 0; 2073 2074 /* 2075 * Part 2: 2076 * Setup VLAN HW filter 2077 */ 2078 /* Cleanup shadow_vfta */ 2079 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) 2080 adapter->shadow_vfta[i] = 0; 2081 /* Generate shadow_vfta from ec_vids */ 2082 ETHER_LOCK(ec); 2083 SIMPLEQ_FOREACH(vlanidp, &ec->ec_vids, vid_list) { 2084 uint32_t idx; 2085 2086 idx = vlanidp->vid / 32; 2087 KASSERT(idx < IXGBE_VFTA_SIZE); 2088 adapter->shadow_vfta[idx] |= (u32)1 << (vlanidp->vid % 32); 2089 } 2090 ETHER_UNLOCK(ec); 2091 2092 /* 2093 * A soft reset zero's out the VFTA, so 2094 * we need to repopulate it now. 2095 */ 2096 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) { 2097 if (adapter->shadow_vfta[i] == 0) 2098 continue; 2099 vfta = adapter->shadow_vfta[i]; 2100 /* 2101 * Reconstruct the vlan id's 2102 * based on the bits set in each 2103 * of the array ints. 2104 */ 2105 for (int j = 0; j < 32; j++) { 2106 retry = 0; 2107 if ((vfta & ((u32)1 << j)) == 0) 2108 continue; 2109 vid = (i * 32) + j; 2110 2111 /* Call the shared code mailbox routine */ 2112 while ((rv = hw->mac.ops.set_vfta(hw, vid, 0, TRUE, 2113 FALSE)) != 0) { 2114 if (++retry > 5) { 2115 device_printf(adapter->dev, 2116 "%s: max retry exceeded\n", 2117 __func__); 2118 break; 2119 } 2120 } 2121 if (rv != 0) { 2122 device_printf(adapter->dev, 2123 "failed to set vlan %d\n", vid); 2124 error = EACCES; 2125 } 2126 } 2127 } 2128 return error; 2129 } /* ixv_setup_vlan_support */ 2130 2131 static int 2132 ixv_vlan_cb(struct ethercom *ec, uint16_t vid, bool set) 2133 { 2134 struct ifnet *ifp = &ec->ec_if; 2135 struct adapter *adapter = ifp->if_softc; 2136 int rv; 2137 2138 if (set) 2139 rv = ixv_register_vlan(adapter, vid); 2140 else 2141 rv = ixv_unregister_vlan(adapter, vid); 2142 2143 if (rv != 0) 2144 return rv; 2145 2146 /* 2147 * Control VLAN HW tagging when ec_nvlan is changed from 1 to 0 2148 * or 0 to 1. 2149 */ 2150 if ((set && (ec->ec_nvlans == 1)) || (!set && (ec->ec_nvlans == 0))) 2151 ixv_setup_vlan_tagging(adapter); 2152 2153 return rv; 2154 } 2155 2156 /************************************************************************ 2157 * ixv_register_vlan 2158 * 2159 * Run via a vlan config EVENT, it enables us to use the 2160 * HW Filter table since we can get the vlan id. This just 2161 * creates the entry in the soft version of the VFTA, init 2162 * will repopulate the real table. 2163 ************************************************************************/ 2164 static int 2165 ixv_register_vlan(struct adapter *adapter, u16 vtag) 2166 { 2167 struct ixgbe_hw *hw = &adapter->hw; 2168 u16 index, bit; 2169 int error; 2170 2171 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2172 return EINVAL; 2173 IXGBE_CORE_LOCK(adapter); 2174 index = (vtag >> 5) & 0x7F; 2175 bit = vtag & 0x1F; 2176 adapter->shadow_vfta[index] |= ((u32)1 << bit); 2177 error = hw->mac.ops.set_vfta(hw, vtag, 0, true, false); 2178 IXGBE_CORE_UNLOCK(adapter); 2179 2180 if (error != 0) { 2181 device_printf(adapter->dev, "failed to register vlan %hu\n", 2182 vtag); 2183 error = EACCES; 2184 } 2185 return error; 2186 } /* ixv_register_vlan */ 2187 2188 /************************************************************************ 2189 * ixv_unregister_vlan 2190 * 2191 * Run via a vlan unconfig EVENT, remove our entry 2192 * in the soft vfta. 2193 ************************************************************************/ 2194 static int 2195 ixv_unregister_vlan(struct adapter *adapter, u16 vtag) 2196 { 2197 struct ixgbe_hw *hw = &adapter->hw; 2198 u16 index, bit; 2199 int error; 2200 2201 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2202 return EINVAL; 2203 2204 IXGBE_CORE_LOCK(adapter); 2205 index = (vtag >> 5) & 0x7F; 2206 bit = vtag & 0x1F; 2207 adapter->shadow_vfta[index] &= ~((u32)1 << bit); 2208 error = hw->mac.ops.set_vfta(hw, vtag, 0, false, false); 2209 IXGBE_CORE_UNLOCK(adapter); 2210 2211 if (error != 0) { 2212 device_printf(adapter->dev, "failed to unregister vlan %hu\n", 2213 vtag); 2214 error = EIO; 2215 } 2216 return error; 2217 } /* ixv_unregister_vlan */ 2218 2219 /************************************************************************ 2220 * ixv_enable_intr 2221 ************************************************************************/ 2222 static void 2223 ixv_enable_intr(struct adapter *adapter) 2224 { 2225 struct ixgbe_hw *hw = &adapter->hw; 2226 struct ix_queue *que = adapter->queues; 2227 u32 mask; 2228 int i; 2229 2230 /* For VTEIAC */ 2231 mask = (1 << adapter->vector); 2232 for (i = 0; i < adapter->num_queues; i++, que++) 2233 mask |= (1 << que->msix); 2234 IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask); 2235 2236 /* For VTEIMS */ 2237 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, (1 << adapter->vector)); 2238 que = adapter->queues; 2239 for (i = 0; i < adapter->num_queues; i++, que++) 2240 ixv_enable_queue(adapter, que->msix); 2241 2242 IXGBE_WRITE_FLUSH(hw); 2243 } /* ixv_enable_intr */ 2244 2245 /************************************************************************ 2246 * ixv_disable_intr 2247 ************************************************************************/ 2248 static void 2249 ixv_disable_intr(struct adapter *adapter) 2250 { 2251 struct ix_queue *que = adapter->queues; 2252 2253 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIAC, 0); 2254 2255 /* disable interrupts other than queues */ 2256 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIMC, adapter->vector); 2257 2258 for (int i = 0; i < adapter->num_queues; i++, que++) 2259 ixv_disable_queue(adapter, que->msix); 2260 2261 IXGBE_WRITE_FLUSH(&adapter->hw); 2262 } /* ixv_disable_intr */ 2263 2264 /************************************************************************ 2265 * ixv_set_ivar 2266 * 2267 * Setup the correct IVAR register for a particular MSI-X interrupt 2268 * - entry is the register array entry 2269 * - vector is the MSI-X vector for this queue 2270 * - type is RX/TX/MISC 2271 ************************************************************************/ 2272 static void 2273 ixv_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 2274 { 2275 struct ixgbe_hw *hw = &adapter->hw; 2276 u32 ivar, index; 2277 2278 vector |= IXGBE_IVAR_ALLOC_VAL; 2279 2280 if (type == -1) { /* MISC IVAR */ 2281 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); 2282 ivar &= ~0xFF; 2283 ivar |= vector; 2284 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar); 2285 } else { /* RX/TX IVARS */ 2286 index = (16 * (entry & 1)) + (8 * type); 2287 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(entry >> 1)); 2288 ivar &= ~(0xffUL << index); 2289 ivar |= ((u32)vector << index); 2290 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(entry >> 1), ivar); 2291 } 2292 } /* ixv_set_ivar */ 2293 2294 /************************************************************************ 2295 * ixv_configure_ivars 2296 ************************************************************************/ 2297 static void 2298 ixv_configure_ivars(struct adapter *adapter) 2299 { 2300 struct ix_queue *que = adapter->queues; 2301 2302 /* XXX We should sync EITR value calculation with ixgbe.c? */ 2303 2304 for (int i = 0; i < adapter->num_queues; i++, que++) { 2305 /* First the RX queue entry */ 2306 ixv_set_ivar(adapter, i, que->msix, 0); 2307 /* ... and the TX */ 2308 ixv_set_ivar(adapter, i, que->msix, 1); 2309 /* Set an initial value in EITR */ 2310 ixv_eitr_write(adapter, que->msix, IXGBE_EITR_DEFAULT); 2311 } 2312 2313 /* For the mailbox interrupt */ 2314 ixv_set_ivar(adapter, 1, adapter->vector, -1); 2315 } /* ixv_configure_ivars */ 2316 2317 2318 /************************************************************************ 2319 * ixv_save_stats 2320 * 2321 * The VF stats registers never have a truly virgin 2322 * starting point, so this routine tries to make an 2323 * artificial one, marking ground zero on attach as 2324 * it were. 2325 ************************************************************************/ 2326 static void 2327 ixv_save_stats(struct adapter *adapter) 2328 { 2329 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2330 2331 if (stats->vfgprc.ev_count || stats->vfgptc.ev_count) { 2332 stats->saved_reset_vfgprc += 2333 stats->vfgprc.ev_count - stats->base_vfgprc; 2334 stats->saved_reset_vfgptc += 2335 stats->vfgptc.ev_count - stats->base_vfgptc; 2336 stats->saved_reset_vfgorc += 2337 stats->vfgorc.ev_count - stats->base_vfgorc; 2338 stats->saved_reset_vfgotc += 2339 stats->vfgotc.ev_count - stats->base_vfgotc; 2340 stats->saved_reset_vfmprc += 2341 stats->vfmprc.ev_count - stats->base_vfmprc; 2342 } 2343 } /* ixv_save_stats */ 2344 2345 /************************************************************************ 2346 * ixv_init_stats 2347 ************************************************************************/ 2348 static void 2349 ixv_init_stats(struct adapter *adapter) 2350 { 2351 struct ixgbe_hw *hw = &adapter->hw; 2352 2353 adapter->stats.vf.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC); 2354 adapter->stats.vf.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB); 2355 adapter->stats.vf.last_vfgorc |= 2356 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32); 2357 2358 adapter->stats.vf.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC); 2359 adapter->stats.vf.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB); 2360 adapter->stats.vf.last_vfgotc |= 2361 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32); 2362 2363 adapter->stats.vf.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC); 2364 2365 adapter->stats.vf.base_vfgprc = adapter->stats.vf.last_vfgprc; 2366 adapter->stats.vf.base_vfgorc = adapter->stats.vf.last_vfgorc; 2367 adapter->stats.vf.base_vfgptc = adapter->stats.vf.last_vfgptc; 2368 adapter->stats.vf.base_vfgotc = adapter->stats.vf.last_vfgotc; 2369 adapter->stats.vf.base_vfmprc = adapter->stats.vf.last_vfmprc; 2370 } /* ixv_init_stats */ 2371 2372 #define UPDATE_STAT_32(reg, last, count) \ 2373 { \ 2374 u32 current = IXGBE_READ_REG(hw, (reg)); \ 2375 if (current < (last)) \ 2376 count.ev_count += 0x100000000LL; \ 2377 (last) = current; \ 2378 count.ev_count &= 0xFFFFFFFF00000000LL; \ 2379 count.ev_count |= current; \ 2380 } 2381 2382 #define UPDATE_STAT_36(lsb, msb, last, count) \ 2383 { \ 2384 u64 cur_lsb = IXGBE_READ_REG(hw, (lsb)); \ 2385 u64 cur_msb = IXGBE_READ_REG(hw, (msb)); \ 2386 u64 current = ((cur_msb << 32) | cur_lsb); \ 2387 if (current < (last)) \ 2388 count.ev_count += 0x1000000000LL; \ 2389 (last) = current; \ 2390 count.ev_count &= 0xFFFFFFF000000000LL; \ 2391 count.ev_count |= current; \ 2392 } 2393 2394 /************************************************************************ 2395 * ixv_update_stats - Update the board statistics counters. 2396 ************************************************************************/ 2397 void 2398 ixv_update_stats(struct adapter *adapter) 2399 { 2400 struct ixgbe_hw *hw = &adapter->hw; 2401 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2402 2403 UPDATE_STAT_32(IXGBE_VFGPRC, stats->last_vfgprc, stats->vfgprc); 2404 UPDATE_STAT_32(IXGBE_VFGPTC, stats->last_vfgptc, stats->vfgptc); 2405 UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB, stats->last_vfgorc, 2406 stats->vfgorc); 2407 UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB, stats->last_vfgotc, 2408 stats->vfgotc); 2409 UPDATE_STAT_32(IXGBE_VFMPRC, stats->last_vfmprc, stats->vfmprc); 2410 2411 /* Fill out the OS statistics structure */ 2412 /* 2413 * NetBSD: Don't override if_{i|o}{packets|bytes|mcasts} with 2414 * adapter->stats counters. It's required to make ifconfig -z 2415 * (SOICZIFDATA) work. 2416 */ 2417 } /* ixv_update_stats */ 2418 2419 /************************************************************************ 2420 * ixv_sysctl_interrupt_rate_handler 2421 ************************************************************************/ 2422 static int 2423 ixv_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 2424 { 2425 struct sysctlnode node = *rnode; 2426 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 2427 struct adapter *adapter = que->adapter; 2428 uint32_t reg, usec, rate; 2429 int error; 2430 2431 if (que == NULL) 2432 return 0; 2433 reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_VTEITR(que->msix)); 2434 usec = ((reg & 0x0FF8) >> 3); 2435 if (usec > 0) 2436 rate = 500000 / usec; 2437 else 2438 rate = 0; 2439 node.sysctl_data = &rate; 2440 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 2441 if (error || newp == NULL) 2442 return error; 2443 reg &= ~0xfff; /* default, no limitation */ 2444 if (rate > 0 && rate < 500000) { 2445 if (rate < 1000) 2446 rate = 1000; 2447 reg |= ((4000000/rate) & 0xff8); 2448 /* 2449 * When RSC is used, ITR interval must be larger than 2450 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 2451 * The minimum value is always greater than 2us on 100M 2452 * (and 10M?(not documented)), but it's not on 1G and higher. 2453 */ 2454 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2455 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2456 if ((adapter->num_queues > 1) 2457 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 2458 return EINVAL; 2459 } 2460 ixv_max_interrupt_rate = rate; 2461 } else 2462 ixv_max_interrupt_rate = 0; 2463 ixv_eitr_write(adapter, que->msix, reg); 2464 2465 return (0); 2466 } /* ixv_sysctl_interrupt_rate_handler */ 2467 2468 const struct sysctlnode * 2469 ixv_sysctl_instance(struct adapter *adapter) 2470 { 2471 const char *dvname; 2472 struct sysctllog **log; 2473 int rc; 2474 const struct sysctlnode *rnode; 2475 2476 log = &adapter->sysctllog; 2477 dvname = device_xname(adapter->dev); 2478 2479 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 2480 0, CTLTYPE_NODE, dvname, 2481 SYSCTL_DESCR("ixv information and settings"), 2482 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 2483 goto err; 2484 2485 return rnode; 2486 err: 2487 device_printf(adapter->dev, 2488 "%s: sysctl_createv failed, rc = %d\n", __func__, rc); 2489 return NULL; 2490 } 2491 2492 static void 2493 ixv_add_device_sysctls(struct adapter *adapter) 2494 { 2495 struct sysctllog **log; 2496 const struct sysctlnode *rnode, *cnode; 2497 device_t dev; 2498 2499 dev = adapter->dev; 2500 log = &adapter->sysctllog; 2501 2502 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2503 aprint_error_dev(dev, "could not create sysctl root\n"); 2504 return; 2505 } 2506 2507 if (sysctl_createv(log, 0, &rnode, &cnode, 2508 CTLFLAG_READWRITE, CTLTYPE_INT, 2509 "debug", SYSCTL_DESCR("Debug Info"), 2510 ixv_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 2511 aprint_error_dev(dev, "could not create sysctl\n"); 2512 2513 if (sysctl_createv(log, 0, &rnode, &cnode, 2514 CTLFLAG_READWRITE, CTLTYPE_BOOL, 2515 "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 2516 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 2517 aprint_error_dev(dev, "could not create sysctl\n"); 2518 2519 if (sysctl_createv(log, 0, &rnode, &cnode, 2520 CTLFLAG_READWRITE, CTLTYPE_BOOL, 2521 "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"), 2522 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0) 2523 aprint_error_dev(dev, "could not create sysctl\n"); 2524 } 2525 2526 /************************************************************************ 2527 * ixv_add_stats_sysctls - Add statistic sysctls for the VF. 2528 ************************************************************************/ 2529 static void 2530 ixv_add_stats_sysctls(struct adapter *adapter) 2531 { 2532 device_t dev = adapter->dev; 2533 struct tx_ring *txr = adapter->tx_rings; 2534 struct rx_ring *rxr = adapter->rx_rings; 2535 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2536 struct ixgbe_hw *hw = &adapter->hw; 2537 const struct sysctlnode *rnode, *cnode; 2538 struct sysctllog **log = &adapter->sysctllog; 2539 const char *xname = device_xname(dev); 2540 2541 /* Driver Statistics */ 2542 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 2543 NULL, xname, "Driver tx dma soft fail EFBIG"); 2544 evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC, 2545 NULL, xname, "m_defrag() failed"); 2546 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 2547 NULL, xname, "Driver tx dma hard fail EFBIG"); 2548 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 2549 NULL, xname, "Driver tx dma hard fail EINVAL"); 2550 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 2551 NULL, xname, "Driver tx dma hard fail other"); 2552 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 2553 NULL, xname, "Driver tx dma soft fail EAGAIN"); 2554 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 2555 NULL, xname, "Driver tx dma soft fail ENOMEM"); 2556 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 2557 NULL, xname, "Watchdog timeouts"); 2558 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 2559 NULL, xname, "TSO errors"); 2560 evcnt_attach_dynamic(&adapter->link_irq, EVCNT_TYPE_INTR, 2561 NULL, xname, "Link MSI-X IRQ Handled"); 2562 2563 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2564 snprintf(adapter->queues[i].evnamebuf, 2565 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 2566 xname, i); 2567 snprintf(adapter->queues[i].namebuf, 2568 sizeof(adapter->queues[i].namebuf), "q%d", i); 2569 2570 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2571 aprint_error_dev(dev, "could not create sysctl root\n"); 2572 break; 2573 } 2574 2575 if (sysctl_createv(log, 0, &rnode, &rnode, 2576 0, CTLTYPE_NODE, 2577 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 2578 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 2579 break; 2580 2581 if (sysctl_createv(log, 0, &rnode, &cnode, 2582 CTLFLAG_READWRITE, CTLTYPE_INT, 2583 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 2584 ixv_sysctl_interrupt_rate_handler, 0, 2585 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 2586 break; 2587 2588 if (sysctl_createv(log, 0, &rnode, &cnode, 2589 CTLFLAG_READONLY, CTLTYPE_INT, 2590 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 2591 ixv_sysctl_tdh_handler, 0, (void *)txr, 2592 0, CTL_CREATE, CTL_EOL) != 0) 2593 break; 2594 2595 if (sysctl_createv(log, 0, &rnode, &cnode, 2596 CTLFLAG_READONLY, CTLTYPE_INT, 2597 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 2598 ixv_sysctl_tdt_handler, 0, (void *)txr, 2599 0, CTL_CREATE, CTL_EOL) != 0) 2600 break; 2601 2602 evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR, 2603 NULL, adapter->queues[i].evnamebuf, "IRQs on queue"); 2604 evcnt_attach_dynamic(&adapter->queues[i].handleq, 2605 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 2606 "Handled queue in softint"); 2607 evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC, 2608 NULL, adapter->queues[i].evnamebuf, "Requeued in softint"); 2609 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 2610 NULL, adapter->queues[i].evnamebuf, "TSO"); 2611 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 2612 NULL, adapter->queues[i].evnamebuf, 2613 "Queue No Descriptor Available"); 2614 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 2615 NULL, adapter->queues[i].evnamebuf, 2616 "Queue Packets Transmitted"); 2617 #ifndef IXGBE_LEGACY_TX 2618 evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC, 2619 NULL, adapter->queues[i].evnamebuf, 2620 "Packets dropped in pcq"); 2621 #endif 2622 2623 #ifdef LRO 2624 struct lro_ctrl *lro = &rxr->lro; 2625 #endif /* LRO */ 2626 2627 if (sysctl_createv(log, 0, &rnode, &cnode, 2628 CTLFLAG_READONLY, 2629 CTLTYPE_INT, 2630 "rxd_nxck", SYSCTL_DESCR("Receive Descriptor next to check"), 2631 ixv_sysctl_next_to_check_handler, 0, (void *)rxr, 0, 2632 CTL_CREATE, CTL_EOL) != 0) 2633 break; 2634 2635 if (sysctl_createv(log, 0, &rnode, &cnode, 2636 CTLFLAG_READONLY, 2637 CTLTYPE_INT, 2638 "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"), 2639 ixv_sysctl_rdh_handler, 0, (void *)rxr, 0, 2640 CTL_CREATE, CTL_EOL) != 0) 2641 break; 2642 2643 if (sysctl_createv(log, 0, &rnode, &cnode, 2644 CTLFLAG_READONLY, 2645 CTLTYPE_INT, 2646 "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"), 2647 ixv_sysctl_rdt_handler, 0, (void *)rxr, 0, 2648 CTL_CREATE, CTL_EOL) != 0) 2649 break; 2650 2651 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 2652 NULL, adapter->queues[i].evnamebuf, "Queue Packets Received"); 2653 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 2654 NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received"); 2655 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 2656 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 2657 evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC, 2658 NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf"); 2659 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 2660 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 2661 #ifdef LRO 2662 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 2663 CTLFLAG_RD, &lro->lro_queued, 0, 2664 "LRO Queued"); 2665 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 2666 CTLFLAG_RD, &lro->lro_flushed, 0, 2667 "LRO Flushed"); 2668 #endif /* LRO */ 2669 } 2670 2671 /* MAC stats get their own sub node */ 2672 2673 snprintf(stats->namebuf, 2674 sizeof(stats->namebuf), "%s MAC Statistics", xname); 2675 2676 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 2677 stats->namebuf, "rx csum offload - IP"); 2678 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 2679 stats->namebuf, "rx csum offload - L4"); 2680 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 2681 stats->namebuf, "rx csum offload - IP bad"); 2682 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 2683 stats->namebuf, "rx csum offload - L4 bad"); 2684 2685 /* Packet Reception Stats */ 2686 evcnt_attach_dynamic(&stats->vfgprc, EVCNT_TYPE_MISC, NULL, 2687 xname, "Good Packets Received"); 2688 evcnt_attach_dynamic(&stats->vfgorc, EVCNT_TYPE_MISC, NULL, 2689 xname, "Good Octets Received"); 2690 evcnt_attach_dynamic(&stats->vfmprc, EVCNT_TYPE_MISC, NULL, 2691 xname, "Multicast Packets Received"); 2692 evcnt_attach_dynamic(&stats->vfgptc, EVCNT_TYPE_MISC, NULL, 2693 xname, "Good Packets Transmitted"); 2694 evcnt_attach_dynamic(&stats->vfgotc, EVCNT_TYPE_MISC, NULL, 2695 xname, "Good Octets Transmitted"); 2696 2697 /* Mailbox Stats */ 2698 evcnt_attach_dynamic(&hw->mbx.stats.msgs_tx, EVCNT_TYPE_MISC, NULL, 2699 xname, "message TXs"); 2700 evcnt_attach_dynamic(&hw->mbx.stats.msgs_rx, EVCNT_TYPE_MISC, NULL, 2701 xname, "message RXs"); 2702 evcnt_attach_dynamic(&hw->mbx.stats.acks, EVCNT_TYPE_MISC, NULL, 2703 xname, "ACKs"); 2704 evcnt_attach_dynamic(&hw->mbx.stats.reqs, EVCNT_TYPE_MISC, NULL, 2705 xname, "REQs"); 2706 evcnt_attach_dynamic(&hw->mbx.stats.rsts, EVCNT_TYPE_MISC, NULL, 2707 xname, "RSTs"); 2708 2709 } /* ixv_add_stats_sysctls */ 2710 2711 static void 2712 ixv_clear_evcnt(struct adapter *adapter) 2713 { 2714 struct tx_ring *txr = adapter->tx_rings; 2715 struct rx_ring *rxr = adapter->rx_rings; 2716 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2717 struct ixgbe_hw *hw = &adapter->hw; 2718 int i; 2719 2720 /* Driver Statistics */ 2721 adapter->efbig_tx_dma_setup.ev_count = 0; 2722 adapter->mbuf_defrag_failed.ev_count = 0; 2723 adapter->efbig2_tx_dma_setup.ev_count = 0; 2724 adapter->einval_tx_dma_setup.ev_count = 0; 2725 adapter->other_tx_dma_setup.ev_count = 0; 2726 adapter->eagain_tx_dma_setup.ev_count = 0; 2727 adapter->enomem_tx_dma_setup.ev_count = 0; 2728 adapter->watchdog_events.ev_count = 0; 2729 adapter->tso_err.ev_count = 0; 2730 adapter->link_irq.ev_count = 0; 2731 2732 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2733 adapter->queues[i].irqs.ev_count = 0; 2734 adapter->queues[i].handleq.ev_count = 0; 2735 adapter->queues[i].req.ev_count = 0; 2736 txr->tso_tx.ev_count = 0; 2737 txr->no_desc_avail.ev_count = 0; 2738 txr->total_packets.ev_count = 0; 2739 #ifndef IXGBE_LEGACY_TX 2740 txr->pcq_drops.ev_count = 0; 2741 #endif 2742 txr->q_efbig_tx_dma_setup = 0; 2743 txr->q_mbuf_defrag_failed = 0; 2744 txr->q_efbig2_tx_dma_setup = 0; 2745 txr->q_einval_tx_dma_setup = 0; 2746 txr->q_other_tx_dma_setup = 0; 2747 txr->q_eagain_tx_dma_setup = 0; 2748 txr->q_enomem_tx_dma_setup = 0; 2749 txr->q_tso_err = 0; 2750 2751 rxr->rx_packets.ev_count = 0; 2752 rxr->rx_bytes.ev_count = 0; 2753 rxr->rx_copies.ev_count = 0; 2754 rxr->no_jmbuf.ev_count = 0; 2755 rxr->rx_discarded.ev_count = 0; 2756 } 2757 2758 /* MAC stats get their own sub node */ 2759 2760 stats->ipcs.ev_count = 0; 2761 stats->l4cs.ev_count = 0; 2762 stats->ipcs_bad.ev_count = 0; 2763 stats->l4cs_bad.ev_count = 0; 2764 2765 /* Packet Reception Stats */ 2766 stats->vfgprc.ev_count = 0; 2767 stats->vfgorc.ev_count = 0; 2768 stats->vfmprc.ev_count = 0; 2769 stats->vfgptc.ev_count = 0; 2770 stats->vfgotc.ev_count = 0; 2771 2772 /* Mailbox Stats */ 2773 hw->mbx.stats.msgs_tx.ev_count = 0; 2774 hw->mbx.stats.msgs_rx.ev_count = 0; 2775 hw->mbx.stats.acks.ev_count = 0; 2776 hw->mbx.stats.reqs.ev_count = 0; 2777 hw->mbx.stats.rsts.ev_count = 0; 2778 2779 } /* ixv_clear_evcnt */ 2780 2781 /************************************************************************ 2782 * ixv_set_sysctl_value 2783 ************************************************************************/ 2784 static void 2785 ixv_set_sysctl_value(struct adapter *adapter, const char *name, 2786 const char *description, int *limit, int value) 2787 { 2788 device_t dev = adapter->dev; 2789 struct sysctllog **log; 2790 const struct sysctlnode *rnode, *cnode; 2791 2792 log = &adapter->sysctllog; 2793 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2794 aprint_error_dev(dev, "could not create sysctl root\n"); 2795 return; 2796 } 2797 if (sysctl_createv(log, 0, &rnode, &cnode, 2798 CTLFLAG_READWRITE, CTLTYPE_INT, 2799 name, SYSCTL_DESCR(description), 2800 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 2801 aprint_error_dev(dev, "could not create sysctl\n"); 2802 *limit = value; 2803 } /* ixv_set_sysctl_value */ 2804 2805 /************************************************************************ 2806 * ixv_print_debug_info 2807 * 2808 * Called only when em_display_debug_stats is enabled. 2809 * Provides a way to take a look at important statistics 2810 * maintained by the driver and hardware. 2811 ************************************************************************/ 2812 static void 2813 ixv_print_debug_info(struct adapter *adapter) 2814 { 2815 device_t dev = adapter->dev; 2816 struct ix_queue *que = adapter->queues; 2817 struct rx_ring *rxr; 2818 struct tx_ring *txr; 2819 #ifdef LRO 2820 struct lro_ctrl *lro; 2821 #endif /* LRO */ 2822 2823 for (int i = 0; i < adapter->num_queues; i++, que++) { 2824 txr = que->txr; 2825 rxr = que->rxr; 2826 #ifdef LRO 2827 lro = &rxr->lro; 2828 #endif /* LRO */ 2829 device_printf(dev, "QUE(%d) IRQs Handled: %lu\n", 2830 que->msix, (long)que->irqs.ev_count); 2831 device_printf(dev, "RX(%d) Packets Received: %lld\n", 2832 rxr->me, (long long)rxr->rx_packets.ev_count); 2833 device_printf(dev, "RX(%d) Bytes Received: %lu\n", 2834 rxr->me, (long)rxr->rx_bytes.ev_count); 2835 #ifdef LRO 2836 device_printf(dev, "RX(%d) LRO Queued= %ju\n", 2837 rxr->me, (uintmax_t)lro->lro_queued); 2838 device_printf(dev, "RX(%d) LRO Flushed= %ju\n", 2839 rxr->me, (uintmax_t)lro->lro_flushed); 2840 #endif /* LRO */ 2841 device_printf(dev, "TX(%d) Packets Sent: %lu\n", 2842 txr->me, (long)txr->total_packets.ev_count); 2843 device_printf(dev, "TX(%d) NO Desc Avail: %lu\n", 2844 txr->me, (long)txr->no_desc_avail.ev_count); 2845 } 2846 2847 device_printf(dev, "MBX IRQ Handled: %lu\n", 2848 (long)adapter->link_irq.ev_count); 2849 } /* ixv_print_debug_info */ 2850 2851 /************************************************************************ 2852 * ixv_sysctl_debug 2853 ************************************************************************/ 2854 static int 2855 ixv_sysctl_debug(SYSCTLFN_ARGS) 2856 { 2857 struct sysctlnode node = *rnode; 2858 struct adapter *adapter = (struct adapter *)node.sysctl_data; 2859 int error, result; 2860 2861 node.sysctl_data = &result; 2862 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 2863 2864 if (error || newp == NULL) 2865 return error; 2866 2867 if (result == 1) 2868 ixv_print_debug_info(adapter); 2869 2870 return 0; 2871 } /* ixv_sysctl_debug */ 2872 2873 /************************************************************************ 2874 * ixv_init_device_features 2875 ************************************************************************/ 2876 static void 2877 ixv_init_device_features(struct adapter *adapter) 2878 { 2879 adapter->feat_cap = IXGBE_FEATURE_NETMAP 2880 | IXGBE_FEATURE_VF 2881 | IXGBE_FEATURE_RSS 2882 | IXGBE_FEATURE_LEGACY_TX; 2883 2884 /* A tad short on feature flags for VFs, atm. */ 2885 switch (adapter->hw.mac.type) { 2886 case ixgbe_mac_82599_vf: 2887 break; 2888 case ixgbe_mac_X540_vf: 2889 break; 2890 case ixgbe_mac_X550_vf: 2891 case ixgbe_mac_X550EM_x_vf: 2892 case ixgbe_mac_X550EM_a_vf: 2893 adapter->feat_cap |= IXGBE_FEATURE_NEEDS_CTXD; 2894 break; 2895 default: 2896 break; 2897 } 2898 2899 /* Enabled by default... */ 2900 /* Is a virtual function (VF) */ 2901 if (adapter->feat_cap & IXGBE_FEATURE_VF) 2902 adapter->feat_en |= IXGBE_FEATURE_VF; 2903 /* Netmap */ 2904 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 2905 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 2906 /* Receive-Side Scaling (RSS) */ 2907 if (adapter->feat_cap & IXGBE_FEATURE_RSS) 2908 adapter->feat_en |= IXGBE_FEATURE_RSS; 2909 /* Needs advanced context descriptor regardless of offloads req'd */ 2910 if (adapter->feat_cap & IXGBE_FEATURE_NEEDS_CTXD) 2911 adapter->feat_en |= IXGBE_FEATURE_NEEDS_CTXD; 2912 2913 /* Enabled via sysctl... */ 2914 /* Legacy (single queue) transmit */ 2915 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 2916 ixv_enable_legacy_tx) 2917 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 2918 } /* ixv_init_device_features */ 2919 2920 /************************************************************************ 2921 * ixv_shutdown - Shutdown entry point 2922 ************************************************************************/ 2923 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 2924 static int 2925 ixv_shutdown(device_t dev) 2926 { 2927 struct adapter *adapter = device_private(dev); 2928 IXGBE_CORE_LOCK(adapter); 2929 ixv_stop(adapter); 2930 IXGBE_CORE_UNLOCK(adapter); 2931 2932 return (0); 2933 } /* ixv_shutdown */ 2934 #endif 2935 2936 static int 2937 ixv_ifflags_cb(struct ethercom *ec) 2938 { 2939 struct ifnet *ifp = &ec->ec_if; 2940 struct adapter *adapter = ifp->if_softc; 2941 u_short saved_flags; 2942 u_short change; 2943 int rv = 0; 2944 2945 IXGBE_CORE_LOCK(adapter); 2946 2947 saved_flags = adapter->if_flags; 2948 change = ifp->if_flags ^ adapter->if_flags; 2949 if (change != 0) 2950 adapter->if_flags = ifp->if_flags; 2951 2952 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) { 2953 rv = ENETRESET; 2954 goto out; 2955 } else if ((change & IFF_PROMISC) != 0) { 2956 rv = ixv_set_rxfilter(adapter); 2957 if (rv != 0) { 2958 /* Restore previous */ 2959 adapter->if_flags = saved_flags; 2960 goto out; 2961 } 2962 } 2963 2964 /* Check for ec_capenable. */ 2965 change = ec->ec_capenable ^ adapter->ec_capenable; 2966 adapter->ec_capenable = ec->ec_capenable; 2967 if ((change & ~(ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING 2968 | ETHERCAP_VLAN_HWFILTER)) != 0) { 2969 rv = ENETRESET; 2970 goto out; 2971 } 2972 2973 /* 2974 * Special handling is not required for ETHERCAP_VLAN_MTU. 2975 * PF's MAXFRS(MHADD) does not include the 4bytes of the VLAN header. 2976 */ 2977 2978 /* Set up VLAN support and filter */ 2979 if ((change & (ETHERCAP_VLAN_HWTAGGING | ETHERCAP_VLAN_HWFILTER)) != 0) 2980 rv = ixv_setup_vlan_support(adapter); 2981 2982 out: 2983 IXGBE_CORE_UNLOCK(adapter); 2984 2985 return rv; 2986 } 2987 2988 2989 /************************************************************************ 2990 * ixv_ioctl - Ioctl entry point 2991 * 2992 * Called when the user wants to configure the interface. 2993 * 2994 * return 0 on success, positive on failure 2995 ************************************************************************/ 2996 static int 2997 ixv_ioctl(struct ifnet *ifp, u_long command, void *data) 2998 { 2999 struct adapter *adapter = ifp->if_softc; 3000 struct ixgbe_hw *hw = &adapter->hw; 3001 struct ifcapreq *ifcr = data; 3002 int error; 3003 int l4csum_en; 3004 const int l4csum = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx | 3005 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx; 3006 3007 switch (command) { 3008 case SIOCSIFFLAGS: 3009 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 3010 break; 3011 case SIOCADDMULTI: { 3012 struct ether_multi *enm; 3013 struct ether_multistep step; 3014 struct ethercom *ec = &adapter->osdep.ec; 3015 bool overflow = false; 3016 int mcnt = 0; 3017 3018 /* 3019 * Check the number of multicast address. If it exceeds, 3020 * return ENOSPC. 3021 * Update this code when we support API 1.3. 3022 */ 3023 ETHER_LOCK(ec); 3024 ETHER_FIRST_MULTI(step, ec, enm); 3025 while (enm != NULL) { 3026 mcnt++; 3027 3028 /* 3029 * This code is before adding, so one room is required 3030 * at least. 3031 */ 3032 if (mcnt > (IXGBE_MAX_VF_MC - 1)) { 3033 overflow = true; 3034 break; 3035 } 3036 ETHER_NEXT_MULTI(step, enm); 3037 } 3038 ETHER_UNLOCK(ec); 3039 error = 0; 3040 if (overflow && ((ec->ec_flags & ETHER_F_ALLMULTI) == 0)) { 3041 error = hw->mac.ops.update_xcast_mode(hw, 3042 IXGBEVF_XCAST_MODE_ALLMULTI); 3043 if (error == IXGBE_ERR_NOT_TRUSTED) { 3044 device_printf(adapter->dev, 3045 "this interface is not trusted\n"); 3046 error = EPERM; 3047 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 3048 device_printf(adapter->dev, 3049 "the PF doesn't support allmulti mode\n"); 3050 error = EOPNOTSUPP; 3051 } else if (error) { 3052 device_printf(adapter->dev, 3053 "number of Ethernet multicast addresses " 3054 "exceeds the limit (%d). error = %d\n", 3055 IXGBE_MAX_VF_MC, error); 3056 error = ENOSPC; 3057 } else 3058 ec->ec_flags |= ETHER_F_ALLMULTI; 3059 } 3060 if (error) 3061 return error; 3062 } 3063 /*FALLTHROUGH*/ 3064 case SIOCDELMULTI: 3065 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 3066 break; 3067 case SIOCSIFMEDIA: 3068 case SIOCGIFMEDIA: 3069 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 3070 break; 3071 case SIOCSIFCAP: 3072 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 3073 break; 3074 case SIOCSIFMTU: 3075 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 3076 break; 3077 case SIOCZIFDATA: 3078 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 3079 ixv_update_stats(adapter); 3080 ixv_clear_evcnt(adapter); 3081 break; 3082 default: 3083 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 3084 break; 3085 } 3086 3087 switch (command) { 3088 case SIOCSIFCAP: 3089 /* Layer-4 Rx checksum offload has to be turned on and 3090 * off as a unit. 3091 */ 3092 l4csum_en = ifcr->ifcr_capenable & l4csum; 3093 if (l4csum_en != l4csum && l4csum_en != 0) 3094 return EINVAL; 3095 /*FALLTHROUGH*/ 3096 case SIOCADDMULTI: 3097 case SIOCDELMULTI: 3098 case SIOCSIFFLAGS: 3099 case SIOCSIFMTU: 3100 default: 3101 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 3102 return error; 3103 if ((ifp->if_flags & IFF_RUNNING) == 0) 3104 ; 3105 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 3106 IXGBE_CORE_LOCK(adapter); 3107 ixv_init_locked(adapter); 3108 IXGBE_CORE_UNLOCK(adapter); 3109 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 3110 /* 3111 * Multicast list has changed; set the hardware filter 3112 * accordingly. 3113 */ 3114 IXGBE_CORE_LOCK(adapter); 3115 ixv_disable_intr(adapter); 3116 ixv_set_rxfilter(adapter); 3117 ixv_enable_intr(adapter); 3118 IXGBE_CORE_UNLOCK(adapter); 3119 } 3120 return 0; 3121 } 3122 } /* ixv_ioctl */ 3123 3124 /************************************************************************ 3125 * ixv_init 3126 ************************************************************************/ 3127 static int 3128 ixv_init(struct ifnet *ifp) 3129 { 3130 struct adapter *adapter = ifp->if_softc; 3131 3132 IXGBE_CORE_LOCK(adapter); 3133 ixv_init_locked(adapter); 3134 IXGBE_CORE_UNLOCK(adapter); 3135 3136 return 0; 3137 } /* ixv_init */ 3138 3139 /************************************************************************ 3140 * ixv_handle_que 3141 ************************************************************************/ 3142 static void 3143 ixv_handle_que(void *context) 3144 { 3145 struct ix_queue *que = context; 3146 struct adapter *adapter = que->adapter; 3147 struct tx_ring *txr = que->txr; 3148 struct ifnet *ifp = adapter->ifp; 3149 bool more; 3150 3151 que->handleq.ev_count++; 3152 3153 if (ifp->if_flags & IFF_RUNNING) { 3154 more = ixgbe_rxeof(que); 3155 IXGBE_TX_LOCK(txr); 3156 more |= ixgbe_txeof(txr); 3157 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 3158 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 3159 ixgbe_mq_start_locked(ifp, txr); 3160 /* Only for queue 0 */ 3161 /* NetBSD still needs this for CBQ */ 3162 if ((&adapter->queues[0] == que) 3163 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 3164 ixgbe_legacy_start_locked(ifp, txr); 3165 IXGBE_TX_UNLOCK(txr); 3166 if (more) { 3167 que->req.ev_count++; 3168 if (adapter->txrx_use_workqueue) { 3169 /* 3170 * "enqueued flag" is not required here 3171 * the same as ixg(4). See ixgbe_msix_que(). 3172 */ 3173 workqueue_enqueue(adapter->que_wq, 3174 &que->wq_cookie, curcpu()); 3175 } else 3176 softint_schedule(que->que_si); 3177 return; 3178 } 3179 } 3180 3181 /* Re-enable this interrupt */ 3182 ixv_enable_queue(adapter, que->msix); 3183 3184 return; 3185 } /* ixv_handle_que */ 3186 3187 /************************************************************************ 3188 * ixv_handle_que_work 3189 ************************************************************************/ 3190 static void 3191 ixv_handle_que_work(struct work *wk, void *context) 3192 { 3193 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 3194 3195 /* 3196 * "enqueued flag" is not required here the same as ixg(4). 3197 * See ixgbe_msix_que(). 3198 */ 3199 ixv_handle_que(que); 3200 } 3201 3202 /************************************************************************ 3203 * ixv_allocate_msix - Setup MSI-X Interrupt resources and handlers 3204 ************************************************************************/ 3205 static int 3206 ixv_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 3207 { 3208 device_t dev = adapter->dev; 3209 struct ix_queue *que = adapter->queues; 3210 struct tx_ring *txr = adapter->tx_rings; 3211 int error, msix_ctrl, rid, vector = 0; 3212 pci_chipset_tag_t pc; 3213 pcitag_t tag; 3214 char intrbuf[PCI_INTRSTR_LEN]; 3215 char wqname[MAXCOMLEN]; 3216 char intr_xname[32]; 3217 const char *intrstr = NULL; 3218 kcpuset_t *affinity; 3219 int cpu_id = 0; 3220 3221 pc = adapter->osdep.pc; 3222 tag = adapter->osdep.tag; 3223 3224 adapter->osdep.nintrs = adapter->num_queues + 1; 3225 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 3226 adapter->osdep.nintrs) != 0) { 3227 aprint_error_dev(dev, 3228 "failed to allocate MSI-X interrupt\n"); 3229 return (ENXIO); 3230 } 3231 3232 kcpuset_create(&affinity, false); 3233 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 3234 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 3235 device_xname(dev), i); 3236 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 3237 sizeof(intrbuf)); 3238 #ifdef IXGBE_MPSAFE 3239 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 3240 true); 3241 #endif 3242 /* Set the handler function */ 3243 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 3244 adapter->osdep.intrs[i], IPL_NET, ixv_msix_que, que, 3245 intr_xname); 3246 if (que->res == NULL) { 3247 pci_intr_release(pc, adapter->osdep.intrs, 3248 adapter->osdep.nintrs); 3249 aprint_error_dev(dev, 3250 "Failed to register QUE handler\n"); 3251 kcpuset_destroy(affinity); 3252 return (ENXIO); 3253 } 3254 que->msix = vector; 3255 adapter->active_queues |= (u64)(1 << que->msix); 3256 3257 cpu_id = i; 3258 /* Round-robin affinity */ 3259 kcpuset_zero(affinity); 3260 kcpuset_set(affinity, cpu_id % ncpu); 3261 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 3262 NULL); 3263 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 3264 intrstr); 3265 if (error == 0) 3266 aprint_normal(", bound queue %d to cpu %d\n", 3267 i, cpu_id % ncpu); 3268 else 3269 aprint_normal("\n"); 3270 3271 #ifndef IXGBE_LEGACY_TX 3272 txr->txr_si 3273 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 3274 ixgbe_deferred_mq_start, txr); 3275 #endif 3276 que->que_si 3277 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 3278 ixv_handle_que, que); 3279 if (que->que_si == NULL) { 3280 aprint_error_dev(dev, 3281 "could not establish software interrupt\n"); 3282 } 3283 } 3284 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 3285 error = workqueue_create(&adapter->txr_wq, wqname, 3286 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 3287 IXGBE_WORKQUEUE_FLAGS); 3288 if (error) { 3289 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 3290 } 3291 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 3292 3293 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 3294 error = workqueue_create(&adapter->que_wq, wqname, 3295 ixv_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 3296 IXGBE_WORKQUEUE_FLAGS); 3297 if (error) { 3298 aprint_error_dev(dev, 3299 "couldn't create workqueue\n"); 3300 } 3301 3302 /* and Mailbox */ 3303 cpu_id++; 3304 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 3305 adapter->vector = vector; 3306 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 3307 sizeof(intrbuf)); 3308 #ifdef IXGBE_MPSAFE 3309 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 3310 true); 3311 #endif 3312 /* Set the mbx handler function */ 3313 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 3314 adapter->osdep.intrs[vector], IPL_NET, ixv_msix_mbx, adapter, 3315 intr_xname); 3316 if (adapter->osdep.ihs[vector] == NULL) { 3317 aprint_error_dev(dev, "Failed to register LINK handler\n"); 3318 kcpuset_destroy(affinity); 3319 return (ENXIO); 3320 } 3321 /* Round-robin affinity */ 3322 kcpuset_zero(affinity); 3323 kcpuset_set(affinity, cpu_id % ncpu); 3324 error = interrupt_distribute(adapter->osdep.ihs[vector], 3325 affinity, NULL); 3326 3327 aprint_normal_dev(dev, 3328 "for link, interrupting at %s", intrstr); 3329 if (error == 0) 3330 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 3331 else 3332 aprint_normal("\n"); 3333 3334 /* Tasklets for Mailbox */ 3335 adapter->link_si = softint_establish(SOFTINT_NET |IXGBE_SOFTINFT_FLAGS, 3336 ixv_handle_link, adapter); 3337 /* 3338 * Due to a broken design QEMU will fail to properly 3339 * enable the guest for MSI-X unless the vectors in 3340 * the table are all set up, so we must rewrite the 3341 * ENABLE in the MSI-X control register again at this 3342 * point to cause it to successfully initialize us. 3343 */ 3344 if (adapter->hw.mac.type == ixgbe_mac_82599_vf) { 3345 pci_get_capability(pc, tag, PCI_CAP_MSIX, &rid, NULL); 3346 rid += PCI_MSIX_CTL; 3347 msix_ctrl = pci_conf_read(pc, tag, rid); 3348 msix_ctrl |= PCI_MSIX_CTL_ENABLE; 3349 pci_conf_write(pc, tag, rid, msix_ctrl); 3350 } 3351 3352 kcpuset_destroy(affinity); 3353 return (0); 3354 } /* ixv_allocate_msix */ 3355 3356 /************************************************************************ 3357 * ixv_configure_interrupts - Setup MSI-X resources 3358 * 3359 * Note: The VF device MUST use MSI-X, there is no fallback. 3360 ************************************************************************/ 3361 static int 3362 ixv_configure_interrupts(struct adapter *adapter) 3363 { 3364 device_t dev = adapter->dev; 3365 int want, queues, msgs; 3366 3367 /* Must have at least 2 MSI-X vectors */ 3368 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 3369 if (msgs < 2) { 3370 aprint_error_dev(dev, "MSIX config error\n"); 3371 return (ENXIO); 3372 } 3373 msgs = MIN(msgs, IXG_MAX_NINTR); 3374 3375 /* Figure out a reasonable auto config value */ 3376 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 3377 3378 if (ixv_num_queues != 0) 3379 queues = ixv_num_queues; 3380 else if ((ixv_num_queues == 0) && (queues > IXGBE_VF_MAX_TX_QUEUES)) 3381 queues = IXGBE_VF_MAX_TX_QUEUES; 3382 3383 /* 3384 * Want vectors for the queues, 3385 * plus an additional for mailbox. 3386 */ 3387 want = queues + 1; 3388 if (msgs >= want) 3389 msgs = want; 3390 else { 3391 aprint_error_dev(dev, 3392 "MSI-X Configuration Problem, " 3393 "%d vectors but %d queues wanted!\n", 3394 msgs, want); 3395 return -1; 3396 } 3397 3398 adapter->msix_mem = (void *)1; /* XXX */ 3399 aprint_normal_dev(dev, 3400 "Using MSI-X interrupts with %d vectors\n", msgs); 3401 adapter->num_queues = queues; 3402 3403 return (0); 3404 } /* ixv_configure_interrupts */ 3405 3406 3407 /************************************************************************ 3408 * ixv_handle_link - Tasklet handler for MSI-X MBX interrupts 3409 * 3410 * Done outside of interrupt context since the driver might sleep 3411 ************************************************************************/ 3412 static void 3413 ixv_handle_link(void *context) 3414 { 3415 struct adapter *adapter = context; 3416 3417 IXGBE_CORE_LOCK(adapter); 3418 3419 adapter->hw.mac.ops.check_link(&adapter->hw, &adapter->link_speed, 3420 &adapter->link_up, FALSE); 3421 ixv_update_link_status(adapter); 3422 3423 IXGBE_CORE_UNLOCK(adapter); 3424 } /* ixv_handle_link */ 3425 3426 /************************************************************************ 3427 * ixv_check_link - Used in the local timer to poll for link changes 3428 ************************************************************************/ 3429 static s32 3430 ixv_check_link(struct adapter *adapter) 3431 { 3432 s32 error; 3433 3434 KASSERT(mutex_owned(&adapter->core_mtx)); 3435 3436 adapter->hw.mac.get_link_status = TRUE; 3437 3438 error = adapter->hw.mac.ops.check_link(&adapter->hw, 3439 &adapter->link_speed, &adapter->link_up, FALSE); 3440 ixv_update_link_status(adapter); 3441 3442 return error; 3443 } /* ixv_check_link */ 3444
Indexes created Tue Sep 30 20:09:53 GMT 2025