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