ixgbe.c revision 1.128.2.2
1 /* $NetBSD: ixgbe.c,v 1.128.2.2 2018/03/22 01:44:50 pgoyette 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_ix.c 320916 2017-07-12 17:35:32Z sbruno $*/ 36 37 /* 38 * Copyright (c) 2011 The NetBSD Foundation, Inc. 39 * All rights reserved. 40 * 41 * This code is derived from software contributed to The NetBSD Foundation 42 * by Coyote Point Systems, Inc. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 53 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 54 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 55 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 56 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 57 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 58 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 59 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 60 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 61 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 63 * POSSIBILITY OF SUCH DAMAGE. 64 */ 65 66 #ifdef _KERNEL_OPT 67 #include "opt_inet.h" 68 #include "opt_inet6.h" 69 #include "opt_net_mpsafe.h" 70 #endif 71 72 #include "ixgbe.h" 73 #include "ixgbe_sriov.h" 74 #include "vlan.h" 75 76 #include <sys/cprng.h> 77 #include <dev/mii/mii.h> 78 #include <dev/mii/miivar.h> 79 80 /************************************************************************ 81 * Driver version 82 ************************************************************************/ 83 char ixgbe_driver_version[] = "3.2.12-k"; 84 85 86 /************************************************************************ 87 * PCI Device ID Table 88 * 89 * Used by probe to select devices to load on 90 * Last field stores an index into ixgbe_strings 91 * Last entry must be all 0s 92 * 93 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 94 ************************************************************************/ 95 static ixgbe_vendor_info_t ixgbe_vendor_info_array[] = 96 { 97 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_DUAL_PORT, 0, 0, 0}, 98 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_SINGLE_PORT, 0, 0, 0}, 99 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_CX4, 0, 0, 0}, 100 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT, 0, 0, 0}, 101 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT2, 0, 0, 0}, 102 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598, 0, 0, 0}, 103 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_DA_DUAL_PORT, 0, 0, 0}, 104 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_CX4_DUAL_PORT, 0, 0, 0}, 105 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_XF_LR, 0, 0, 0}, 106 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM, 0, 0, 0}, 107 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_SFP_LOM, 0, 0, 0}, 108 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4, 0, 0, 0}, 109 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4_MEZZ, 0, 0, 0}, 110 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP, 0, 0, 0}, 111 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_XAUI_LOM, 0, 0, 0}, 112 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_CX4, 0, 0, 0}, 113 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_T3_LOM, 0, 0, 0}, 114 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_COMBO_BACKPLANE, 0, 0, 0}, 115 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BACKPLANE_FCOE, 0, 0, 0}, 116 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF2, 0, 0, 0}, 117 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_FCOE, 0, 0, 0}, 118 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599EN_SFP, 0, 0, 0}, 119 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF_QP, 0, 0, 0}, 120 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_QSFP_SF_QP, 0, 0, 0}, 121 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T, 0, 0, 0}, 122 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T1, 0, 0, 0}, 123 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T, 0, 0, 0}, 124 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T1, 0, 0, 0}, 125 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KR, 0, 0, 0}, 126 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KX4, 0, 0, 0}, 127 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_10G_T, 0, 0, 0}, 128 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_1G_T, 0, 0, 0}, 129 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_SFP, 0, 0, 0}, 130 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR, 0, 0, 0}, 131 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR_L, 0, 0, 0}, 132 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP, 0, 0, 0}, 133 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP_N, 0, 0, 0}, 134 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII, 0, 0, 0}, 135 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII_L, 0, 0, 0}, 136 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_10G_T, 0, 0, 0}, 137 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T, 0, 0, 0}, 138 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T_L, 0, 0, 0}, 139 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_BYPASS, 0, 0, 0}, 140 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BYPASS, 0, 0, 0}, 141 /* required last entry */ 142 {0, 0, 0, 0, 0} 143 }; 144 145 /************************************************************************ 146 * Table of branding strings 147 ************************************************************************/ 148 static const char *ixgbe_strings[] = { 149 "Intel(R) PRO/10GbE PCI-Express Network Driver" 150 }; 151 152 /************************************************************************ 153 * Function prototypes 154 ************************************************************************/ 155 static int ixgbe_probe(device_t, cfdata_t, void *); 156 static void ixgbe_attach(device_t, device_t, void *); 157 static int ixgbe_detach(device_t, int); 158 #if 0 159 static int ixgbe_shutdown(device_t); 160 #endif 161 static bool ixgbe_suspend(device_t, const pmf_qual_t *); 162 static bool ixgbe_resume(device_t, const pmf_qual_t *); 163 static int ixgbe_ifflags_cb(struct ethercom *); 164 static int ixgbe_ioctl(struct ifnet *, u_long, void *); 165 static void ixgbe_ifstop(struct ifnet *, int); 166 static int ixgbe_init(struct ifnet *); 167 static void ixgbe_init_locked(struct adapter *); 168 static void ixgbe_stop(void *); 169 static void ixgbe_init_device_features(struct adapter *); 170 static void ixgbe_check_fan_failure(struct adapter *, u32, bool); 171 static void ixgbe_add_media_types(struct adapter *); 172 static void ixgbe_media_status(struct ifnet *, struct ifmediareq *); 173 static int ixgbe_media_change(struct ifnet *); 174 static int ixgbe_allocate_pci_resources(struct adapter *, 175 const struct pci_attach_args *); 176 static void ixgbe_free_softint(struct adapter *); 177 static void ixgbe_get_slot_info(struct adapter *); 178 static int ixgbe_allocate_msix(struct adapter *, 179 const struct pci_attach_args *); 180 static int ixgbe_allocate_legacy(struct adapter *, 181 const struct pci_attach_args *); 182 static int ixgbe_configure_interrupts(struct adapter *); 183 static void ixgbe_free_pciintr_resources(struct adapter *); 184 static void ixgbe_free_pci_resources(struct adapter *); 185 static void ixgbe_local_timer(void *); 186 static void ixgbe_local_timer1(void *); 187 static int ixgbe_setup_interface(device_t, struct adapter *); 188 static void ixgbe_config_gpie(struct adapter *); 189 static void ixgbe_config_dmac(struct adapter *); 190 static void ixgbe_config_delay_values(struct adapter *); 191 static void ixgbe_config_link(struct adapter *); 192 static void ixgbe_check_wol_support(struct adapter *); 193 static int ixgbe_setup_low_power_mode(struct adapter *); 194 static void ixgbe_rearm_queues(struct adapter *, u64); 195 196 static void ixgbe_initialize_transmit_units(struct adapter *); 197 static void ixgbe_initialize_receive_units(struct adapter *); 198 static void ixgbe_enable_rx_drop(struct adapter *); 199 static void ixgbe_disable_rx_drop(struct adapter *); 200 static void ixgbe_initialize_rss_mapping(struct adapter *); 201 202 static void ixgbe_enable_intr(struct adapter *); 203 static void ixgbe_disable_intr(struct adapter *); 204 static void ixgbe_update_stats_counters(struct adapter *); 205 static void ixgbe_set_promisc(struct adapter *); 206 static void ixgbe_set_multi(struct adapter *); 207 static void ixgbe_update_link_status(struct adapter *); 208 static void ixgbe_set_ivar(struct adapter *, u8, u8, s8); 209 static void ixgbe_configure_ivars(struct adapter *); 210 static u8 * ixgbe_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *); 211 static void ixgbe_eitr_write(struct ix_queue *, uint32_t); 212 213 static void ixgbe_setup_vlan_hw_support(struct adapter *); 214 #if 0 215 static void ixgbe_register_vlan(void *, struct ifnet *, u16); 216 static void ixgbe_unregister_vlan(void *, struct ifnet *, u16); 217 #endif 218 219 static void ixgbe_add_device_sysctls(struct adapter *); 220 static void ixgbe_add_hw_stats(struct adapter *); 221 static void ixgbe_clear_evcnt(struct adapter *); 222 static int ixgbe_set_flowcntl(struct adapter *, int); 223 static int ixgbe_set_advertise(struct adapter *, int); 224 static int ixgbe_get_advertise(struct adapter *); 225 226 /* Sysctl handlers */ 227 static void ixgbe_set_sysctl_value(struct adapter *, const char *, 228 const char *, int *, int); 229 static int ixgbe_sysctl_flowcntl(SYSCTLFN_PROTO); 230 static int ixgbe_sysctl_advertise(SYSCTLFN_PROTO); 231 static int ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_PROTO); 232 static int ixgbe_sysctl_dmac(SYSCTLFN_PROTO); 233 static int ixgbe_sysctl_phy_temp(SYSCTLFN_PROTO); 234 static int ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_PROTO); 235 #ifdef IXGBE_DEBUG 236 static int ixgbe_sysctl_power_state(SYSCTLFN_PROTO); 237 static int ixgbe_sysctl_print_rss_config(SYSCTLFN_PROTO); 238 #endif 239 static int ixgbe_sysctl_rdh_handler(SYSCTLFN_PROTO); 240 static int ixgbe_sysctl_rdt_handler(SYSCTLFN_PROTO); 241 static int ixgbe_sysctl_tdt_handler(SYSCTLFN_PROTO); 242 static int ixgbe_sysctl_tdh_handler(SYSCTLFN_PROTO); 243 static int ixgbe_sysctl_eee_state(SYSCTLFN_PROTO); 244 static int ixgbe_sysctl_wol_enable(SYSCTLFN_PROTO); 245 static int ixgbe_sysctl_wufc(SYSCTLFN_PROTO); 246 247 /* Support for pluggable optic modules */ 248 static bool ixgbe_sfp_probe(struct adapter *); 249 250 /* Legacy (single vector) interrupt handler */ 251 static int ixgbe_legacy_irq(void *); 252 253 /* The MSI/MSI-X Interrupt handlers */ 254 static int ixgbe_msix_que(void *); 255 static int ixgbe_msix_link(void *); 256 257 /* Software interrupts for deferred work */ 258 static void ixgbe_handle_que(void *); 259 static void ixgbe_handle_link(void *); 260 static void ixgbe_handle_msf(void *); 261 static void ixgbe_handle_mod(void *); 262 static void ixgbe_handle_phy(void *); 263 264 /* Workqueue handler for deferred work */ 265 static void ixgbe_handle_que_work(struct work *, void *); 266 267 static ixgbe_vendor_info_t *ixgbe_lookup(const struct pci_attach_args *); 268 269 /************************************************************************ 270 * NetBSD Device Interface Entry Points 271 ************************************************************************/ 272 CFATTACH_DECL3_NEW(ixg, sizeof(struct adapter), 273 ixgbe_probe, ixgbe_attach, ixgbe_detach, NULL, NULL, NULL, 274 DVF_DETACH_SHUTDOWN); 275 276 #if 0 277 devclass_t ix_devclass; 278 DRIVER_MODULE(ix, pci, ix_driver, ix_devclass, 0, 0); 279 280 MODULE_DEPEND(ix, pci, 1, 1, 1); 281 MODULE_DEPEND(ix, ether, 1, 1, 1); 282 #ifdef DEV_NETMAP 283 MODULE_DEPEND(ix, netmap, 1, 1, 1); 284 #endif 285 #endif 286 287 /* 288 * TUNEABLE PARAMETERS: 289 */ 290 291 /* 292 * AIM: Adaptive Interrupt Moderation 293 * which means that the interrupt rate 294 * is varied over time based on the 295 * traffic for that interrupt vector 296 */ 297 static bool ixgbe_enable_aim = true; 298 #define SYSCTL_INT(_a1, _a2, _a3, _a4, _a5, _a6, _a7) 299 SYSCTL_INT(_hw_ix, OID_AUTO, enable_aim, CTLFLAG_RDTUN, &ixgbe_enable_aim, 0, 300 "Enable adaptive interrupt moderation"); 301 302 static int ixgbe_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY); 303 SYSCTL_INT(_hw_ix, OID_AUTO, max_interrupt_rate, CTLFLAG_RDTUN, 304 &ixgbe_max_interrupt_rate, 0, "Maximum interrupts per second"); 305 306 /* How many packets rxeof tries to clean at a time */ 307 static int ixgbe_rx_process_limit = 256; 308 SYSCTL_INT(_hw_ix, OID_AUTO, rx_process_limit, CTLFLAG_RDTUN, 309 &ixgbe_rx_process_limit, 0, "Maximum number of received packets to process at a time, -1 means unlimited"); 310 311 /* How many packets txeof tries to clean at a time */ 312 static int ixgbe_tx_process_limit = 256; 313 SYSCTL_INT(_hw_ix, OID_AUTO, tx_process_limit, CTLFLAG_RDTUN, 314 &ixgbe_tx_process_limit, 0, 315 "Maximum number of sent packets to process at a time, -1 means unlimited"); 316 317 /* Flow control setting, default to full */ 318 static int ixgbe_flow_control = ixgbe_fc_full; 319 SYSCTL_INT(_hw_ix, OID_AUTO, flow_control, CTLFLAG_RDTUN, 320 &ixgbe_flow_control, 0, "Default flow control used for all adapters"); 321 322 /* Which pakcet processing uses workqueue or softint */ 323 static bool ixgbe_txrx_workqueue = false; 324 325 /* 326 * Smart speed setting, default to on 327 * this only works as a compile option 328 * right now as its during attach, set 329 * this to 'ixgbe_smart_speed_off' to 330 * disable. 331 */ 332 static int ixgbe_smart_speed = ixgbe_smart_speed_on; 333 334 /* 335 * MSI-X should be the default for best performance, 336 * but this allows it to be forced off for testing. 337 */ 338 static int ixgbe_enable_msix = 1; 339 SYSCTL_INT(_hw_ix, OID_AUTO, enable_msix, CTLFLAG_RDTUN, &ixgbe_enable_msix, 0, 340 "Enable MSI-X interrupts"); 341 342 /* 343 * Number of Queues, can be set to 0, 344 * it then autoconfigures based on the 345 * number of cpus with a max of 8. This 346 * can be overriden manually here. 347 */ 348 static int ixgbe_num_queues = 0; 349 SYSCTL_INT(_hw_ix, OID_AUTO, num_queues, CTLFLAG_RDTUN, &ixgbe_num_queues, 0, 350 "Number of queues to configure, 0 indicates autoconfigure"); 351 352 /* 353 * Number of TX descriptors per ring, 354 * setting higher than RX as this seems 355 * the better performing choice. 356 */ 357 static int ixgbe_txd = PERFORM_TXD; 358 SYSCTL_INT(_hw_ix, OID_AUTO, txd, CTLFLAG_RDTUN, &ixgbe_txd, 0, 359 "Number of transmit descriptors per queue"); 360 361 /* Number of RX descriptors per ring */ 362 static int ixgbe_rxd = PERFORM_RXD; 363 SYSCTL_INT(_hw_ix, OID_AUTO, rxd, CTLFLAG_RDTUN, &ixgbe_rxd, 0, 364 "Number of receive descriptors per queue"); 365 366 /* 367 * Defining this on will allow the use 368 * of unsupported SFP+ modules, note that 369 * doing so you are on your own :) 370 */ 371 static int allow_unsupported_sfp = false; 372 #define TUNABLE_INT(__x, __y) 373 TUNABLE_INT("hw.ix.unsupported_sfp", &allow_unsupported_sfp); 374 375 /* 376 * Not sure if Flow Director is fully baked, 377 * so we'll default to turning it off. 378 */ 379 static int ixgbe_enable_fdir = 0; 380 SYSCTL_INT(_hw_ix, OID_AUTO, enable_fdir, CTLFLAG_RDTUN, &ixgbe_enable_fdir, 0, 381 "Enable Flow Director"); 382 383 /* Legacy Transmit (single queue) */ 384 static int ixgbe_enable_legacy_tx = 0; 385 SYSCTL_INT(_hw_ix, OID_AUTO, enable_legacy_tx, CTLFLAG_RDTUN, 386 &ixgbe_enable_legacy_tx, 0, "Enable Legacy TX flow"); 387 388 /* Receive-Side Scaling */ 389 static int ixgbe_enable_rss = 1; 390 SYSCTL_INT(_hw_ix, OID_AUTO, enable_rss, CTLFLAG_RDTUN, &ixgbe_enable_rss, 0, 391 "Enable Receive-Side Scaling (RSS)"); 392 393 /* Keep running tab on them for sanity check */ 394 static int ixgbe_total_ports; 395 396 #if 0 397 static int (*ixgbe_start_locked)(struct ifnet *, struct tx_ring *); 398 static int (*ixgbe_ring_empty)(struct ifnet *, pcq_t *); 399 #endif 400 401 #ifdef NET_MPSAFE 402 #define IXGBE_MPSAFE 1 403 #define IXGBE_CALLOUT_FLAGS CALLOUT_MPSAFE 404 #define IXGBE_SOFTINFT_FLAGS SOFTINT_MPSAFE 405 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU | WQ_MPSAFE 406 #else 407 #define IXGBE_CALLOUT_FLAGS 0 408 #define IXGBE_SOFTINFT_FLAGS 0 409 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU 410 #endif 411 #define IXGBE_WORKQUEUE_PRI PRI_SOFTNET 412 413 /************************************************************************ 414 * ixgbe_initialize_rss_mapping 415 ************************************************************************/ 416 static void 417 ixgbe_initialize_rss_mapping(struct adapter *adapter) 418 { 419 struct ixgbe_hw *hw = &adapter->hw; 420 u32 reta = 0, mrqc, rss_key[10]; 421 int queue_id, table_size, index_mult; 422 int i, j; 423 u32 rss_hash_config; 424 425 /* force use default RSS key. */ 426 #ifdef __NetBSD__ 427 rss_getkey((uint8_t *) &rss_key); 428 #else 429 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 430 /* Fetch the configured RSS key */ 431 rss_getkey((uint8_t *) &rss_key); 432 } else { 433 /* set up random bits */ 434 cprng_fast(&rss_key, sizeof(rss_key)); 435 } 436 #endif 437 438 /* Set multiplier for RETA setup and table size based on MAC */ 439 index_mult = 0x1; 440 table_size = 128; 441 switch (adapter->hw.mac.type) { 442 case ixgbe_mac_82598EB: 443 index_mult = 0x11; 444 break; 445 case ixgbe_mac_X550: 446 case ixgbe_mac_X550EM_x: 447 case ixgbe_mac_X550EM_a: 448 table_size = 512; 449 break; 450 default: 451 break; 452 } 453 454 /* Set up the redirection table */ 455 for (i = 0, j = 0; i < table_size; i++, j++) { 456 if (j == adapter->num_queues) 457 j = 0; 458 459 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 460 /* 461 * Fetch the RSS bucket id for the given indirection 462 * entry. Cap it at the number of configured buckets 463 * (which is num_queues.) 464 */ 465 queue_id = rss_get_indirection_to_bucket(i); 466 queue_id = queue_id % adapter->num_queues; 467 } else 468 queue_id = (j * index_mult); 469 470 /* 471 * The low 8 bits are for hash value (n+0); 472 * The next 8 bits are for hash value (n+1), etc. 473 */ 474 reta = reta >> 8; 475 reta = reta | (((uint32_t) queue_id) << 24); 476 if ((i & 3) == 3) { 477 if (i < 128) 478 IXGBE_WRITE_REG(hw, IXGBE_RETA(i >> 2), reta); 479 else 480 IXGBE_WRITE_REG(hw, IXGBE_ERETA((i >> 2) - 32), 481 reta); 482 reta = 0; 483 } 484 } 485 486 /* Now fill our hash function seeds */ 487 for (i = 0; i < 10; i++) 488 IXGBE_WRITE_REG(hw, IXGBE_RSSRK(i), rss_key[i]); 489 490 /* Perform hash on these packet types */ 491 if (adapter->feat_en & IXGBE_FEATURE_RSS) 492 rss_hash_config = rss_gethashconfig(); 493 else { 494 /* 495 * Disable UDP - IP fragments aren't currently being handled 496 * and so we end up with a mix of 2-tuple and 4-tuple 497 * traffic. 498 */ 499 rss_hash_config = RSS_HASHTYPE_RSS_IPV4 500 | RSS_HASHTYPE_RSS_TCP_IPV4 501 | RSS_HASHTYPE_RSS_IPV6 502 | RSS_HASHTYPE_RSS_TCP_IPV6 503 | RSS_HASHTYPE_RSS_IPV6_EX 504 | RSS_HASHTYPE_RSS_TCP_IPV6_EX; 505 } 506 507 mrqc = IXGBE_MRQC_RSSEN; 508 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 509 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 510 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 511 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 512 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 513 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 514 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 515 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 516 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 517 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX; 518 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 519 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP; 520 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 521 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 522 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 523 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 524 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 525 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP; 526 mrqc |= ixgbe_get_mrqc(adapter->iov_mode); 527 IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc); 528 } /* ixgbe_initialize_rss_mapping */ 529 530 /************************************************************************ 531 * ixgbe_initialize_receive_units - Setup receive registers and features. 532 ************************************************************************/ 533 #define BSIZEPKT_ROUNDUP ((1<<IXGBE_SRRCTL_BSIZEPKT_SHIFT)-1) 534 535 static void 536 ixgbe_initialize_receive_units(struct adapter *adapter) 537 { 538 struct rx_ring *rxr = adapter->rx_rings; 539 struct ixgbe_hw *hw = &adapter->hw; 540 struct ifnet *ifp = adapter->ifp; 541 int i, j; 542 u32 bufsz, fctrl, srrctl, rxcsum; 543 u32 hlreg; 544 545 /* 546 * Make sure receives are disabled while 547 * setting up the descriptor ring 548 */ 549 ixgbe_disable_rx(hw); 550 551 /* Enable broadcasts */ 552 fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL); 553 fctrl |= IXGBE_FCTRL_BAM; 554 if (adapter->hw.mac.type == ixgbe_mac_82598EB) { 555 fctrl |= IXGBE_FCTRL_DPF; 556 fctrl |= IXGBE_FCTRL_PMCF; 557 } 558 IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl); 559 560 /* Set for Jumbo Frames? */ 561 hlreg = IXGBE_READ_REG(hw, IXGBE_HLREG0); 562 if (ifp->if_mtu > ETHERMTU) 563 hlreg |= IXGBE_HLREG0_JUMBOEN; 564 else 565 hlreg &= ~IXGBE_HLREG0_JUMBOEN; 566 567 #ifdef DEV_NETMAP 568 /* CRC stripping is conditional in Netmap */ 569 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 570 (ifp->if_capenable & IFCAP_NETMAP) && 571 !ix_crcstrip) 572 hlreg &= ~IXGBE_HLREG0_RXCRCSTRP; 573 else 574 #endif /* DEV_NETMAP */ 575 hlreg |= IXGBE_HLREG0_RXCRCSTRP; 576 577 IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg); 578 579 bufsz = (adapter->rx_mbuf_sz + BSIZEPKT_ROUNDUP) >> 580 IXGBE_SRRCTL_BSIZEPKT_SHIFT; 581 582 for (i = 0; i < adapter->num_queues; i++, rxr++) { 583 u64 rdba = rxr->rxdma.dma_paddr; 584 u32 tqsmreg, reg; 585 int regnum = i / 4; /* 1 register per 4 queues */ 586 int regshift = i % 4; /* 4 bits per 1 queue */ 587 j = rxr->me; 588 589 /* Setup the Base and Length of the Rx Descriptor Ring */ 590 IXGBE_WRITE_REG(hw, IXGBE_RDBAL(j), 591 (rdba & 0x00000000ffffffffULL)); 592 IXGBE_WRITE_REG(hw, IXGBE_RDBAH(j), (rdba >> 32)); 593 IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j), 594 adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc)); 595 596 /* Set up the SRRCTL register */ 597 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(j)); 598 srrctl &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 599 srrctl &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 600 srrctl |= bufsz; 601 srrctl |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 602 603 /* Set RQSMR (Receive Queue Statistic Mapping) register */ 604 reg = IXGBE_READ_REG(hw, IXGBE_RQSMR(regnum)); 605 reg &= ~(0x000000ff << (regshift * 8)); 606 reg |= i << (regshift * 8); 607 IXGBE_WRITE_REG(hw, IXGBE_RQSMR(regnum), reg); 608 609 /* 610 * Set RQSMR (Receive Queue Statistic Mapping) register. 611 * Register location for queue 0...7 are different between 612 * 82598 and newer. 613 */ 614 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 615 tqsmreg = IXGBE_TQSMR(regnum); 616 else 617 tqsmreg = IXGBE_TQSM(regnum); 618 reg = IXGBE_READ_REG(hw, tqsmreg); 619 reg &= ~(0x000000ff << (regshift * 8)); 620 reg |= i << (regshift * 8); 621 IXGBE_WRITE_REG(hw, tqsmreg, reg); 622 623 /* 624 * Set DROP_EN iff we have no flow control and >1 queue. 625 * Note that srrctl was cleared shortly before during reset, 626 * so we do not need to clear the bit, but do it just in case 627 * this code is moved elsewhere. 628 */ 629 if (adapter->num_queues > 1 && 630 adapter->hw.fc.requested_mode == ixgbe_fc_none) { 631 srrctl |= IXGBE_SRRCTL_DROP_EN; 632 } else { 633 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 634 } 635 636 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(j), srrctl); 637 638 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 639 IXGBE_WRITE_REG(hw, IXGBE_RDH(j), 0); 640 IXGBE_WRITE_REG(hw, IXGBE_RDT(j), 0); 641 642 /* Set the driver rx tail address */ 643 rxr->tail = IXGBE_RDT(rxr->me); 644 } 645 646 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 647 u32 psrtype = IXGBE_PSRTYPE_TCPHDR 648 | IXGBE_PSRTYPE_UDPHDR 649 | IXGBE_PSRTYPE_IPV4HDR 650 | IXGBE_PSRTYPE_IPV6HDR; 651 IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(0), psrtype); 652 } 653 654 rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM); 655 656 ixgbe_initialize_rss_mapping(adapter); 657 658 if (adapter->num_queues > 1) { 659 /* RSS and RX IPP Checksum are mutually exclusive */ 660 rxcsum |= IXGBE_RXCSUM_PCSD; 661 } 662 663 if (ifp->if_capenable & IFCAP_RXCSUM) 664 rxcsum |= IXGBE_RXCSUM_PCSD; 665 666 /* This is useful for calculating UDP/IP fragment checksums */ 667 if (!(rxcsum & IXGBE_RXCSUM_PCSD)) 668 rxcsum |= IXGBE_RXCSUM_IPPCSE; 669 670 IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum); 671 672 return; 673 } /* ixgbe_initialize_receive_units */ 674 675 /************************************************************************ 676 * ixgbe_initialize_transmit_units - Enable transmit units. 677 ************************************************************************/ 678 static void 679 ixgbe_initialize_transmit_units(struct adapter *adapter) 680 { 681 struct tx_ring *txr = adapter->tx_rings; 682 struct ixgbe_hw *hw = &adapter->hw; 683 684 /* Setup the Base and Length of the Tx Descriptor Ring */ 685 for (int i = 0; i < adapter->num_queues; i++, txr++) { 686 u64 tdba = txr->txdma.dma_paddr; 687 u32 txctrl = 0; 688 int j = txr->me; 689 690 IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j), 691 (tdba & 0x00000000ffffffffULL)); 692 IXGBE_WRITE_REG(hw, IXGBE_TDBAH(j), (tdba >> 32)); 693 IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), 694 adapter->num_tx_desc * sizeof(union ixgbe_adv_tx_desc)); 695 696 /* Setup the HW Tx Head and Tail descriptor pointers */ 697 IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0); 698 IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0); 699 700 /* Cache the tail address */ 701 txr->tail = IXGBE_TDT(j); 702 703 /* Disable Head Writeback */ 704 /* 705 * Note: for X550 series devices, these registers are actually 706 * prefixed with TPH_ isntead of DCA_, but the addresses and 707 * fields remain the same. 708 */ 709 switch (hw->mac.type) { 710 case ixgbe_mac_82598EB: 711 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j)); 712 break; 713 default: 714 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(j)); 715 break; 716 } 717 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 718 switch (hw->mac.type) { 719 case ixgbe_mac_82598EB: 720 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl); 721 break; 722 default: 723 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(j), txctrl); 724 break; 725 } 726 727 } 728 729 if (hw->mac.type != ixgbe_mac_82598EB) { 730 u32 dmatxctl, rttdcs; 731 732 dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL); 733 dmatxctl |= IXGBE_DMATXCTL_TE; 734 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl); 735 /* Disable arbiter to set MTQC */ 736 rttdcs = IXGBE_READ_REG(hw, IXGBE_RTTDCS); 737 rttdcs |= IXGBE_RTTDCS_ARBDIS; 738 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 739 IXGBE_WRITE_REG(hw, IXGBE_MTQC, 740 ixgbe_get_mtqc(adapter->iov_mode)); 741 rttdcs &= ~IXGBE_RTTDCS_ARBDIS; 742 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 743 } 744 745 return; 746 } /* ixgbe_initialize_transmit_units */ 747 748 /************************************************************************ 749 * ixgbe_attach - Device initialization routine 750 * 751 * Called when the driver is being loaded. 752 * Identifies the type of hardware, allocates all resources 753 * and initializes the hardware. 754 * 755 * return 0 on success, positive on failure 756 ************************************************************************/ 757 static void 758 ixgbe_attach(device_t parent, device_t dev, void *aux) 759 { 760 struct adapter *adapter; 761 struct ixgbe_hw *hw; 762 int error = -1; 763 u32 ctrl_ext; 764 u16 high, low, nvmreg; 765 pcireg_t id, subid; 766 ixgbe_vendor_info_t *ent; 767 struct pci_attach_args *pa = aux; 768 const char *str; 769 char buf[256]; 770 771 INIT_DEBUGOUT("ixgbe_attach: begin"); 772 773 /* Allocate, clear, and link in our adapter structure */ 774 adapter = device_private(dev); 775 adapter->hw.back = adapter; 776 adapter->dev = dev; 777 hw = &adapter->hw; 778 adapter->osdep.pc = pa->pa_pc; 779 adapter->osdep.tag = pa->pa_tag; 780 if (pci_dma64_available(pa)) 781 adapter->osdep.dmat = pa->pa_dmat64; 782 else 783 adapter->osdep.dmat = pa->pa_dmat; 784 adapter->osdep.attached = false; 785 786 ent = ixgbe_lookup(pa); 787 788 KASSERT(ent != NULL); 789 790 aprint_normal(": %s, Version - %s\n", 791 ixgbe_strings[ent->index], ixgbe_driver_version); 792 793 /* Core Lock Init*/ 794 IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev)); 795 796 /* Set up the timer callout */ 797 callout_init(&adapter->timer, IXGBE_CALLOUT_FLAGS); 798 799 /* Determine hardware revision */ 800 id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG); 801 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 802 803 hw->vendor_id = PCI_VENDOR(id); 804 hw->device_id = PCI_PRODUCT(id); 805 hw->revision_id = 806 PCI_REVISION(pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG)); 807 hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid); 808 hw->subsystem_device_id = PCI_SUBSYS_ID(subid); 809 810 /* 811 * Make sure BUSMASTER is set 812 */ 813 ixgbe_pci_enable_busmaster(pa->pa_pc, pa->pa_tag); 814 815 /* Do base PCI setup - map BAR0 */ 816 if (ixgbe_allocate_pci_resources(adapter, pa)) { 817 aprint_error_dev(dev, "Allocation of PCI resources failed\n"); 818 error = ENXIO; 819 goto err_out; 820 } 821 822 /* let hardware know driver is loaded */ 823 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 824 ctrl_ext |= IXGBE_CTRL_EXT_DRV_LOAD; 825 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 826 827 /* 828 * Initialize the shared code 829 */ 830 if (ixgbe_init_shared_code(hw)) { 831 aprint_error_dev(dev, "Unable to initialize the shared code\n"); 832 error = ENXIO; 833 goto err_out; 834 } 835 836 switch (hw->mac.type) { 837 case ixgbe_mac_82598EB: 838 str = "82598EB"; 839 break; 840 case ixgbe_mac_82599EB: 841 str = "82599EB"; 842 break; 843 case ixgbe_mac_X540: 844 str = "X540"; 845 break; 846 case ixgbe_mac_X550: 847 str = "X550"; 848 break; 849 case ixgbe_mac_X550EM_x: 850 str = "X550EM"; 851 break; 852 case ixgbe_mac_X550EM_a: 853 str = "X550EM A"; 854 break; 855 default: 856 str = "Unknown"; 857 break; 858 } 859 aprint_normal_dev(dev, "device %s\n", str); 860 861 if (hw->mbx.ops.init_params) 862 hw->mbx.ops.init_params(hw); 863 864 hw->allow_unsupported_sfp = allow_unsupported_sfp; 865 866 /* Pick up the 82599 settings */ 867 if (hw->mac.type != ixgbe_mac_82598EB) { 868 hw->phy.smart_speed = ixgbe_smart_speed; 869 adapter->num_segs = IXGBE_82599_SCATTER; 870 } else 871 adapter->num_segs = IXGBE_82598_SCATTER; 872 873 hw->mac.ops.set_lan_id(hw); 874 ixgbe_init_device_features(adapter); 875 876 if (ixgbe_configure_interrupts(adapter)) { 877 error = ENXIO; 878 goto err_out; 879 } 880 881 /* Allocate multicast array memory. */ 882 adapter->mta = malloc(sizeof(*adapter->mta) * 883 MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_NOWAIT); 884 if (adapter->mta == NULL) { 885 aprint_error_dev(dev, "Cannot allocate multicast setup array\n"); 886 error = ENOMEM; 887 goto err_out; 888 } 889 890 /* Enable WoL (if supported) */ 891 ixgbe_check_wol_support(adapter); 892 893 /* Verify adapter fan is still functional (if applicable) */ 894 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 895 u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 896 ixgbe_check_fan_failure(adapter, esdp, FALSE); 897 } 898 899 /* Ensure SW/FW semaphore is free */ 900 ixgbe_init_swfw_semaphore(hw); 901 902 /* Enable EEE power saving */ 903 if (adapter->feat_en & IXGBE_FEATURE_EEE) 904 hw->mac.ops.setup_eee(hw, TRUE); 905 906 /* Set an initial default flow control value */ 907 hw->fc.requested_mode = ixgbe_flow_control; 908 909 /* Sysctls for limiting the amount of work done in the taskqueues */ 910 ixgbe_set_sysctl_value(adapter, "rx_processing_limit", 911 "max number of rx packets to process", 912 &adapter->rx_process_limit, ixgbe_rx_process_limit); 913 914 ixgbe_set_sysctl_value(adapter, "tx_processing_limit", 915 "max number of tx packets to process", 916 &adapter->tx_process_limit, ixgbe_tx_process_limit); 917 918 /* Do descriptor calc and sanity checks */ 919 if (((ixgbe_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 || 920 ixgbe_txd < MIN_TXD || ixgbe_txd > MAX_TXD) { 921 aprint_error_dev(dev, "TXD config issue, using default!\n"); 922 adapter->num_tx_desc = DEFAULT_TXD; 923 } else 924 adapter->num_tx_desc = ixgbe_txd; 925 926 /* 927 * With many RX rings it is easy to exceed the 928 * system mbuf allocation. Tuning nmbclusters 929 * can alleviate this. 930 */ 931 if (nmbclusters > 0) { 932 int s; 933 s = (ixgbe_rxd * adapter->num_queues) * ixgbe_total_ports; 934 if (s > nmbclusters) { 935 aprint_error_dev(dev, "RX Descriptors exceed " 936 "system mbuf max, using default instead!\n"); 937 ixgbe_rxd = DEFAULT_RXD; 938 } 939 } 940 941 if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 || 942 ixgbe_rxd < MIN_RXD || ixgbe_rxd > MAX_RXD) { 943 aprint_error_dev(dev, "RXD config issue, using default!\n"); 944 adapter->num_rx_desc = DEFAULT_RXD; 945 } else 946 adapter->num_rx_desc = ixgbe_rxd; 947 948 /* Allocate our TX/RX Queues */ 949 if (ixgbe_allocate_queues(adapter)) { 950 error = ENOMEM; 951 goto err_out; 952 } 953 954 hw->phy.reset_if_overtemp = TRUE; 955 error = ixgbe_reset_hw(hw); 956 hw->phy.reset_if_overtemp = FALSE; 957 if (error == IXGBE_ERR_SFP_NOT_PRESENT) { 958 /* 959 * No optics in this port, set up 960 * so the timer routine will probe 961 * for later insertion. 962 */ 963 adapter->sfp_probe = TRUE; 964 error = IXGBE_SUCCESS; 965 } else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) { 966 aprint_error_dev(dev, "Unsupported SFP+ module detected!\n"); 967 error = EIO; 968 goto err_late; 969 } else if (error) { 970 aprint_error_dev(dev, "Hardware initialization failed\n"); 971 error = EIO; 972 goto err_late; 973 } 974 975 /* Make sure we have a good EEPROM before we read from it */ 976 if (ixgbe_validate_eeprom_checksum(&adapter->hw, NULL) < 0) { 977 aprint_error_dev(dev, "The EEPROM Checksum Is Not Valid\n"); 978 error = EIO; 979 goto err_late; 980 } 981 982 aprint_normal("%s:", device_xname(dev)); 983 /* NVM Image Version */ 984 switch (hw->mac.type) { 985 case ixgbe_mac_X540: 986 case ixgbe_mac_X550EM_a: 987 hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg); 988 if (nvmreg == 0xffff) 989 break; 990 high = (nvmreg >> 12) & 0x0f; 991 low = (nvmreg >> 4) & 0xff; 992 id = nvmreg & 0x0f; 993 aprint_normal(" NVM Image Version %u.", high); 994 if (hw->mac.type == ixgbe_mac_X540) 995 str = "%x"; 996 else 997 str = "%02x"; 998 aprint_normal(str, low); 999 aprint_normal(" ID 0x%x,", id); 1000 break; 1001 case ixgbe_mac_X550EM_x: 1002 case ixgbe_mac_X550: 1003 hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg); 1004 if (nvmreg == 0xffff) 1005 break; 1006 high = (nvmreg >> 12) & 0x0f; 1007 low = nvmreg & 0xff; 1008 aprint_normal(" NVM Image Version %u.%02x,", high, low); 1009 break; 1010 default: 1011 break; 1012 } 1013 1014 /* PHY firmware revision */ 1015 switch (hw->mac.type) { 1016 case ixgbe_mac_X540: 1017 case ixgbe_mac_X550: 1018 hw->eeprom.ops.read(hw, IXGBE_PHYFW_REV, &nvmreg); 1019 if (nvmreg == 0xffff) 1020 break; 1021 high = (nvmreg >> 12) & 0x0f; 1022 low = (nvmreg >> 4) & 0xff; 1023 id = nvmreg & 0x000f; 1024 aprint_normal(" PHY FW Revision %u.", high); 1025 if (hw->mac.type == ixgbe_mac_X540) 1026 str = "%x"; 1027 else 1028 str = "%02x"; 1029 aprint_normal(str, low); 1030 aprint_normal(" ID 0x%x,", id); 1031 break; 1032 default: 1033 break; 1034 } 1035 1036 /* NVM Map version & OEM NVM Image version */ 1037 switch (hw->mac.type) { 1038 case ixgbe_mac_X550: 1039 case ixgbe_mac_X550EM_x: 1040 case ixgbe_mac_X550EM_a: 1041 hw->eeprom.ops.read(hw, IXGBE_NVM_MAP_VER, &nvmreg); 1042 if (nvmreg != 0xffff) { 1043 high = (nvmreg >> 12) & 0x0f; 1044 low = nvmreg & 0x00ff; 1045 aprint_normal(" NVM Map version %u.%02x,", high, low); 1046 } 1047 hw->eeprom.ops.read(hw, IXGBE_OEM_NVM_IMAGE_VER, &nvmreg); 1048 if (nvmreg != 0xffff) { 1049 high = (nvmreg >> 12) & 0x0f; 1050 low = nvmreg & 0x00ff; 1051 aprint_verbose(" OEM NVM Image version %u.%02x,", high, 1052 low); 1053 } 1054 break; 1055 default: 1056 break; 1057 } 1058 1059 /* Print the ETrackID */ 1060 hw->eeprom.ops.read(hw, IXGBE_ETRACKID_H, &high); 1061 hw->eeprom.ops.read(hw, IXGBE_ETRACKID_L, &low); 1062 aprint_normal(" ETrackID %08x\n", ((uint32_t)high << 16) | low); 1063 1064 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 1065 error = ixgbe_allocate_msix(adapter, pa); 1066 if (error) { 1067 /* Free allocated queue structures first */ 1068 ixgbe_free_transmit_structures(adapter); 1069 ixgbe_free_receive_structures(adapter); 1070 free(adapter->queues, M_DEVBUF); 1071 1072 /* Fallback to legacy interrupt */ 1073 adapter->feat_en &= ~IXGBE_FEATURE_MSIX; 1074 if (adapter->feat_cap & IXGBE_FEATURE_MSI) 1075 adapter->feat_en |= IXGBE_FEATURE_MSI; 1076 adapter->num_queues = 1; 1077 1078 /* Allocate our TX/RX Queues again */ 1079 if (ixgbe_allocate_queues(adapter)) { 1080 error = ENOMEM; 1081 goto err_out; 1082 } 1083 } 1084 } 1085 if ((adapter->feat_en & IXGBE_FEATURE_MSIX) == 0) 1086 error = ixgbe_allocate_legacy(adapter, pa); 1087 if (error) 1088 goto err_late; 1089 1090 /* Tasklets for Link, SFP, Multispeed Fiber and Flow Director */ 1091 adapter->link_si = softint_establish(SOFTINT_NET |IXGBE_SOFTINFT_FLAGS, 1092 ixgbe_handle_link, adapter); 1093 adapter->mod_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 1094 ixgbe_handle_mod, adapter); 1095 adapter->msf_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 1096 ixgbe_handle_msf, adapter); 1097 adapter->phy_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 1098 ixgbe_handle_phy, adapter); 1099 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 1100 adapter->fdir_si = 1101 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 1102 ixgbe_reinit_fdir, adapter); 1103 if ((adapter->link_si == NULL) || (adapter->mod_si == NULL) 1104 || (adapter->msf_si == NULL) || (adapter->phy_si == NULL) 1105 || ((adapter->feat_en & IXGBE_FEATURE_FDIR) 1106 && (adapter->fdir_si == NULL))) { 1107 aprint_error_dev(dev, 1108 "could not establish software interrupts ()\n"); 1109 goto err_out; 1110 } 1111 1112 error = ixgbe_start_hw(hw); 1113 switch (error) { 1114 case IXGBE_ERR_EEPROM_VERSION: 1115 aprint_error_dev(dev, "This device is a pre-production adapter/" 1116 "LOM. Please be aware there may be issues associated " 1117 "with your hardware.\nIf you are experiencing problems " 1118 "please contact your Intel or hardware representative " 1119 "who provided you with this hardware.\n"); 1120 break; 1121 case IXGBE_ERR_SFP_NOT_SUPPORTED: 1122 aprint_error_dev(dev, "Unsupported SFP+ Module\n"); 1123 error = EIO; 1124 goto err_late; 1125 case IXGBE_ERR_SFP_NOT_PRESENT: 1126 aprint_error_dev(dev, "No SFP+ Module found\n"); 1127 /* falls thru */ 1128 default: 1129 break; 1130 } 1131 1132 /* Setup OS specific network interface */ 1133 if (ixgbe_setup_interface(dev, adapter) != 0) 1134 goto err_late; 1135 1136 /* 1137 * Print PHY ID only for copper PHY. On device which has SFP(+) cage 1138 * and a module is inserted, phy.id is not MII PHY id but SFF 8024 ID. 1139 */ 1140 if (hw->phy.media_type == ixgbe_media_type_copper) { 1141 uint16_t id1, id2; 1142 int oui, model, rev; 1143 const char *descr; 1144 1145 id1 = hw->phy.id >> 16; 1146 id2 = hw->phy.id & 0xffff; 1147 oui = MII_OUI(id1, id2); 1148 model = MII_MODEL(id2); 1149 rev = MII_REV(id2); 1150 if ((descr = mii_get_descr(oui, model)) != NULL) 1151 aprint_normal_dev(dev, 1152 "PHY: %s (OUI 0x%06x, model 0x%04x), rev. %d\n", 1153 descr, oui, model, rev); 1154 else 1155 aprint_normal_dev(dev, 1156 "PHY OUI 0x%06x, model 0x%04x, rev. %d\n", 1157 oui, model, rev); 1158 } 1159 1160 /* Enable the optics for 82599 SFP+ fiber */ 1161 ixgbe_enable_tx_laser(hw); 1162 1163 /* Enable power to the phy. */ 1164 ixgbe_set_phy_power(hw, TRUE); 1165 1166 /* Initialize statistics */ 1167 ixgbe_update_stats_counters(adapter); 1168 1169 /* Check PCIE slot type/speed/width */ 1170 ixgbe_get_slot_info(adapter); 1171 1172 /* 1173 * Do time init and sysctl init here, but 1174 * only on the first port of a bypass adapter. 1175 */ 1176 ixgbe_bypass_init(adapter); 1177 1178 /* Set an initial dmac value */ 1179 adapter->dmac = 0; 1180 /* Set initial advertised speeds (if applicable) */ 1181 adapter->advertise = ixgbe_get_advertise(adapter); 1182 1183 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 1184 ixgbe_define_iov_schemas(dev, &error); 1185 1186 /* Add sysctls */ 1187 ixgbe_add_device_sysctls(adapter); 1188 ixgbe_add_hw_stats(adapter); 1189 1190 /* For Netmap */ 1191 adapter->init_locked = ixgbe_init_locked; 1192 adapter->stop_locked = ixgbe_stop; 1193 1194 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 1195 ixgbe_netmap_attach(adapter); 1196 1197 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_cap); 1198 aprint_verbose_dev(dev, "feature cap %s\n", buf); 1199 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_en); 1200 aprint_verbose_dev(dev, "feature ena %s\n", buf); 1201 1202 if (pmf_device_register(dev, ixgbe_suspend, ixgbe_resume)) 1203 pmf_class_network_register(dev, adapter->ifp); 1204 else 1205 aprint_error_dev(dev, "couldn't establish power handler\n"); 1206 1207 INIT_DEBUGOUT("ixgbe_attach: end"); 1208 adapter->osdep.attached = true; 1209 1210 return; 1211 1212 err_late: 1213 ixgbe_free_transmit_structures(adapter); 1214 ixgbe_free_receive_structures(adapter); 1215 free(adapter->queues, M_DEVBUF); 1216 err_out: 1217 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 1218 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 1219 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 1220 ixgbe_free_softint(adapter); 1221 ixgbe_free_pci_resources(adapter); 1222 if (adapter->mta != NULL) 1223 free(adapter->mta, M_DEVBUF); 1224 IXGBE_CORE_LOCK_DESTROY(adapter); 1225 1226 return; 1227 } /* ixgbe_attach */ 1228 1229 /************************************************************************ 1230 * ixgbe_check_wol_support 1231 * 1232 * Checks whether the adapter's ports are capable of 1233 * Wake On LAN by reading the adapter's NVM. 1234 * 1235 * Sets each port's hw->wol_enabled value depending 1236 * on the value read here. 1237 ************************************************************************/ 1238 static void 1239 ixgbe_check_wol_support(struct adapter *adapter) 1240 { 1241 struct ixgbe_hw *hw = &adapter->hw; 1242 u16 dev_caps = 0; 1243 1244 /* Find out WoL support for port */ 1245 adapter->wol_support = hw->wol_enabled = 0; 1246 ixgbe_get_device_caps(hw, &dev_caps); 1247 if ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0_1) || 1248 ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0) && 1249 hw->bus.func == 0)) 1250 adapter->wol_support = hw->wol_enabled = 1; 1251 1252 /* Save initial wake up filter configuration */ 1253 adapter->wufc = IXGBE_READ_REG(hw, IXGBE_WUFC); 1254 1255 return; 1256 } /* ixgbe_check_wol_support */ 1257 1258 /************************************************************************ 1259 * ixgbe_setup_interface 1260 * 1261 * Setup networking device structure and register an interface. 1262 ************************************************************************/ 1263 static int 1264 ixgbe_setup_interface(device_t dev, struct adapter *adapter) 1265 { 1266 struct ethercom *ec = &adapter->osdep.ec; 1267 struct ifnet *ifp; 1268 int rv; 1269 1270 INIT_DEBUGOUT("ixgbe_setup_interface: begin"); 1271 1272 ifp = adapter->ifp = &ec->ec_if; 1273 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 1274 ifp->if_baudrate = IF_Gbps(10); 1275 ifp->if_init = ixgbe_init; 1276 ifp->if_stop = ixgbe_ifstop; 1277 ifp->if_softc = adapter; 1278 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1279 #ifdef IXGBE_MPSAFE 1280 ifp->if_extflags = IFEF_MPSAFE; 1281 #endif 1282 ifp->if_ioctl = ixgbe_ioctl; 1283 #if __FreeBSD_version >= 1100045 1284 /* TSO parameters */ 1285 ifp->if_hw_tsomax = 65518; 1286 ifp->if_hw_tsomaxsegcount = IXGBE_82599_SCATTER; 1287 ifp->if_hw_tsomaxsegsize = 2048; 1288 #endif 1289 if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) { 1290 #if 0 1291 ixgbe_start_locked = ixgbe_legacy_start_locked; 1292 #endif 1293 } else { 1294 ifp->if_transmit = ixgbe_mq_start; 1295 #if 0 1296 ixgbe_start_locked = ixgbe_mq_start_locked; 1297 #endif 1298 } 1299 ifp->if_start = ixgbe_legacy_start; 1300 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 1301 IFQ_SET_READY(&ifp->if_snd); 1302 1303 rv = if_initialize(ifp); 1304 if (rv != 0) { 1305 aprint_error_dev(dev, "if_initialize failed(%d)\n", rv); 1306 return rv; 1307 } 1308 adapter->ipq = if_percpuq_create(&adapter->osdep.ec.ec_if); 1309 ether_ifattach(ifp, adapter->hw.mac.addr); 1310 /* 1311 * We use per TX queue softint, so if_deferred_start_init() isn't 1312 * used. 1313 */ 1314 if_register(ifp); 1315 ether_set_ifflags_cb(ec, ixgbe_ifflags_cb); 1316 1317 adapter->max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 1318 1319 /* 1320 * Tell the upper layer(s) we support long frames. 1321 */ 1322 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 1323 1324 /* Set capability flags */ 1325 ifp->if_capabilities |= IFCAP_RXCSUM 1326 | IFCAP_TXCSUM 1327 | IFCAP_TSOv4 1328 | IFCAP_TSOv6 1329 | IFCAP_LRO; 1330 ifp->if_capenable = 0; 1331 1332 ec->ec_capabilities |= ETHERCAP_VLAN_HWTAGGING 1333 | ETHERCAP_VLAN_HWCSUM 1334 | ETHERCAP_JUMBO_MTU 1335 | ETHERCAP_VLAN_MTU; 1336 1337 /* Enable the above capabilities by default */ 1338 ec->ec_capenable = ec->ec_capabilities; 1339 1340 /* 1341 * Don't turn this on by default, if vlans are 1342 * created on another pseudo device (eg. lagg) 1343 * then vlan events are not passed thru, breaking 1344 * operation, but with HW FILTER off it works. If 1345 * using vlans directly on the ixgbe driver you can 1346 * enable this and get full hardware tag filtering. 1347 */ 1348 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER; 1349 1350 /* 1351 * Specify the media types supported by this adapter and register 1352 * callbacks to update media and link information 1353 */ 1354 ifmedia_init(&adapter->media, IFM_IMASK, ixgbe_media_change, 1355 ixgbe_media_status); 1356 1357 adapter->phy_layer = ixgbe_get_supported_physical_layer(&adapter->hw); 1358 ixgbe_add_media_types(adapter); 1359 1360 /* Set autoselect media by default */ 1361 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1362 1363 return (0); 1364 } /* ixgbe_setup_interface */ 1365 1366 /************************************************************************ 1367 * ixgbe_add_media_types 1368 ************************************************************************/ 1369 static void 1370 ixgbe_add_media_types(struct adapter *adapter) 1371 { 1372 struct ixgbe_hw *hw = &adapter->hw; 1373 device_t dev = adapter->dev; 1374 u64 layer; 1375 1376 layer = adapter->phy_layer; 1377 1378 #define ADD(mm, dd) \ 1379 ifmedia_add(&adapter->media, IFM_ETHER | (mm), (dd), NULL); 1380 1381 /* Media types with matching NetBSD media defines */ 1382 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T) { 1383 ADD(IFM_10G_T | IFM_FDX, 0); 1384 } 1385 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T) { 1386 ADD(IFM_1000_T | IFM_FDX, 0); 1387 } 1388 if (layer & IXGBE_PHYSICAL_LAYER_100BASE_TX) { 1389 ADD(IFM_100_TX | IFM_FDX, 0); 1390 } 1391 if (layer & IXGBE_PHYSICAL_LAYER_10BASE_T) { 1392 ADD(IFM_10_T | IFM_FDX, 0); 1393 } 1394 1395 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 1396 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) { 1397 ADD(IFM_10G_TWINAX | IFM_FDX, 0); 1398 } 1399 1400 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) { 1401 ADD(IFM_10G_LR | IFM_FDX, 0); 1402 if (hw->phy.multispeed_fiber) { 1403 ADD(IFM_1000_LX | IFM_FDX, 0); 1404 } 1405 } 1406 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) { 1407 ADD(IFM_10G_SR | IFM_FDX, 0); 1408 if (hw->phy.multispeed_fiber) { 1409 ADD(IFM_1000_SX | IFM_FDX, 0); 1410 } 1411 } else if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) { 1412 ADD(IFM_1000_SX | IFM_FDX, 0); 1413 } 1414 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) { 1415 ADD(IFM_10G_CX4 | IFM_FDX, 0); 1416 } 1417 1418 #ifdef IFM_ETH_XTYPE 1419 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) { 1420 ADD(IFM_10G_KR | IFM_FDX, 0); 1421 } 1422 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) { 1423 ADD(AIFM_10G_KX4 | IFM_FDX, 0); 1424 } 1425 #else 1426 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) { 1427 device_printf(dev, "Media supported: 10GbaseKR\n"); 1428 device_printf(dev, "10GbaseKR mapped to 10GbaseSR\n"); 1429 ADD(IFM_10G_SR | IFM_FDX, 0); 1430 } 1431 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) { 1432 device_printf(dev, "Media supported: 10GbaseKX4\n"); 1433 device_printf(dev, "10GbaseKX4 mapped to 10GbaseCX4\n"); 1434 ADD(IFM_10G_CX4 | IFM_FDX, 0); 1435 } 1436 #endif 1437 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) { 1438 ADD(IFM_1000_KX | IFM_FDX, 0); 1439 } 1440 if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX) { 1441 ADD(IFM_2500_KX | IFM_FDX, 0); 1442 } 1443 if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_T) { 1444 ADD(IFM_2500_T | IFM_FDX, 0); 1445 } 1446 if (layer & IXGBE_PHYSICAL_LAYER_5GBASE_T) { 1447 ADD(IFM_5000_T | IFM_FDX, 0); 1448 } 1449 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_BX) 1450 device_printf(dev, "Media supported: 1000baseBX\n"); 1451 /* XXX no ifmedia_set? */ 1452 1453 ADD(IFM_AUTO, 0); 1454 1455 #undef ADD 1456 } /* ixgbe_add_media_types */ 1457 1458 /************************************************************************ 1459 * ixgbe_is_sfp 1460 ************************************************************************/ 1461 static inline bool 1462 ixgbe_is_sfp(struct ixgbe_hw *hw) 1463 { 1464 switch (hw->mac.type) { 1465 case ixgbe_mac_82598EB: 1466 if (hw->phy.type == ixgbe_phy_nl) 1467 return TRUE; 1468 return FALSE; 1469 case ixgbe_mac_82599EB: 1470 switch (hw->mac.ops.get_media_type(hw)) { 1471 case ixgbe_media_type_fiber: 1472 case ixgbe_media_type_fiber_qsfp: 1473 return TRUE; 1474 default: 1475 return FALSE; 1476 } 1477 case ixgbe_mac_X550EM_x: 1478 case ixgbe_mac_X550EM_a: 1479 if (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber) 1480 return TRUE; 1481 return FALSE; 1482 default: 1483 return FALSE; 1484 } 1485 } /* ixgbe_is_sfp */ 1486 1487 /************************************************************************ 1488 * ixgbe_config_link 1489 ************************************************************************/ 1490 static void 1491 ixgbe_config_link(struct adapter *adapter) 1492 { 1493 struct ixgbe_hw *hw = &adapter->hw; 1494 u32 autoneg, err = 0; 1495 bool sfp, negotiate = false; 1496 1497 sfp = ixgbe_is_sfp(hw); 1498 1499 if (sfp) { 1500 if (hw->phy.multispeed_fiber) { 1501 hw->mac.ops.setup_sfp(hw); 1502 ixgbe_enable_tx_laser(hw); 1503 kpreempt_disable(); 1504 softint_schedule(adapter->msf_si); 1505 kpreempt_enable(); 1506 } else { 1507 kpreempt_disable(); 1508 softint_schedule(adapter->mod_si); 1509 kpreempt_enable(); 1510 } 1511 } else { 1512 if (hw->mac.ops.check_link) 1513 err = ixgbe_check_link(hw, &adapter->link_speed, 1514 &adapter->link_up, FALSE); 1515 if (err) 1516 goto out; 1517 autoneg = hw->phy.autoneg_advertised; 1518 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 1519 err = hw->mac.ops.get_link_capabilities(hw, &autoneg, 1520 &negotiate); 1521 if (err) 1522 goto out; 1523 if (hw->mac.ops.setup_link) 1524 err = hw->mac.ops.setup_link(hw, autoneg, 1525 adapter->link_up); 1526 } 1527 out: 1528 1529 return; 1530 } /* ixgbe_config_link */ 1531 1532 /************************************************************************ 1533 * ixgbe_update_stats_counters - Update board statistics counters. 1534 ************************************************************************/ 1535 static void 1536 ixgbe_update_stats_counters(struct adapter *adapter) 1537 { 1538 struct ifnet *ifp = adapter->ifp; 1539 struct ixgbe_hw *hw = &adapter->hw; 1540 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1541 u32 missed_rx = 0, bprc, lxon, lxoff, total; 1542 u64 total_missed_rx = 0; 1543 uint64_t crcerrs, rlec; 1544 1545 crcerrs = IXGBE_READ_REG(hw, IXGBE_CRCERRS); 1546 stats->crcerrs.ev_count += crcerrs; 1547 stats->illerrc.ev_count += IXGBE_READ_REG(hw, IXGBE_ILLERRC); 1548 stats->errbc.ev_count += IXGBE_READ_REG(hw, IXGBE_ERRBC); 1549 stats->mspdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MSPDC); 1550 if (hw->mac.type == ixgbe_mac_X550) 1551 stats->mbsdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MBSDC); 1552 1553 for (int i = 0; i < __arraycount(stats->qprc); i++) { 1554 int j = i % adapter->num_queues; 1555 stats->qprc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRC(i)); 1556 stats->qptc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPTC(i)); 1557 stats->qprdc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRDC(i)); 1558 } 1559 for (int i = 0; i < __arraycount(stats->mpc); i++) { 1560 uint32_t mp; 1561 int j = i % adapter->num_queues; 1562 1563 mp = IXGBE_READ_REG(hw, IXGBE_MPC(i)); 1564 /* global total per queue */ 1565 stats->mpc[j].ev_count += mp; 1566 /* running comprehensive total for stats display */ 1567 total_missed_rx += mp; 1568 1569 if (hw->mac.type == ixgbe_mac_82598EB) 1570 stats->rnbc[j].ev_count 1571 += IXGBE_READ_REG(hw, IXGBE_RNBC(i)); 1572 1573 } 1574 stats->mpctotal.ev_count += total_missed_rx; 1575 1576 /* Document says M[LR]FC are valid when link is up and 10Gbps */ 1577 if ((adapter->link_active == TRUE) 1578 && (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL)) { 1579 stats->mlfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MLFC); 1580 stats->mrfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MRFC); 1581 } 1582 rlec = IXGBE_READ_REG(hw, IXGBE_RLEC); 1583 stats->rlec.ev_count += rlec; 1584 1585 /* Hardware workaround, gprc counts missed packets */ 1586 stats->gprc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx; 1587 1588 lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC); 1589 stats->lxontxc.ev_count += lxon; 1590 lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC); 1591 stats->lxofftxc.ev_count += lxoff; 1592 total = lxon + lxoff; 1593 1594 if (hw->mac.type != ixgbe_mac_82598EB) { 1595 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCL) + 1596 ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32); 1597 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCL) + 1598 ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32) - total * ETHER_MIN_LEN; 1599 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORL) + 1600 ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32); 1601 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); 1602 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT); 1603 } else { 1604 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXC); 1605 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC); 1606 /* 82598 only has a counter in the high register */ 1607 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCH); 1608 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH) - total * ETHER_MIN_LEN; 1609 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORH); 1610 } 1611 1612 /* 1613 * Workaround: mprc hardware is incorrectly counting 1614 * broadcasts, so for now we subtract those. 1615 */ 1616 bprc = IXGBE_READ_REG(hw, IXGBE_BPRC); 1617 stats->bprc.ev_count += bprc; 1618 stats->mprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPRC) 1619 - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0); 1620 1621 stats->prc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC64); 1622 stats->prc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC127); 1623 stats->prc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC255); 1624 stats->prc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC511); 1625 stats->prc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1023); 1626 stats->prc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1522); 1627 1628 stats->gptc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPTC) - total; 1629 stats->mptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPTC) - total; 1630 stats->ptc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC64) - total; 1631 1632 stats->ruc.ev_count += IXGBE_READ_REG(hw, IXGBE_RUC); 1633 stats->rfc.ev_count += IXGBE_READ_REG(hw, IXGBE_RFC); 1634 stats->roc.ev_count += IXGBE_READ_REG(hw, IXGBE_ROC); 1635 stats->rjc.ev_count += IXGBE_READ_REG(hw, IXGBE_RJC); 1636 stats->mngprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPRC); 1637 stats->mngpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPDC); 1638 stats->mngptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPTC); 1639 stats->tpr.ev_count += IXGBE_READ_REG(hw, IXGBE_TPR); 1640 stats->tpt.ev_count += IXGBE_READ_REG(hw, IXGBE_TPT); 1641 stats->ptc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC127); 1642 stats->ptc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC255); 1643 stats->ptc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC511); 1644 stats->ptc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1023); 1645 stats->ptc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1522); 1646 stats->bptc.ev_count += IXGBE_READ_REG(hw, IXGBE_BPTC); 1647 stats->xec.ev_count += IXGBE_READ_REG(hw, IXGBE_XEC); 1648 stats->fccrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCCRC); 1649 stats->fclast.ev_count += IXGBE_READ_REG(hw, IXGBE_FCLAST); 1650 /* Only read FCOE on 82599 */ 1651 if (hw->mac.type != ixgbe_mac_82598EB) { 1652 stats->fcoerpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOERPDC); 1653 stats->fcoeprc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPRC); 1654 stats->fcoeptc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPTC); 1655 stats->fcoedwrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWRC); 1656 stats->fcoedwtc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWTC); 1657 } 1658 1659 /* Fill out the OS statistics structure */ 1660 /* 1661 * NetBSD: Don't override if_{i|o}{packets|bytes|mcasts} with 1662 * adapter->stats counters. It's required to make ifconfig -z 1663 * (SOICZIFDATA) work. 1664 */ 1665 ifp->if_collisions = 0; 1666 1667 /* Rx Errors */ 1668 ifp->if_iqdrops += total_missed_rx; 1669 ifp->if_ierrors += crcerrs + rlec; 1670 } /* ixgbe_update_stats_counters */ 1671 1672 /************************************************************************ 1673 * ixgbe_add_hw_stats 1674 * 1675 * Add sysctl variables, one per statistic, to the system. 1676 ************************************************************************/ 1677 static void 1678 ixgbe_add_hw_stats(struct adapter *adapter) 1679 { 1680 device_t dev = adapter->dev; 1681 const struct sysctlnode *rnode, *cnode; 1682 struct sysctllog **log = &adapter->sysctllog; 1683 struct tx_ring *txr = adapter->tx_rings; 1684 struct rx_ring *rxr = adapter->rx_rings; 1685 struct ixgbe_hw *hw = &adapter->hw; 1686 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1687 const char *xname = device_xname(dev); 1688 1689 /* Driver Statistics */ 1690 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 1691 NULL, xname, "Driver tx dma soft fail EFBIG"); 1692 evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC, 1693 NULL, xname, "m_defrag() failed"); 1694 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 1695 NULL, xname, "Driver tx dma hard fail EFBIG"); 1696 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 1697 NULL, xname, "Driver tx dma hard fail EINVAL"); 1698 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 1699 NULL, xname, "Driver tx dma hard fail other"); 1700 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 1701 NULL, xname, "Driver tx dma soft fail EAGAIN"); 1702 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 1703 NULL, xname, "Driver tx dma soft fail ENOMEM"); 1704 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 1705 NULL, xname, "Watchdog timeouts"); 1706 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 1707 NULL, xname, "TSO errors"); 1708 evcnt_attach_dynamic(&adapter->link_irq, EVCNT_TYPE_INTR, 1709 NULL, xname, "Link MSI-X IRQ Handled"); 1710 1711 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 1712 #ifdef LRO 1713 struct lro_ctrl *lro = &rxr->lro; 1714 #endif /* LRO */ 1715 1716 snprintf(adapter->queues[i].evnamebuf, 1717 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 1718 xname, i); 1719 snprintf(adapter->queues[i].namebuf, 1720 sizeof(adapter->queues[i].namebuf), "q%d", i); 1721 1722 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 1723 aprint_error_dev(dev, "could not create sysctl root\n"); 1724 break; 1725 } 1726 1727 if (sysctl_createv(log, 0, &rnode, &rnode, 1728 0, CTLTYPE_NODE, 1729 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 1730 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 1731 break; 1732 1733 if (sysctl_createv(log, 0, &rnode, &cnode, 1734 CTLFLAG_READWRITE, CTLTYPE_INT, 1735 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 1736 ixgbe_sysctl_interrupt_rate_handler, 0, 1737 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 1738 break; 1739 1740 if (sysctl_createv(log, 0, &rnode, &cnode, 1741 CTLFLAG_READONLY, CTLTYPE_INT, 1742 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 1743 ixgbe_sysctl_tdh_handler, 0, (void *)txr, 1744 0, CTL_CREATE, CTL_EOL) != 0) 1745 break; 1746 1747 if (sysctl_createv(log, 0, &rnode, &cnode, 1748 CTLFLAG_READONLY, CTLTYPE_INT, 1749 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 1750 ixgbe_sysctl_tdt_handler, 0, (void *)txr, 1751 0, CTL_CREATE, CTL_EOL) != 0) 1752 break; 1753 1754 evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR, 1755 NULL, adapter->queues[i].evnamebuf, "IRQs on queue"); 1756 evcnt_attach_dynamic(&adapter->queues[i].handleq, 1757 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1758 "Handled queue in softint"); 1759 evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC, 1760 NULL, adapter->queues[i].evnamebuf, "Requeued in softint"); 1761 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 1762 NULL, adapter->queues[i].evnamebuf, "TSO"); 1763 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 1764 NULL, adapter->queues[i].evnamebuf, 1765 "Queue No Descriptor Available"); 1766 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 1767 NULL, adapter->queues[i].evnamebuf, 1768 "Queue Packets Transmitted"); 1769 #ifndef IXGBE_LEGACY_TX 1770 evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC, 1771 NULL, adapter->queues[i].evnamebuf, 1772 "Packets dropped in pcq"); 1773 #endif 1774 1775 if (sysctl_createv(log, 0, &rnode, &cnode, 1776 CTLFLAG_READONLY, 1777 CTLTYPE_INT, 1778 "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"), 1779 ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0, 1780 CTL_CREATE, CTL_EOL) != 0) 1781 break; 1782 1783 if (sysctl_createv(log, 0, &rnode, &cnode, 1784 CTLFLAG_READONLY, 1785 CTLTYPE_INT, 1786 "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"), 1787 ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0, 1788 CTL_CREATE, CTL_EOL) != 0) 1789 break; 1790 1791 if (i < __arraycount(stats->mpc)) { 1792 evcnt_attach_dynamic(&stats->mpc[i], 1793 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1794 "RX Missed Packet Count"); 1795 if (hw->mac.type == ixgbe_mac_82598EB) 1796 evcnt_attach_dynamic(&stats->rnbc[i], 1797 EVCNT_TYPE_MISC, NULL, 1798 adapter->queues[i].evnamebuf, 1799 "Receive No Buffers"); 1800 } 1801 if (i < __arraycount(stats->pxontxc)) { 1802 evcnt_attach_dynamic(&stats->pxontxc[i], 1803 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1804 "pxontxc"); 1805 evcnt_attach_dynamic(&stats->pxonrxc[i], 1806 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1807 "pxonrxc"); 1808 evcnt_attach_dynamic(&stats->pxofftxc[i], 1809 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1810 "pxofftxc"); 1811 evcnt_attach_dynamic(&stats->pxoffrxc[i], 1812 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1813 "pxoffrxc"); 1814 evcnt_attach_dynamic(&stats->pxon2offc[i], 1815 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1816 "pxon2offc"); 1817 } 1818 if (i < __arraycount(stats->qprc)) { 1819 evcnt_attach_dynamic(&stats->qprc[i], 1820 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1821 "qprc"); 1822 evcnt_attach_dynamic(&stats->qptc[i], 1823 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1824 "qptc"); 1825 evcnt_attach_dynamic(&stats->qbrc[i], 1826 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1827 "qbrc"); 1828 evcnt_attach_dynamic(&stats->qbtc[i], 1829 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1830 "qbtc"); 1831 evcnt_attach_dynamic(&stats->qprdc[i], 1832 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1833 "qprdc"); 1834 } 1835 1836 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 1837 NULL, adapter->queues[i].evnamebuf, "Queue Packets Received"); 1838 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 1839 NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received"); 1840 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 1841 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 1842 evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC, 1843 NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf"); 1844 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 1845 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 1846 #ifdef LRO 1847 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 1848 CTLFLAG_RD, &lro->lro_queued, 0, 1849 "LRO Queued"); 1850 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 1851 CTLFLAG_RD, &lro->lro_flushed, 0, 1852 "LRO Flushed"); 1853 #endif /* LRO */ 1854 } 1855 1856 /* MAC stats get their own sub node */ 1857 1858 snprintf(stats->namebuf, 1859 sizeof(stats->namebuf), "%s MAC Statistics", xname); 1860 1861 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 1862 stats->namebuf, "rx csum offload - IP"); 1863 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 1864 stats->namebuf, "rx csum offload - L4"); 1865 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 1866 stats->namebuf, "rx csum offload - IP bad"); 1867 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 1868 stats->namebuf, "rx csum offload - L4 bad"); 1869 evcnt_attach_dynamic(&stats->intzero, EVCNT_TYPE_MISC, NULL, 1870 stats->namebuf, "Interrupt conditions zero"); 1871 evcnt_attach_dynamic(&stats->legint, EVCNT_TYPE_MISC, NULL, 1872 stats->namebuf, "Legacy interrupts"); 1873 1874 evcnt_attach_dynamic(&stats->crcerrs, EVCNT_TYPE_MISC, NULL, 1875 stats->namebuf, "CRC Errors"); 1876 evcnt_attach_dynamic(&stats->illerrc, EVCNT_TYPE_MISC, NULL, 1877 stats->namebuf, "Illegal Byte Errors"); 1878 evcnt_attach_dynamic(&stats->errbc, EVCNT_TYPE_MISC, NULL, 1879 stats->namebuf, "Byte Errors"); 1880 evcnt_attach_dynamic(&stats->mspdc, EVCNT_TYPE_MISC, NULL, 1881 stats->namebuf, "MAC Short Packets Discarded"); 1882 if (hw->mac.type >= ixgbe_mac_X550) 1883 evcnt_attach_dynamic(&stats->mbsdc, EVCNT_TYPE_MISC, NULL, 1884 stats->namebuf, "Bad SFD"); 1885 evcnt_attach_dynamic(&stats->mpctotal, EVCNT_TYPE_MISC, NULL, 1886 stats->namebuf, "Total Packets Missed"); 1887 evcnt_attach_dynamic(&stats->mlfc, EVCNT_TYPE_MISC, NULL, 1888 stats->namebuf, "MAC Local Faults"); 1889 evcnt_attach_dynamic(&stats->mrfc, EVCNT_TYPE_MISC, NULL, 1890 stats->namebuf, "MAC Remote Faults"); 1891 evcnt_attach_dynamic(&stats->rlec, EVCNT_TYPE_MISC, NULL, 1892 stats->namebuf, "Receive Length Errors"); 1893 evcnt_attach_dynamic(&stats->lxontxc, EVCNT_TYPE_MISC, NULL, 1894 stats->namebuf, "Link XON Transmitted"); 1895 evcnt_attach_dynamic(&stats->lxonrxc, EVCNT_TYPE_MISC, NULL, 1896 stats->namebuf, "Link XON Received"); 1897 evcnt_attach_dynamic(&stats->lxofftxc, EVCNT_TYPE_MISC, NULL, 1898 stats->namebuf, "Link XOFF Transmitted"); 1899 evcnt_attach_dynamic(&stats->lxoffrxc, EVCNT_TYPE_MISC, NULL, 1900 stats->namebuf, "Link XOFF Received"); 1901 1902 /* Packet Reception Stats */ 1903 evcnt_attach_dynamic(&stats->tor, EVCNT_TYPE_MISC, NULL, 1904 stats->namebuf, "Total Octets Received"); 1905 evcnt_attach_dynamic(&stats->gorc, EVCNT_TYPE_MISC, NULL, 1906 stats->namebuf, "Good Octets Received"); 1907 evcnt_attach_dynamic(&stats->tpr, EVCNT_TYPE_MISC, NULL, 1908 stats->namebuf, "Total Packets Received"); 1909 evcnt_attach_dynamic(&stats->gprc, EVCNT_TYPE_MISC, NULL, 1910 stats->namebuf, "Good Packets Received"); 1911 evcnt_attach_dynamic(&stats->mprc, EVCNT_TYPE_MISC, NULL, 1912 stats->namebuf, "Multicast Packets Received"); 1913 evcnt_attach_dynamic(&stats->bprc, EVCNT_TYPE_MISC, NULL, 1914 stats->namebuf, "Broadcast Packets Received"); 1915 evcnt_attach_dynamic(&stats->prc64, EVCNT_TYPE_MISC, NULL, 1916 stats->namebuf, "64 byte frames received "); 1917 evcnt_attach_dynamic(&stats->prc127, EVCNT_TYPE_MISC, NULL, 1918 stats->namebuf, "65-127 byte frames received"); 1919 evcnt_attach_dynamic(&stats->prc255, EVCNT_TYPE_MISC, NULL, 1920 stats->namebuf, "128-255 byte frames received"); 1921 evcnt_attach_dynamic(&stats->prc511, EVCNT_TYPE_MISC, NULL, 1922 stats->namebuf, "256-511 byte frames received"); 1923 evcnt_attach_dynamic(&stats->prc1023, EVCNT_TYPE_MISC, NULL, 1924 stats->namebuf, "512-1023 byte frames received"); 1925 evcnt_attach_dynamic(&stats->prc1522, EVCNT_TYPE_MISC, NULL, 1926 stats->namebuf, "1023-1522 byte frames received"); 1927 evcnt_attach_dynamic(&stats->ruc, EVCNT_TYPE_MISC, NULL, 1928 stats->namebuf, "Receive Undersized"); 1929 evcnt_attach_dynamic(&stats->rfc, EVCNT_TYPE_MISC, NULL, 1930 stats->namebuf, "Fragmented Packets Received "); 1931 evcnt_attach_dynamic(&stats->roc, EVCNT_TYPE_MISC, NULL, 1932 stats->namebuf, "Oversized Packets Received"); 1933 evcnt_attach_dynamic(&stats->rjc, EVCNT_TYPE_MISC, NULL, 1934 stats->namebuf, "Received Jabber"); 1935 evcnt_attach_dynamic(&stats->mngprc, EVCNT_TYPE_MISC, NULL, 1936 stats->namebuf, "Management Packets Received"); 1937 evcnt_attach_dynamic(&stats->mngpdc, EVCNT_TYPE_MISC, NULL, 1938 stats->namebuf, "Management Packets Dropped"); 1939 evcnt_attach_dynamic(&stats->xec, EVCNT_TYPE_MISC, NULL, 1940 stats->namebuf, "Checksum Errors"); 1941 1942 /* Packet Transmission Stats */ 1943 evcnt_attach_dynamic(&stats->gotc, EVCNT_TYPE_MISC, NULL, 1944 stats->namebuf, "Good Octets Transmitted"); 1945 evcnt_attach_dynamic(&stats->tpt, EVCNT_TYPE_MISC, NULL, 1946 stats->namebuf, "Total Packets Transmitted"); 1947 evcnt_attach_dynamic(&stats->gptc, EVCNT_TYPE_MISC, NULL, 1948 stats->namebuf, "Good Packets Transmitted"); 1949 evcnt_attach_dynamic(&stats->bptc, EVCNT_TYPE_MISC, NULL, 1950 stats->namebuf, "Broadcast Packets Transmitted"); 1951 evcnt_attach_dynamic(&stats->mptc, EVCNT_TYPE_MISC, NULL, 1952 stats->namebuf, "Multicast Packets Transmitted"); 1953 evcnt_attach_dynamic(&stats->mngptc, EVCNT_TYPE_MISC, NULL, 1954 stats->namebuf, "Management Packets Transmitted"); 1955 evcnt_attach_dynamic(&stats->ptc64, EVCNT_TYPE_MISC, NULL, 1956 stats->namebuf, "64 byte frames transmitted "); 1957 evcnt_attach_dynamic(&stats->ptc127, EVCNT_TYPE_MISC, NULL, 1958 stats->namebuf, "65-127 byte frames transmitted"); 1959 evcnt_attach_dynamic(&stats->ptc255, EVCNT_TYPE_MISC, NULL, 1960 stats->namebuf, "128-255 byte frames transmitted"); 1961 evcnt_attach_dynamic(&stats->ptc511, EVCNT_TYPE_MISC, NULL, 1962 stats->namebuf, "256-511 byte frames transmitted"); 1963 evcnt_attach_dynamic(&stats->ptc1023, EVCNT_TYPE_MISC, NULL, 1964 stats->namebuf, "512-1023 byte frames transmitted"); 1965 evcnt_attach_dynamic(&stats->ptc1522, EVCNT_TYPE_MISC, NULL, 1966 stats->namebuf, "1024-1522 byte frames transmitted"); 1967 } /* ixgbe_add_hw_stats */ 1968 1969 static void 1970 ixgbe_clear_evcnt(struct adapter *adapter) 1971 { 1972 struct tx_ring *txr = adapter->tx_rings; 1973 struct rx_ring *rxr = adapter->rx_rings; 1974 struct ixgbe_hw *hw = &adapter->hw; 1975 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1976 1977 adapter->efbig_tx_dma_setup.ev_count = 0; 1978 adapter->mbuf_defrag_failed.ev_count = 0; 1979 adapter->efbig2_tx_dma_setup.ev_count = 0; 1980 adapter->einval_tx_dma_setup.ev_count = 0; 1981 adapter->other_tx_dma_setup.ev_count = 0; 1982 adapter->eagain_tx_dma_setup.ev_count = 0; 1983 adapter->enomem_tx_dma_setup.ev_count = 0; 1984 adapter->tso_err.ev_count = 0; 1985 adapter->watchdog_events.ev_count = 0; 1986 adapter->link_irq.ev_count = 0; 1987 1988 txr = adapter->tx_rings; 1989 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 1990 adapter->queues[i].irqs.ev_count = 0; 1991 adapter->queues[i].handleq.ev_count = 0; 1992 adapter->queues[i].req.ev_count = 0; 1993 txr->no_desc_avail.ev_count = 0; 1994 txr->total_packets.ev_count = 0; 1995 txr->tso_tx.ev_count = 0; 1996 #ifndef IXGBE_LEGACY_TX 1997 txr->pcq_drops.ev_count = 0; 1998 #endif 1999 txr->q_efbig_tx_dma_setup = 0; 2000 txr->q_mbuf_defrag_failed = 0; 2001 txr->q_efbig2_tx_dma_setup = 0; 2002 txr->q_einval_tx_dma_setup = 0; 2003 txr->q_other_tx_dma_setup = 0; 2004 txr->q_eagain_tx_dma_setup = 0; 2005 txr->q_enomem_tx_dma_setup = 0; 2006 txr->q_tso_err = 0; 2007 2008 if (i < __arraycount(stats->mpc)) { 2009 stats->mpc[i].ev_count = 0; 2010 if (hw->mac.type == ixgbe_mac_82598EB) 2011 stats->rnbc[i].ev_count = 0; 2012 } 2013 if (i < __arraycount(stats->pxontxc)) { 2014 stats->pxontxc[i].ev_count = 0; 2015 stats->pxonrxc[i].ev_count = 0; 2016 stats->pxofftxc[i].ev_count = 0; 2017 stats->pxoffrxc[i].ev_count = 0; 2018 stats->pxon2offc[i].ev_count = 0; 2019 } 2020 if (i < __arraycount(stats->qprc)) { 2021 stats->qprc[i].ev_count = 0; 2022 stats->qptc[i].ev_count = 0; 2023 stats->qbrc[i].ev_count = 0; 2024 stats->qbtc[i].ev_count = 0; 2025 stats->qprdc[i].ev_count = 0; 2026 } 2027 2028 rxr->rx_packets.ev_count = 0; 2029 rxr->rx_bytes.ev_count = 0; 2030 rxr->rx_copies.ev_count = 0; 2031 rxr->no_jmbuf.ev_count = 0; 2032 rxr->rx_discarded.ev_count = 0; 2033 } 2034 stats->ipcs.ev_count = 0; 2035 stats->l4cs.ev_count = 0; 2036 stats->ipcs_bad.ev_count = 0; 2037 stats->l4cs_bad.ev_count = 0; 2038 stats->intzero.ev_count = 0; 2039 stats->legint.ev_count = 0; 2040 stats->crcerrs.ev_count = 0; 2041 stats->illerrc.ev_count = 0; 2042 stats->errbc.ev_count = 0; 2043 stats->mspdc.ev_count = 0; 2044 stats->mbsdc.ev_count = 0; 2045 stats->mpctotal.ev_count = 0; 2046 stats->mlfc.ev_count = 0; 2047 stats->mrfc.ev_count = 0; 2048 stats->rlec.ev_count = 0; 2049 stats->lxontxc.ev_count = 0; 2050 stats->lxonrxc.ev_count = 0; 2051 stats->lxofftxc.ev_count = 0; 2052 stats->lxoffrxc.ev_count = 0; 2053 2054 /* Packet Reception Stats */ 2055 stats->tor.ev_count = 0; 2056 stats->gorc.ev_count = 0; 2057 stats->tpr.ev_count = 0; 2058 stats->gprc.ev_count = 0; 2059 stats->mprc.ev_count = 0; 2060 stats->bprc.ev_count = 0; 2061 stats->prc64.ev_count = 0; 2062 stats->prc127.ev_count = 0; 2063 stats->prc255.ev_count = 0; 2064 stats->prc511.ev_count = 0; 2065 stats->prc1023.ev_count = 0; 2066 stats->prc1522.ev_count = 0; 2067 stats->ruc.ev_count = 0; 2068 stats->rfc.ev_count = 0; 2069 stats->roc.ev_count = 0; 2070 stats->rjc.ev_count = 0; 2071 stats->mngprc.ev_count = 0; 2072 stats->mngpdc.ev_count = 0; 2073 stats->xec.ev_count = 0; 2074 2075 /* Packet Transmission Stats */ 2076 stats->gotc.ev_count = 0; 2077 stats->tpt.ev_count = 0; 2078 stats->gptc.ev_count = 0; 2079 stats->bptc.ev_count = 0; 2080 stats->mptc.ev_count = 0; 2081 stats->mngptc.ev_count = 0; 2082 stats->ptc64.ev_count = 0; 2083 stats->ptc127.ev_count = 0; 2084 stats->ptc255.ev_count = 0; 2085 stats->ptc511.ev_count = 0; 2086 stats->ptc1023.ev_count = 0; 2087 stats->ptc1522.ev_count = 0; 2088 } 2089 2090 /************************************************************************ 2091 * ixgbe_sysctl_tdh_handler - Transmit Descriptor Head handler function 2092 * 2093 * Retrieves the TDH value from the hardware 2094 ************************************************************************/ 2095 static int 2096 ixgbe_sysctl_tdh_handler(SYSCTLFN_ARGS) 2097 { 2098 struct sysctlnode node = *rnode; 2099 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2100 uint32_t val; 2101 2102 if (!txr) 2103 return (0); 2104 2105 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDH(txr->me)); 2106 node.sysctl_data = &val; 2107 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2108 } /* ixgbe_sysctl_tdh_handler */ 2109 2110 /************************************************************************ 2111 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 2112 * 2113 * Retrieves the TDT value from the hardware 2114 ************************************************************************/ 2115 static int 2116 ixgbe_sysctl_tdt_handler(SYSCTLFN_ARGS) 2117 { 2118 struct sysctlnode node = *rnode; 2119 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2120 uint32_t val; 2121 2122 if (!txr) 2123 return (0); 2124 2125 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDT(txr->me)); 2126 node.sysctl_data = &val; 2127 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2128 } /* ixgbe_sysctl_tdt_handler */ 2129 2130 /************************************************************************ 2131 * ixgbe_sysctl_rdh_handler - Receive Descriptor Head handler function 2132 * 2133 * Retrieves the RDH value from the hardware 2134 ************************************************************************/ 2135 static int 2136 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS) 2137 { 2138 struct sysctlnode node = *rnode; 2139 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2140 uint32_t val; 2141 2142 if (!rxr) 2143 return (0); 2144 2145 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDH(rxr->me)); 2146 node.sysctl_data = &val; 2147 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2148 } /* ixgbe_sysctl_rdh_handler */ 2149 2150 /************************************************************************ 2151 * ixgbe_sysctl_rdt_handler - Receive Descriptor Tail handler function 2152 * 2153 * Retrieves the RDT value from the hardware 2154 ************************************************************************/ 2155 static int 2156 ixgbe_sysctl_rdt_handler(SYSCTLFN_ARGS) 2157 { 2158 struct sysctlnode node = *rnode; 2159 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2160 uint32_t val; 2161 2162 if (!rxr) 2163 return (0); 2164 2165 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDT(rxr->me)); 2166 node.sysctl_data = &val; 2167 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2168 } /* ixgbe_sysctl_rdt_handler */ 2169 2170 #if 0 /* XXX Badly need to overhaul vlan(4) on NetBSD. */ 2171 /************************************************************************ 2172 * ixgbe_register_vlan 2173 * 2174 * Run via vlan config EVENT, it enables us to use the 2175 * HW Filter table since we can get the vlan id. This 2176 * just creates the entry in the soft version of the 2177 * VFTA, init will repopulate the real table. 2178 ************************************************************************/ 2179 static void 2180 ixgbe_register_vlan(void *arg, struct ifnet *ifp, u16 vtag) 2181 { 2182 struct adapter *adapter = ifp->if_softc; 2183 u16 index, bit; 2184 2185 if (ifp->if_softc != arg) /* Not our event */ 2186 return; 2187 2188 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2189 return; 2190 2191 IXGBE_CORE_LOCK(adapter); 2192 index = (vtag >> 5) & 0x7F; 2193 bit = vtag & 0x1F; 2194 adapter->shadow_vfta[index] |= (1 << bit); 2195 ixgbe_setup_vlan_hw_support(adapter); 2196 IXGBE_CORE_UNLOCK(adapter); 2197 } /* ixgbe_register_vlan */ 2198 2199 /************************************************************************ 2200 * ixgbe_unregister_vlan 2201 * 2202 * Run via vlan unconfig EVENT, remove our entry in the soft vfta. 2203 ************************************************************************/ 2204 static void 2205 ixgbe_unregister_vlan(void *arg, struct ifnet *ifp, u16 vtag) 2206 { 2207 struct adapter *adapter = ifp->if_softc; 2208 u16 index, bit; 2209 2210 if (ifp->if_softc != arg) 2211 return; 2212 2213 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2214 return; 2215 2216 IXGBE_CORE_LOCK(adapter); 2217 index = (vtag >> 5) & 0x7F; 2218 bit = vtag & 0x1F; 2219 adapter->shadow_vfta[index] &= ~(1 << bit); 2220 /* Re-init to load the changes */ 2221 ixgbe_setup_vlan_hw_support(adapter); 2222 IXGBE_CORE_UNLOCK(adapter); 2223 } /* ixgbe_unregister_vlan */ 2224 #endif 2225 2226 static void 2227 ixgbe_setup_vlan_hw_support(struct adapter *adapter) 2228 { 2229 struct ethercom *ec = &adapter->osdep.ec; 2230 struct ixgbe_hw *hw = &adapter->hw; 2231 struct rx_ring *rxr; 2232 int i; 2233 u32 ctrl; 2234 2235 2236 /* 2237 * We get here thru init_locked, meaning 2238 * a soft reset, this has already cleared 2239 * the VFTA and other state, so if there 2240 * have been no vlan's registered do nothing. 2241 */ 2242 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 2243 return; 2244 2245 /* Setup the queues for vlans */ 2246 if (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) { 2247 for (i = 0; i < adapter->num_queues; i++) { 2248 rxr = &adapter->rx_rings[i]; 2249 /* On 82599 the VLAN enable is per/queue in RXDCTL */ 2250 if (hw->mac.type != ixgbe_mac_82598EB) { 2251 ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 2252 ctrl |= IXGBE_RXDCTL_VME; 2253 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), ctrl); 2254 } 2255 rxr->vtag_strip = TRUE; 2256 } 2257 } 2258 2259 if ((ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) == 0) 2260 return; 2261 /* 2262 * A soft reset zero's out the VFTA, so 2263 * we need to repopulate it now. 2264 */ 2265 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2266 if (adapter->shadow_vfta[i] != 0) 2267 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), 2268 adapter->shadow_vfta[i]); 2269 2270 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2271 /* Enable the Filter Table if enabled */ 2272 if (ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) { 2273 ctrl &= ~IXGBE_VLNCTRL_CFIEN; 2274 ctrl |= IXGBE_VLNCTRL_VFE; 2275 } 2276 if (hw->mac.type == ixgbe_mac_82598EB) 2277 ctrl |= IXGBE_VLNCTRL_VME; 2278 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2279 } /* ixgbe_setup_vlan_hw_support */ 2280 2281 /************************************************************************ 2282 * ixgbe_get_slot_info 2283 * 2284 * Get the width and transaction speed of 2285 * the slot this adapter is plugged into. 2286 ************************************************************************/ 2287 static void 2288 ixgbe_get_slot_info(struct adapter *adapter) 2289 { 2290 device_t dev = adapter->dev; 2291 struct ixgbe_hw *hw = &adapter->hw; 2292 u32 offset; 2293 // struct ixgbe_mac_info *mac = &hw->mac; 2294 u16 link; 2295 int bus_info_valid = TRUE; 2296 2297 /* Some devices are behind an internal bridge */ 2298 switch (hw->device_id) { 2299 case IXGBE_DEV_ID_82599_SFP_SF_QP: 2300 case IXGBE_DEV_ID_82599_QSFP_SF_QP: 2301 goto get_parent_info; 2302 default: 2303 break; 2304 } 2305 2306 ixgbe_get_bus_info(hw); 2307 2308 /* 2309 * Some devices don't use PCI-E, but there is no need 2310 * to display "Unknown" for bus speed and width. 2311 */ 2312 switch (hw->mac.type) { 2313 case ixgbe_mac_X550EM_x: 2314 case ixgbe_mac_X550EM_a: 2315 return; 2316 default: 2317 goto display; 2318 } 2319 2320 get_parent_info: 2321 /* 2322 * For the Quad port adapter we need to parse back 2323 * up the PCI tree to find the speed of the expansion 2324 * slot into which this adapter is plugged. A bit more work. 2325 */ 2326 dev = device_parent(device_parent(dev)); 2327 #if 0 2328 #ifdef IXGBE_DEBUG 2329 device_printf(dev, "parent pcib = %x,%x,%x\n", pci_get_bus(dev), 2330 pci_get_slot(dev), pci_get_function(dev)); 2331 #endif 2332 dev = device_parent(device_parent(dev)); 2333 #ifdef IXGBE_DEBUG 2334 device_printf(dev, "slot pcib = %x,%x,%x\n", pci_get_bus(dev), 2335 pci_get_slot(dev), pci_get_function(dev)); 2336 #endif 2337 #endif 2338 /* Now get the PCI Express Capabilities offset */ 2339 if (pci_get_capability(adapter->osdep.pc, adapter->osdep.tag, 2340 PCI_CAP_PCIEXPRESS, &offset, NULL)) { 2341 /* 2342 * Hmm...can't get PCI-Express capabilities. 2343 * Falling back to default method. 2344 */ 2345 bus_info_valid = FALSE; 2346 ixgbe_get_bus_info(hw); 2347 goto display; 2348 } 2349 /* ...and read the Link Status Register */ 2350 link = pci_conf_read(adapter->osdep.pc, adapter->osdep.tag, 2351 offset + PCIE_LCSR) >> 16; 2352 ixgbe_set_pci_config_data_generic(hw, link); 2353 2354 display: 2355 device_printf(dev, "PCI Express Bus: Speed %s Width %s\n", 2356 ((hw->bus.speed == ixgbe_bus_speed_8000) ? "8.0GT/s" : 2357 (hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0GT/s" : 2358 (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5GT/s" : 2359 "Unknown"), 2360 ((hw->bus.width == ixgbe_bus_width_pcie_x8) ? "x8" : 2361 (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "x4" : 2362 (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "x1" : 2363 "Unknown")); 2364 2365 if (bus_info_valid) { 2366 if ((hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) && 2367 ((hw->bus.width <= ixgbe_bus_width_pcie_x4) && 2368 (hw->bus.speed == ixgbe_bus_speed_2500))) { 2369 device_printf(dev, "PCI-Express bandwidth available" 2370 " for this card\n is not sufficient for" 2371 " optimal performance.\n"); 2372 device_printf(dev, "For optimal performance a x8 " 2373 "PCIE, or x4 PCIE Gen2 slot is required.\n"); 2374 } 2375 if ((hw->device_id == IXGBE_DEV_ID_82599_SFP_SF_QP) && 2376 ((hw->bus.width <= ixgbe_bus_width_pcie_x8) && 2377 (hw->bus.speed < ixgbe_bus_speed_8000))) { 2378 device_printf(dev, "PCI-Express bandwidth available" 2379 " for this card\n is not sufficient for" 2380 " optimal performance.\n"); 2381 device_printf(dev, "For optimal performance a x8 " 2382 "PCIE Gen3 slot is required.\n"); 2383 } 2384 } else 2385 device_printf(dev, "Unable to determine slot speed/width. The speed/width reported are that of the internal switch.\n"); 2386 2387 return; 2388 } /* ixgbe_get_slot_info */ 2389 2390 /************************************************************************ 2391 * ixgbe_enable_queue - MSI-X Interrupt Handlers and Tasklets 2392 ************************************************************************/ 2393 static inline void 2394 ixgbe_enable_queue(struct adapter *adapter, u32 vector) 2395 { 2396 struct ixgbe_hw *hw = &adapter->hw; 2397 struct ix_queue *que = &adapter->queues[vector]; 2398 u64 queue = (u64)(1ULL << vector); 2399 u32 mask; 2400 2401 mutex_enter(&que->im_mtx); 2402 if (que->im_nest > 0 && --que->im_nest > 0) 2403 goto out; 2404 2405 if (hw->mac.type == ixgbe_mac_82598EB) { 2406 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2407 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 2408 } else { 2409 mask = (queue & 0xFFFFFFFF); 2410 if (mask) 2411 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask); 2412 mask = (queue >> 32); 2413 if (mask) 2414 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask); 2415 } 2416 out: 2417 mutex_exit(&que->im_mtx); 2418 } /* ixgbe_enable_queue */ 2419 2420 /************************************************************************ 2421 * ixgbe_disable_queue 2422 ************************************************************************/ 2423 static inline void 2424 ixgbe_disable_queue(struct adapter *adapter, u32 vector) 2425 { 2426 struct ixgbe_hw *hw = &adapter->hw; 2427 struct ix_queue *que = &adapter->queues[vector]; 2428 u64 queue = (u64)(1ULL << vector); 2429 u32 mask; 2430 2431 mutex_enter(&que->im_mtx); 2432 if (que->im_nest++ > 0) 2433 goto out; 2434 2435 if (hw->mac.type == ixgbe_mac_82598EB) { 2436 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2437 IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask); 2438 } else { 2439 mask = (queue & 0xFFFFFFFF); 2440 if (mask) 2441 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask); 2442 mask = (queue >> 32); 2443 if (mask) 2444 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask); 2445 } 2446 out: 2447 mutex_exit(&que->im_mtx); 2448 } /* ixgbe_disable_queue */ 2449 2450 /************************************************************************ 2451 * ixgbe_sched_handle_que - schedule deferred packet processing 2452 ************************************************************************/ 2453 static inline void 2454 ixgbe_sched_handle_que(struct adapter *adapter, struct ix_queue *que) 2455 { 2456 2457 if (adapter->txrx_use_workqueue) { 2458 /* 2459 * adapter->que_wq is bound to each CPU instead of 2460 * each NIC queue to reduce workqueue kthread. As we 2461 * should consider about interrupt affinity in this 2462 * function, the workqueue kthread must be WQ_PERCPU. 2463 * If create WQ_PERCPU workqueue kthread for each NIC 2464 * queue, that number of created workqueue kthread is 2465 * (number of used NIC queue) * (number of CPUs) = 2466 * (number of CPUs) ^ 2 most often. 2467 * 2468 * The same NIC queue's interrupts are avoided by 2469 * masking the queue's interrupt. And different 2470 * NIC queue's interrupts use different struct work 2471 * (que->wq_cookie). So, "enqueued flag" to avoid 2472 * twice workqueue_enqueue() is not required . 2473 */ 2474 workqueue_enqueue(adapter->que_wq, &que->wq_cookie, curcpu()); 2475 } else { 2476 softint_schedule(que->que_si); 2477 } 2478 } 2479 2480 /************************************************************************ 2481 * ixgbe_msix_que - MSI-X Queue Interrupt Service routine 2482 ************************************************************************/ 2483 static int 2484 ixgbe_msix_que(void *arg) 2485 { 2486 struct ix_queue *que = arg; 2487 struct adapter *adapter = que->adapter; 2488 struct ifnet *ifp = adapter->ifp; 2489 struct tx_ring *txr = que->txr; 2490 struct rx_ring *rxr = que->rxr; 2491 bool more; 2492 u32 newitr = 0; 2493 2494 /* Protect against spurious interrupts */ 2495 if ((ifp->if_flags & IFF_RUNNING) == 0) 2496 return 0; 2497 2498 ixgbe_disable_queue(adapter, que->msix); 2499 ++que->irqs.ev_count; 2500 2501 #ifdef __NetBSD__ 2502 /* Don't run ixgbe_rxeof in interrupt context */ 2503 more = true; 2504 #else 2505 more = ixgbe_rxeof(que); 2506 #endif 2507 2508 IXGBE_TX_LOCK(txr); 2509 ixgbe_txeof(txr); 2510 IXGBE_TX_UNLOCK(txr); 2511 2512 /* Do AIM now? */ 2513 2514 if (adapter->enable_aim == false) 2515 goto no_calc; 2516 /* 2517 * Do Adaptive Interrupt Moderation: 2518 * - Write out last calculated setting 2519 * - Calculate based on average size over 2520 * the last interval. 2521 */ 2522 if (que->eitr_setting) 2523 ixgbe_eitr_write(que, que->eitr_setting); 2524 2525 que->eitr_setting = 0; 2526 2527 /* Idle, do nothing */ 2528 if ((txr->bytes == 0) && (rxr->bytes == 0)) 2529 goto no_calc; 2530 2531 if ((txr->bytes) && (txr->packets)) 2532 newitr = txr->bytes/txr->packets; 2533 if ((rxr->bytes) && (rxr->packets)) 2534 newitr = max(newitr, (rxr->bytes / rxr->packets)); 2535 newitr += 24; /* account for hardware frame, crc */ 2536 2537 /* set an upper boundary */ 2538 newitr = min(newitr, 3000); 2539 2540 /* Be nice to the mid range */ 2541 if ((newitr > 300) && (newitr < 1200)) 2542 newitr = (newitr / 3); 2543 else 2544 newitr = (newitr / 2); 2545 2546 /* 2547 * When RSC is used, ITR interval must be larger than RSC_DELAY. 2548 * Currently, we use 2us for RSC_DELAY. The minimum value is always 2549 * greater than 2us on 100M (and 10M?(not documented)), but it's not 2550 * on 1G and higher. 2551 */ 2552 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2553 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2554 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 2555 newitr = IXGBE_MIN_RSC_EITR_10G1G; 2556 } 2557 2558 /* save for next interrupt */ 2559 que->eitr_setting = newitr; 2560 2561 /* Reset state */ 2562 txr->bytes = 0; 2563 txr->packets = 0; 2564 rxr->bytes = 0; 2565 rxr->packets = 0; 2566 2567 no_calc: 2568 if (more) 2569 ixgbe_sched_handle_que(adapter, que); 2570 else 2571 ixgbe_enable_queue(adapter, que->msix); 2572 2573 return 1; 2574 } /* ixgbe_msix_que */ 2575 2576 /************************************************************************ 2577 * ixgbe_media_status - Media Ioctl callback 2578 * 2579 * Called whenever the user queries the status of 2580 * the interface using ifconfig. 2581 ************************************************************************/ 2582 static void 2583 ixgbe_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 2584 { 2585 struct adapter *adapter = ifp->if_softc; 2586 struct ixgbe_hw *hw = &adapter->hw; 2587 int layer; 2588 2589 INIT_DEBUGOUT("ixgbe_media_status: begin"); 2590 IXGBE_CORE_LOCK(adapter); 2591 ixgbe_update_link_status(adapter); 2592 2593 ifmr->ifm_status = IFM_AVALID; 2594 ifmr->ifm_active = IFM_ETHER; 2595 2596 if (!adapter->link_active) { 2597 ifmr->ifm_active |= IFM_NONE; 2598 IXGBE_CORE_UNLOCK(adapter); 2599 return; 2600 } 2601 2602 ifmr->ifm_status |= IFM_ACTIVE; 2603 layer = adapter->phy_layer; 2604 2605 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T || 2606 layer & IXGBE_PHYSICAL_LAYER_5GBASE_T || 2607 layer & IXGBE_PHYSICAL_LAYER_2500BASE_T || 2608 layer & IXGBE_PHYSICAL_LAYER_1000BASE_T || 2609 layer & IXGBE_PHYSICAL_LAYER_100BASE_TX || 2610 layer & IXGBE_PHYSICAL_LAYER_10BASE_T) 2611 switch (adapter->link_speed) { 2612 case IXGBE_LINK_SPEED_10GB_FULL: 2613 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 2614 break; 2615 case IXGBE_LINK_SPEED_5GB_FULL: 2616 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 2617 break; 2618 case IXGBE_LINK_SPEED_2_5GB_FULL: 2619 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 2620 break; 2621 case IXGBE_LINK_SPEED_1GB_FULL: 2622 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 2623 break; 2624 case IXGBE_LINK_SPEED_100_FULL: 2625 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 2626 break; 2627 case IXGBE_LINK_SPEED_10_FULL: 2628 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 2629 break; 2630 } 2631 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 2632 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 2633 switch (adapter->link_speed) { 2634 case IXGBE_LINK_SPEED_10GB_FULL: 2635 ifmr->ifm_active |= IFM_10G_TWINAX | IFM_FDX; 2636 break; 2637 } 2638 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) 2639 switch (adapter->link_speed) { 2640 case IXGBE_LINK_SPEED_10GB_FULL: 2641 ifmr->ifm_active |= IFM_10G_LR | IFM_FDX; 2642 break; 2643 case IXGBE_LINK_SPEED_1GB_FULL: 2644 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2645 break; 2646 } 2647 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LRM) 2648 switch (adapter->link_speed) { 2649 case IXGBE_LINK_SPEED_10GB_FULL: 2650 ifmr->ifm_active |= IFM_10G_LRM | IFM_FDX; 2651 break; 2652 case IXGBE_LINK_SPEED_1GB_FULL: 2653 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2654 break; 2655 } 2656 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR || 2657 layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 2658 switch (adapter->link_speed) { 2659 case IXGBE_LINK_SPEED_10GB_FULL: 2660 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2661 break; 2662 case IXGBE_LINK_SPEED_1GB_FULL: 2663 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 2664 break; 2665 } 2666 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 2667 switch (adapter->link_speed) { 2668 case IXGBE_LINK_SPEED_10GB_FULL: 2669 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2670 break; 2671 } 2672 /* 2673 * XXX: These need to use the proper media types once 2674 * they're added. 2675 */ 2676 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 2677 switch (adapter->link_speed) { 2678 case IXGBE_LINK_SPEED_10GB_FULL: 2679 #ifndef IFM_ETH_XTYPE 2680 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2681 #else 2682 ifmr->ifm_active |= IFM_10G_KR | IFM_FDX; 2683 #endif 2684 break; 2685 case IXGBE_LINK_SPEED_2_5GB_FULL: 2686 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2687 break; 2688 case IXGBE_LINK_SPEED_1GB_FULL: 2689 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2690 break; 2691 } 2692 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 || 2693 layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX || 2694 layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 2695 switch (adapter->link_speed) { 2696 case IXGBE_LINK_SPEED_10GB_FULL: 2697 #ifndef IFM_ETH_XTYPE 2698 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2699 #else 2700 ifmr->ifm_active |= IFM_10G_KX4 | IFM_FDX; 2701 #endif 2702 break; 2703 case IXGBE_LINK_SPEED_2_5GB_FULL: 2704 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2705 break; 2706 case IXGBE_LINK_SPEED_1GB_FULL: 2707 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2708 break; 2709 } 2710 2711 /* If nothing is recognized... */ 2712 #if 0 2713 if (IFM_SUBTYPE(ifmr->ifm_active) == 0) 2714 ifmr->ifm_active |= IFM_UNKNOWN; 2715 #endif 2716 2717 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 2718 2719 /* Display current flow control setting used on link */ 2720 if (hw->fc.current_mode == ixgbe_fc_rx_pause || 2721 hw->fc.current_mode == ixgbe_fc_full) 2722 ifmr->ifm_active |= IFM_ETH_RXPAUSE; 2723 if (hw->fc.current_mode == ixgbe_fc_tx_pause || 2724 hw->fc.current_mode == ixgbe_fc_full) 2725 ifmr->ifm_active |= IFM_ETH_TXPAUSE; 2726 2727 IXGBE_CORE_UNLOCK(adapter); 2728 2729 return; 2730 } /* ixgbe_media_status */ 2731 2732 /************************************************************************ 2733 * ixgbe_media_change - Media Ioctl callback 2734 * 2735 * Called when the user changes speed/duplex using 2736 * media/mediopt option with ifconfig. 2737 ************************************************************************/ 2738 static int 2739 ixgbe_media_change(struct ifnet *ifp) 2740 { 2741 struct adapter *adapter = ifp->if_softc; 2742 struct ifmedia *ifm = &adapter->media; 2743 struct ixgbe_hw *hw = &adapter->hw; 2744 ixgbe_link_speed speed = 0; 2745 ixgbe_link_speed link_caps = 0; 2746 bool negotiate = false; 2747 s32 err = IXGBE_NOT_IMPLEMENTED; 2748 2749 INIT_DEBUGOUT("ixgbe_media_change: begin"); 2750 2751 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 2752 return (EINVAL); 2753 2754 if (hw->phy.media_type == ixgbe_media_type_backplane) 2755 return (ENODEV); 2756 2757 /* 2758 * We don't actually need to check against the supported 2759 * media types of the adapter; ifmedia will take care of 2760 * that for us. 2761 */ 2762 switch (IFM_SUBTYPE(ifm->ifm_media)) { 2763 case IFM_AUTO: 2764 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 2765 &negotiate); 2766 if (err != IXGBE_SUCCESS) { 2767 device_printf(adapter->dev, "Unable to determine " 2768 "supported advertise speeds\n"); 2769 return (ENODEV); 2770 } 2771 speed |= link_caps; 2772 break; 2773 case IFM_10G_T: 2774 case IFM_10G_LRM: 2775 case IFM_10G_LR: 2776 case IFM_10G_TWINAX: 2777 #ifndef IFM_ETH_XTYPE 2778 case IFM_10G_SR: /* KR, too */ 2779 case IFM_10G_CX4: /* KX4 */ 2780 #else 2781 case IFM_10G_KR: 2782 case IFM_10G_KX4: 2783 #endif 2784 speed |= IXGBE_LINK_SPEED_10GB_FULL; 2785 break; 2786 case IFM_5000_T: 2787 speed |= IXGBE_LINK_SPEED_5GB_FULL; 2788 break; 2789 case IFM_2500_T: 2790 case IFM_2500_KX: 2791 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 2792 break; 2793 case IFM_1000_T: 2794 case IFM_1000_LX: 2795 case IFM_1000_SX: 2796 case IFM_1000_KX: 2797 speed |= IXGBE_LINK_SPEED_1GB_FULL; 2798 break; 2799 case IFM_100_TX: 2800 speed |= IXGBE_LINK_SPEED_100_FULL; 2801 break; 2802 case IFM_10_T: 2803 speed |= IXGBE_LINK_SPEED_10_FULL; 2804 break; 2805 default: 2806 goto invalid; 2807 } 2808 2809 hw->mac.autotry_restart = TRUE; 2810 hw->mac.ops.setup_link(hw, speed, TRUE); 2811 adapter->advertise = 0; 2812 if (IFM_SUBTYPE(ifm->ifm_media) != IFM_AUTO) { 2813 if ((speed & IXGBE_LINK_SPEED_10GB_FULL) != 0) 2814 adapter->advertise |= 1 << 2; 2815 if ((speed & IXGBE_LINK_SPEED_1GB_FULL) != 0) 2816 adapter->advertise |= 1 << 1; 2817 if ((speed & IXGBE_LINK_SPEED_100_FULL) != 0) 2818 adapter->advertise |= 1 << 0; 2819 if ((speed & IXGBE_LINK_SPEED_10_FULL) != 0) 2820 adapter->advertise |= 1 << 3; 2821 if ((speed & IXGBE_LINK_SPEED_2_5GB_FULL) != 0) 2822 adapter->advertise |= 1 << 4; 2823 if ((speed & IXGBE_LINK_SPEED_5GB_FULL) != 0) 2824 adapter->advertise |= 1 << 5; 2825 } 2826 2827 return (0); 2828 2829 invalid: 2830 device_printf(adapter->dev, "Invalid media type!\n"); 2831 2832 return (EINVAL); 2833 } /* ixgbe_media_change */ 2834 2835 /************************************************************************ 2836 * ixgbe_set_promisc 2837 ************************************************************************/ 2838 static void 2839 ixgbe_set_promisc(struct adapter *adapter) 2840 { 2841 struct ifnet *ifp = adapter->ifp; 2842 int mcnt = 0; 2843 u32 rctl; 2844 struct ether_multi *enm; 2845 struct ether_multistep step; 2846 struct ethercom *ec = &adapter->osdep.ec; 2847 2848 KASSERT(mutex_owned(&adapter->core_mtx)); 2849 rctl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 2850 rctl &= (~IXGBE_FCTRL_UPE); 2851 if (ifp->if_flags & IFF_ALLMULTI) 2852 mcnt = MAX_NUM_MULTICAST_ADDRESSES; 2853 else { 2854 ETHER_LOCK(ec); 2855 ETHER_FIRST_MULTI(step, ec, enm); 2856 while (enm != NULL) { 2857 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) 2858 break; 2859 mcnt++; 2860 ETHER_NEXT_MULTI(step, enm); 2861 } 2862 ETHER_UNLOCK(ec); 2863 } 2864 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) 2865 rctl &= (~IXGBE_FCTRL_MPE); 2866 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, rctl); 2867 2868 if (ifp->if_flags & IFF_PROMISC) { 2869 rctl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 2870 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, rctl); 2871 } else if (ifp->if_flags & IFF_ALLMULTI) { 2872 rctl |= IXGBE_FCTRL_MPE; 2873 rctl &= ~IXGBE_FCTRL_UPE; 2874 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, rctl); 2875 } 2876 } /* ixgbe_set_promisc */ 2877 2878 /************************************************************************ 2879 * ixgbe_msix_link - Link status change ISR (MSI/MSI-X) 2880 ************************************************************************/ 2881 static int 2882 ixgbe_msix_link(void *arg) 2883 { 2884 struct adapter *adapter = arg; 2885 struct ixgbe_hw *hw = &adapter->hw; 2886 u32 eicr, eicr_mask; 2887 s32 retval; 2888 2889 ++adapter->link_irq.ev_count; 2890 2891 /* Pause other interrupts */ 2892 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_OTHER); 2893 2894 /* First get the cause */ 2895 /* 2896 * The specifications of 82598, 82599, X540 and X550 say EICS register 2897 * is write only. However, Linux says it is a workaround for silicon 2898 * errata to read EICS instead of EICR to get interrupt cause. It seems 2899 * there is a problem about read clear mechanism for EICR register. 2900 */ 2901 eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 2902 /* Be sure the queue bits are not cleared */ 2903 eicr &= ~IXGBE_EICR_RTX_QUEUE; 2904 /* Clear interrupt with write */ 2905 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr); 2906 2907 /* Link status change */ 2908 if (eicr & IXGBE_EICR_LSC) { 2909 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC); 2910 softint_schedule(adapter->link_si); 2911 } 2912 2913 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 2914 if ((adapter->feat_en & IXGBE_FEATURE_FDIR) && 2915 (eicr & IXGBE_EICR_FLOW_DIR)) { 2916 /* This is probably overkill :) */ 2917 if (!atomic_cas_uint(&adapter->fdir_reinit, 0, 1)) 2918 return 1; 2919 /* Disable the interrupt */ 2920 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_FLOW_DIR); 2921 softint_schedule(adapter->fdir_si); 2922 } 2923 2924 if (eicr & IXGBE_EICR_ECC) { 2925 device_printf(adapter->dev, 2926 "CRITICAL: ECC ERROR!! Please Reboot!!\n"); 2927 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_ECC); 2928 } 2929 2930 /* Check for over temp condition */ 2931 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) { 2932 switch (adapter->hw.mac.type) { 2933 case ixgbe_mac_X550EM_a: 2934 if (!(eicr & IXGBE_EICR_GPI_SDP0_X550EM_a)) 2935 break; 2936 IXGBE_WRITE_REG(hw, IXGBE_EIMC, 2937 IXGBE_EICR_GPI_SDP0_X550EM_a); 2938 IXGBE_WRITE_REG(hw, IXGBE_EICR, 2939 IXGBE_EICR_GPI_SDP0_X550EM_a); 2940 retval = hw->phy.ops.check_overtemp(hw); 2941 if (retval != IXGBE_ERR_OVERTEMP) 2942 break; 2943 device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n"); 2944 device_printf(adapter->dev, "System shutdown required!\n"); 2945 break; 2946 default: 2947 if (!(eicr & IXGBE_EICR_TS)) 2948 break; 2949 retval = hw->phy.ops.check_overtemp(hw); 2950 if (retval != IXGBE_ERR_OVERTEMP) 2951 break; 2952 device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n"); 2953 device_printf(adapter->dev, "System shutdown required!\n"); 2954 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_TS); 2955 break; 2956 } 2957 } 2958 2959 /* Check for VF message */ 2960 if ((adapter->feat_en & IXGBE_FEATURE_SRIOV) && 2961 (eicr & IXGBE_EICR_MAILBOX)) 2962 softint_schedule(adapter->mbx_si); 2963 } 2964 2965 if (ixgbe_is_sfp(hw)) { 2966 /* Pluggable optics-related interrupt */ 2967 if (hw->mac.type >= ixgbe_mac_X540) 2968 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 2969 else 2970 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 2971 2972 if (eicr & eicr_mask) { 2973 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 2974 softint_schedule(adapter->mod_si); 2975 } 2976 2977 if ((hw->mac.type == ixgbe_mac_82599EB) && 2978 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 2979 IXGBE_WRITE_REG(hw, IXGBE_EICR, 2980 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 2981 softint_schedule(adapter->msf_si); 2982 } 2983 } 2984 2985 /* Check for fan failure */ 2986 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 2987 ixgbe_check_fan_failure(adapter, eicr, TRUE); 2988 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 2989 } 2990 2991 /* External PHY interrupt */ 2992 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 2993 (eicr & IXGBE_EICR_GPI_SDP0_X540)) { 2994 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP0_X540); 2995 softint_schedule(adapter->phy_si); 2996 } 2997 2998 /* Re-enable other interrupts */ 2999 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_OTHER); 3000 return 1; 3001 } /* ixgbe_msix_link */ 3002 3003 static void 3004 ixgbe_eitr_write(struct ix_queue *que, uint32_t itr) 3005 { 3006 struct adapter *adapter = que->adapter; 3007 3008 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 3009 itr |= itr << 16; 3010 else 3011 itr |= IXGBE_EITR_CNT_WDIS; 3012 3013 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(que->msix), 3014 itr); 3015 } 3016 3017 3018 /************************************************************************ 3019 * ixgbe_sysctl_interrupt_rate_handler 3020 ************************************************************************/ 3021 static int 3022 ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 3023 { 3024 struct sysctlnode node = *rnode; 3025 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 3026 struct adapter *adapter = que->adapter; 3027 uint32_t reg, usec, rate; 3028 int error; 3029 3030 if (que == NULL) 3031 return 0; 3032 reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_EITR(que->msix)); 3033 usec = ((reg & 0x0FF8) >> 3); 3034 if (usec > 0) 3035 rate = 500000 / usec; 3036 else 3037 rate = 0; 3038 node.sysctl_data = &rate; 3039 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 3040 if (error || newp == NULL) 3041 return error; 3042 reg &= ~0xfff; /* default, no limitation */ 3043 if (rate > 0 && rate < 500000) { 3044 if (rate < 1000) 3045 rate = 1000; 3046 reg |= ((4000000/rate) & 0xff8); 3047 /* 3048 * When RSC is used, ITR interval must be larger than 3049 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 3050 * The minimum value is always greater than 2us on 100M 3051 * (and 10M?(not documented)), but it's not on 1G and higher. 3052 */ 3053 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 3054 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 3055 if ((adapter->num_queues > 1) 3056 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 3057 return EINVAL; 3058 } 3059 ixgbe_max_interrupt_rate = rate; 3060 } else 3061 ixgbe_max_interrupt_rate = 0; 3062 ixgbe_eitr_write(que, reg); 3063 3064 return (0); 3065 } /* ixgbe_sysctl_interrupt_rate_handler */ 3066 3067 const struct sysctlnode * 3068 ixgbe_sysctl_instance(struct adapter *adapter) 3069 { 3070 const char *dvname; 3071 struct sysctllog **log; 3072 int rc; 3073 const struct sysctlnode *rnode; 3074 3075 if (adapter->sysctltop != NULL) 3076 return adapter->sysctltop; 3077 3078 log = &adapter->sysctllog; 3079 dvname = device_xname(adapter->dev); 3080 3081 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 3082 0, CTLTYPE_NODE, dvname, 3083 SYSCTL_DESCR("ixgbe information and settings"), 3084 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 3085 goto err; 3086 3087 return rnode; 3088 err: 3089 printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc); 3090 return NULL; 3091 } 3092 3093 /************************************************************************ 3094 * ixgbe_add_device_sysctls 3095 ************************************************************************/ 3096 static void 3097 ixgbe_add_device_sysctls(struct adapter *adapter) 3098 { 3099 device_t dev = adapter->dev; 3100 struct ixgbe_hw *hw = &adapter->hw; 3101 struct sysctllog **log; 3102 const struct sysctlnode *rnode, *cnode; 3103 3104 log = &adapter->sysctllog; 3105 3106 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 3107 aprint_error_dev(dev, "could not create sysctl root\n"); 3108 return; 3109 } 3110 3111 if (sysctl_createv(log, 0, &rnode, &cnode, 3112 CTLFLAG_READONLY, CTLTYPE_INT, 3113 "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"), 3114 NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0) 3115 aprint_error_dev(dev, "could not create sysctl\n"); 3116 3117 if (sysctl_createv(log, 0, &rnode, &cnode, 3118 CTLFLAG_READONLY, CTLTYPE_INT, 3119 "num_queues", SYSCTL_DESCR("Number of queues"), 3120 NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0) 3121 aprint_error_dev(dev, "could not create sysctl\n"); 3122 3123 /* Sysctls for all devices */ 3124 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3125 CTLTYPE_INT, "fc", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_SET_FC), 3126 ixgbe_sysctl_flowcntl, 0, (void *)adapter, 0, CTL_CREATE, 3127 CTL_EOL) != 0) 3128 aprint_error_dev(dev, "could not create sysctl\n"); 3129 3130 adapter->enable_aim = ixgbe_enable_aim; 3131 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3132 CTLTYPE_BOOL, "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 3133 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 3134 aprint_error_dev(dev, "could not create sysctl\n"); 3135 3136 if (sysctl_createv(log, 0, &rnode, &cnode, 3137 CTLFLAG_READWRITE, CTLTYPE_INT, 3138 "advertise_speed", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_ADV_SPEED), 3139 ixgbe_sysctl_advertise, 0, (void *)adapter, 0, CTL_CREATE, 3140 CTL_EOL) != 0) 3141 aprint_error_dev(dev, "could not create sysctl\n"); 3142 3143 adapter->txrx_use_workqueue = ixgbe_txrx_workqueue; 3144 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3145 CTLTYPE_BOOL, "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"), 3146 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0) 3147 aprint_error_dev(dev, "could not create sysctl\n"); 3148 3149 #ifdef IXGBE_DEBUG 3150 /* testing sysctls (for all devices) */ 3151 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3152 CTLTYPE_INT, "power_state", SYSCTL_DESCR("PCI Power State"), 3153 ixgbe_sysctl_power_state, 0, (void *)adapter, 0, CTL_CREATE, 3154 CTL_EOL) != 0) 3155 aprint_error_dev(dev, "could not create sysctl\n"); 3156 3157 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READONLY, 3158 CTLTYPE_STRING, "print_rss_config", 3159 SYSCTL_DESCR("Prints RSS Configuration"), 3160 ixgbe_sysctl_print_rss_config, 0, (void *)adapter, 0, CTL_CREATE, 3161 CTL_EOL) != 0) 3162 aprint_error_dev(dev, "could not create sysctl\n"); 3163 #endif 3164 /* for X550 series devices */ 3165 if (hw->mac.type >= ixgbe_mac_X550) 3166 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3167 CTLTYPE_INT, "dmac", SYSCTL_DESCR("DMA Coalesce"), 3168 ixgbe_sysctl_dmac, 0, (void *)adapter, 0, CTL_CREATE, 3169 CTL_EOL) != 0) 3170 aprint_error_dev(dev, "could not create sysctl\n"); 3171 3172 /* for WoL-capable devices */ 3173 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 3174 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3175 CTLTYPE_BOOL, "wol_enable", 3176 SYSCTL_DESCR("Enable/Disable Wake on LAN"), 3177 ixgbe_sysctl_wol_enable, 0, (void *)adapter, 0, CTL_CREATE, 3178 CTL_EOL) != 0) 3179 aprint_error_dev(dev, "could not create sysctl\n"); 3180 3181 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3182 CTLTYPE_INT, "wufc", 3183 SYSCTL_DESCR("Enable/Disable Wake Up Filters"), 3184 ixgbe_sysctl_wufc, 0, (void *)adapter, 0, CTL_CREATE, 3185 CTL_EOL) != 0) 3186 aprint_error_dev(dev, "could not create sysctl\n"); 3187 } 3188 3189 /* for X552/X557-AT devices */ 3190 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 3191 const struct sysctlnode *phy_node; 3192 3193 if (sysctl_createv(log, 0, &rnode, &phy_node, 0, CTLTYPE_NODE, 3194 "phy", SYSCTL_DESCR("External PHY sysctls"), 3195 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) { 3196 aprint_error_dev(dev, "could not create sysctl\n"); 3197 return; 3198 } 3199 3200 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3201 CTLTYPE_INT, "temp", 3202 SYSCTL_DESCR("Current External PHY Temperature (Celsius)"), 3203 ixgbe_sysctl_phy_temp, 0, (void *)adapter, 0, CTL_CREATE, 3204 CTL_EOL) != 0) 3205 aprint_error_dev(dev, "could not create sysctl\n"); 3206 3207 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3208 CTLTYPE_INT, "overtemp_occurred", 3209 SYSCTL_DESCR("External PHY High Temperature Event Occurred"), 3210 ixgbe_sysctl_phy_overtemp_occurred, 0, (void *)adapter, 0, 3211 CTL_CREATE, CTL_EOL) != 0) 3212 aprint_error_dev(dev, "could not create sysctl\n"); 3213 } 3214 3215 if (adapter->feat_cap & IXGBE_FEATURE_EEE) { 3216 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3217 CTLTYPE_INT, "eee_state", 3218 SYSCTL_DESCR("EEE Power Save State"), 3219 ixgbe_sysctl_eee_state, 0, (void *)adapter, 0, CTL_CREATE, 3220 CTL_EOL) != 0) 3221 aprint_error_dev(dev, "could not create sysctl\n"); 3222 } 3223 } /* ixgbe_add_device_sysctls */ 3224 3225 /************************************************************************ 3226 * ixgbe_allocate_pci_resources 3227 ************************************************************************/ 3228 static int 3229 ixgbe_allocate_pci_resources(struct adapter *adapter, 3230 const struct pci_attach_args *pa) 3231 { 3232 pcireg_t memtype; 3233 device_t dev = adapter->dev; 3234 bus_addr_t addr; 3235 int flags; 3236 3237 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 3238 switch (memtype) { 3239 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 3240 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 3241 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 3242 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 3243 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 3244 goto map_err; 3245 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 3246 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 3247 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 3248 } 3249 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 3250 adapter->osdep.mem_size, flags, 3251 &adapter->osdep.mem_bus_space_handle) != 0) { 3252 map_err: 3253 adapter->osdep.mem_size = 0; 3254 aprint_error_dev(dev, "unable to map BAR0\n"); 3255 return ENXIO; 3256 } 3257 break; 3258 default: 3259 aprint_error_dev(dev, "unexpected type on BAR0\n"); 3260 return ENXIO; 3261 } 3262 3263 return (0); 3264 } /* ixgbe_allocate_pci_resources */ 3265 3266 static void 3267 ixgbe_free_softint(struct adapter *adapter) 3268 { 3269 struct ix_queue *que = adapter->queues; 3270 struct tx_ring *txr = adapter->tx_rings; 3271 int i; 3272 3273 for (i = 0; i < adapter->num_queues; i++, que++, txr++) { 3274 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 3275 if (txr->txr_si != NULL) 3276 softint_disestablish(txr->txr_si); 3277 } 3278 if (que->que_si != NULL) 3279 softint_disestablish(que->que_si); 3280 } 3281 if (adapter->txr_wq != NULL) 3282 workqueue_destroy(adapter->txr_wq); 3283 if (adapter->txr_wq_enqueued != NULL) 3284 percpu_free(adapter->txr_wq_enqueued, sizeof(u_int)); 3285 if (adapter->que_wq != NULL) 3286 workqueue_destroy(adapter->que_wq); 3287 3288 /* Drain the Link queue */ 3289 if (adapter->link_si != NULL) { 3290 softint_disestablish(adapter->link_si); 3291 adapter->link_si = NULL; 3292 } 3293 if (adapter->mod_si != NULL) { 3294 softint_disestablish(adapter->mod_si); 3295 adapter->mod_si = NULL; 3296 } 3297 if (adapter->msf_si != NULL) { 3298 softint_disestablish(adapter->msf_si); 3299 adapter->msf_si = NULL; 3300 } 3301 if (adapter->phy_si != NULL) { 3302 softint_disestablish(adapter->phy_si); 3303 adapter->phy_si = NULL; 3304 } 3305 if (adapter->feat_en & IXGBE_FEATURE_FDIR) { 3306 if (adapter->fdir_si != NULL) { 3307 softint_disestablish(adapter->fdir_si); 3308 adapter->fdir_si = NULL; 3309 } 3310 } 3311 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 3312 if (adapter->mbx_si != NULL) { 3313 softint_disestablish(adapter->mbx_si); 3314 adapter->mbx_si = NULL; 3315 } 3316 } 3317 } /* ixgbe_free_softint */ 3318 3319 /************************************************************************ 3320 * ixgbe_detach - Device removal routine 3321 * 3322 * Called when the driver is being removed. 3323 * Stops the adapter and deallocates all the resources 3324 * that were allocated for driver operation. 3325 * 3326 * return 0 on success, positive on failure 3327 ************************************************************************/ 3328 static int 3329 ixgbe_detach(device_t dev, int flags) 3330 { 3331 struct adapter *adapter = device_private(dev); 3332 struct rx_ring *rxr = adapter->rx_rings; 3333 struct tx_ring *txr = adapter->tx_rings; 3334 struct ixgbe_hw *hw = &adapter->hw; 3335 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 3336 u32 ctrl_ext; 3337 3338 INIT_DEBUGOUT("ixgbe_detach: begin"); 3339 if (adapter->osdep.attached == false) 3340 return 0; 3341 3342 if (ixgbe_pci_iov_detach(dev) != 0) { 3343 device_printf(dev, "SR-IOV in use; detach first.\n"); 3344 return (EBUSY); 3345 } 3346 3347 /* Stop the interface. Callouts are stopped in it. */ 3348 ixgbe_ifstop(adapter->ifp, 1); 3349 #if NVLAN > 0 3350 /* Make sure VLANs are not using driver */ 3351 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 3352 ; /* nothing to do: no VLANs */ 3353 else if ((flags & (DETACH_SHUTDOWN|DETACH_FORCE)) != 0) 3354 vlan_ifdetach(adapter->ifp); 3355 else { 3356 aprint_error_dev(dev, "VLANs in use, detach first\n"); 3357 return (EBUSY); 3358 } 3359 #endif 3360 3361 pmf_device_deregister(dev); 3362 3363 ether_ifdetach(adapter->ifp); 3364 /* Stop the adapter */ 3365 IXGBE_CORE_LOCK(adapter); 3366 ixgbe_setup_low_power_mode(adapter); 3367 IXGBE_CORE_UNLOCK(adapter); 3368 3369 ixgbe_free_softint(adapter); 3370 3371 /* let hardware know driver is unloading */ 3372 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 3373 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 3374 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 3375 3376 callout_halt(&adapter->timer, NULL); 3377 3378 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 3379 netmap_detach(adapter->ifp); 3380 3381 ixgbe_free_pci_resources(adapter); 3382 #if 0 /* XXX the NetBSD port is probably missing something here */ 3383 bus_generic_detach(dev); 3384 #endif 3385 if_detach(adapter->ifp); 3386 if_percpuq_destroy(adapter->ipq); 3387 3388 sysctl_teardown(&adapter->sysctllog); 3389 evcnt_detach(&adapter->efbig_tx_dma_setup); 3390 evcnt_detach(&adapter->mbuf_defrag_failed); 3391 evcnt_detach(&adapter->efbig2_tx_dma_setup); 3392 evcnt_detach(&adapter->einval_tx_dma_setup); 3393 evcnt_detach(&adapter->other_tx_dma_setup); 3394 evcnt_detach(&adapter->eagain_tx_dma_setup); 3395 evcnt_detach(&adapter->enomem_tx_dma_setup); 3396 evcnt_detach(&adapter->watchdog_events); 3397 evcnt_detach(&adapter->tso_err); 3398 evcnt_detach(&adapter->link_irq); 3399 3400 txr = adapter->tx_rings; 3401 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 3402 evcnt_detach(&adapter->queues[i].irqs); 3403 evcnt_detach(&adapter->queues[i].handleq); 3404 evcnt_detach(&adapter->queues[i].req); 3405 evcnt_detach(&txr->no_desc_avail); 3406 evcnt_detach(&txr->total_packets); 3407 evcnt_detach(&txr->tso_tx); 3408 #ifndef IXGBE_LEGACY_TX 3409 evcnt_detach(&txr->pcq_drops); 3410 #endif 3411 3412 if (i < __arraycount(stats->mpc)) { 3413 evcnt_detach(&stats->mpc[i]); 3414 if (hw->mac.type == ixgbe_mac_82598EB) 3415 evcnt_detach(&stats->rnbc[i]); 3416 } 3417 if (i < __arraycount(stats->pxontxc)) { 3418 evcnt_detach(&stats->pxontxc[i]); 3419 evcnt_detach(&stats->pxonrxc[i]); 3420 evcnt_detach(&stats->pxofftxc[i]); 3421 evcnt_detach(&stats->pxoffrxc[i]); 3422 evcnt_detach(&stats->pxon2offc[i]); 3423 } 3424 if (i < __arraycount(stats->qprc)) { 3425 evcnt_detach(&stats->qprc[i]); 3426 evcnt_detach(&stats->qptc[i]); 3427 evcnt_detach(&stats->qbrc[i]); 3428 evcnt_detach(&stats->qbtc[i]); 3429 evcnt_detach(&stats->qprdc[i]); 3430 } 3431 3432 evcnt_detach(&rxr->rx_packets); 3433 evcnt_detach(&rxr->rx_bytes); 3434 evcnt_detach(&rxr->rx_copies); 3435 evcnt_detach(&rxr->no_jmbuf); 3436 evcnt_detach(&rxr->rx_discarded); 3437 } 3438 evcnt_detach(&stats->ipcs); 3439 evcnt_detach(&stats->l4cs); 3440 evcnt_detach(&stats->ipcs_bad); 3441 evcnt_detach(&stats->l4cs_bad); 3442 evcnt_detach(&stats->intzero); 3443 evcnt_detach(&stats->legint); 3444 evcnt_detach(&stats->crcerrs); 3445 evcnt_detach(&stats->illerrc); 3446 evcnt_detach(&stats->errbc); 3447 evcnt_detach(&stats->mspdc); 3448 if (hw->mac.type >= ixgbe_mac_X550) 3449 evcnt_detach(&stats->mbsdc); 3450 evcnt_detach(&stats->mpctotal); 3451 evcnt_detach(&stats->mlfc); 3452 evcnt_detach(&stats->mrfc); 3453 evcnt_detach(&stats->rlec); 3454 evcnt_detach(&stats->lxontxc); 3455 evcnt_detach(&stats->lxonrxc); 3456 evcnt_detach(&stats->lxofftxc); 3457 evcnt_detach(&stats->lxoffrxc); 3458 3459 /* Packet Reception Stats */ 3460 evcnt_detach(&stats->tor); 3461 evcnt_detach(&stats->gorc); 3462 evcnt_detach(&stats->tpr); 3463 evcnt_detach(&stats->gprc); 3464 evcnt_detach(&stats->mprc); 3465 evcnt_detach(&stats->bprc); 3466 evcnt_detach(&stats->prc64); 3467 evcnt_detach(&stats->prc127); 3468 evcnt_detach(&stats->prc255); 3469 evcnt_detach(&stats->prc511); 3470 evcnt_detach(&stats->prc1023); 3471 evcnt_detach(&stats->prc1522); 3472 evcnt_detach(&stats->ruc); 3473 evcnt_detach(&stats->rfc); 3474 evcnt_detach(&stats->roc); 3475 evcnt_detach(&stats->rjc); 3476 evcnt_detach(&stats->mngprc); 3477 evcnt_detach(&stats->mngpdc); 3478 evcnt_detach(&stats->xec); 3479 3480 /* Packet Transmission Stats */ 3481 evcnt_detach(&stats->gotc); 3482 evcnt_detach(&stats->tpt); 3483 evcnt_detach(&stats->gptc); 3484 evcnt_detach(&stats->bptc); 3485 evcnt_detach(&stats->mptc); 3486 evcnt_detach(&stats->mngptc); 3487 evcnt_detach(&stats->ptc64); 3488 evcnt_detach(&stats->ptc127); 3489 evcnt_detach(&stats->ptc255); 3490 evcnt_detach(&stats->ptc511); 3491 evcnt_detach(&stats->ptc1023); 3492 evcnt_detach(&stats->ptc1522); 3493 3494 ixgbe_free_transmit_structures(adapter); 3495 ixgbe_free_receive_structures(adapter); 3496 for (int i = 0; i < adapter->num_queues; i++) { 3497 struct ix_queue * que = &adapter->queues[i]; 3498 mutex_destroy(&que->im_mtx); 3499 } 3500 free(adapter->queues, M_DEVBUF); 3501 free(adapter->mta, M_DEVBUF); 3502 3503 IXGBE_CORE_LOCK_DESTROY(adapter); 3504 3505 return (0); 3506 } /* ixgbe_detach */ 3507 3508 /************************************************************************ 3509 * ixgbe_setup_low_power_mode - LPLU/WoL preparation 3510 * 3511 * Prepare the adapter/port for LPLU and/or WoL 3512 ************************************************************************/ 3513 static int 3514 ixgbe_setup_low_power_mode(struct adapter *adapter) 3515 { 3516 struct ixgbe_hw *hw = &adapter->hw; 3517 device_t dev = adapter->dev; 3518 s32 error = 0; 3519 3520 KASSERT(mutex_owned(&adapter->core_mtx)); 3521 3522 /* Limit power management flow to X550EM baseT */ 3523 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T && 3524 hw->phy.ops.enter_lplu) { 3525 /* X550EM baseT adapters need a special LPLU flow */ 3526 hw->phy.reset_disable = true; 3527 ixgbe_stop(adapter); 3528 error = hw->phy.ops.enter_lplu(hw); 3529 if (error) 3530 device_printf(dev, 3531 "Error entering LPLU: %d\n", error); 3532 hw->phy.reset_disable = false; 3533 } else { 3534 /* Just stop for other adapters */ 3535 ixgbe_stop(adapter); 3536 } 3537 3538 if (!hw->wol_enabled) { 3539 ixgbe_set_phy_power(hw, FALSE); 3540 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3541 IXGBE_WRITE_REG(hw, IXGBE_WUC, 0); 3542 } else { 3543 /* Turn off support for APM wakeup. (Using ACPI instead) */ 3544 IXGBE_WRITE_REG(hw, IXGBE_GRC, 3545 IXGBE_READ_REG(hw, IXGBE_GRC) & ~(u32)2); 3546 3547 /* 3548 * Clear Wake Up Status register to prevent any previous wakeup 3549 * events from waking us up immediately after we suspend. 3550 */ 3551 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3552 3553 /* 3554 * Program the Wakeup Filter Control register with user filter 3555 * settings 3556 */ 3557 IXGBE_WRITE_REG(hw, IXGBE_WUFC, adapter->wufc); 3558 3559 /* Enable wakeups and power management in Wakeup Control */ 3560 IXGBE_WRITE_REG(hw, IXGBE_WUC, 3561 IXGBE_WUC_WKEN | IXGBE_WUC_PME_EN); 3562 3563 } 3564 3565 return error; 3566 } /* ixgbe_setup_low_power_mode */ 3567 3568 /************************************************************************ 3569 * ixgbe_shutdown - Shutdown entry point 3570 ************************************************************************/ 3571 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 3572 static int 3573 ixgbe_shutdown(device_t dev) 3574 { 3575 struct adapter *adapter = device_private(dev); 3576 int error = 0; 3577 3578 INIT_DEBUGOUT("ixgbe_shutdown: begin"); 3579 3580 IXGBE_CORE_LOCK(adapter); 3581 error = ixgbe_setup_low_power_mode(adapter); 3582 IXGBE_CORE_UNLOCK(adapter); 3583 3584 return (error); 3585 } /* ixgbe_shutdown */ 3586 #endif 3587 3588 /************************************************************************ 3589 * ixgbe_suspend 3590 * 3591 * From D0 to D3 3592 ************************************************************************/ 3593 static bool 3594 ixgbe_suspend(device_t dev, const pmf_qual_t *qual) 3595 { 3596 struct adapter *adapter = device_private(dev); 3597 int error = 0; 3598 3599 INIT_DEBUGOUT("ixgbe_suspend: begin"); 3600 3601 IXGBE_CORE_LOCK(adapter); 3602 3603 error = ixgbe_setup_low_power_mode(adapter); 3604 3605 IXGBE_CORE_UNLOCK(adapter); 3606 3607 return (error); 3608 } /* ixgbe_suspend */ 3609 3610 /************************************************************************ 3611 * ixgbe_resume 3612 * 3613 * From D3 to D0 3614 ************************************************************************/ 3615 static bool 3616 ixgbe_resume(device_t dev, const pmf_qual_t *qual) 3617 { 3618 struct adapter *adapter = device_private(dev); 3619 struct ifnet *ifp = adapter->ifp; 3620 struct ixgbe_hw *hw = &adapter->hw; 3621 u32 wus; 3622 3623 INIT_DEBUGOUT("ixgbe_resume: begin"); 3624 3625 IXGBE_CORE_LOCK(adapter); 3626 3627 /* Read & clear WUS register */ 3628 wus = IXGBE_READ_REG(hw, IXGBE_WUS); 3629 if (wus) 3630 device_printf(dev, "Woken up by (WUS): %#010x\n", 3631 IXGBE_READ_REG(hw, IXGBE_WUS)); 3632 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3633 /* And clear WUFC until next low-power transition */ 3634 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3635 3636 /* 3637 * Required after D3->D0 transition; 3638 * will re-advertise all previous advertised speeds 3639 */ 3640 if (ifp->if_flags & IFF_UP) 3641 ixgbe_init_locked(adapter); 3642 3643 IXGBE_CORE_UNLOCK(adapter); 3644 3645 return true; 3646 } /* ixgbe_resume */ 3647 3648 /* 3649 * Set the various hardware offload abilities. 3650 * 3651 * This takes the ifnet's if_capenable flags (e.g. set by the user using 3652 * ifconfig) and indicates to the OS via the ifnet's if_hwassist field what 3653 * mbuf offload flags the driver will understand. 3654 */ 3655 static void 3656 ixgbe_set_if_hwassist(struct adapter *adapter) 3657 { 3658 /* XXX */ 3659 } 3660 3661 /************************************************************************ 3662 * ixgbe_init_locked - Init entry point 3663 * 3664 * Used in two ways: It is used by the stack as an init 3665 * entry point in network interface structure. It is also 3666 * used by the driver as a hw/sw initialization routine to 3667 * get to a consistent state. 3668 * 3669 * return 0 on success, positive on failure 3670 ************************************************************************/ 3671 static void 3672 ixgbe_init_locked(struct adapter *adapter) 3673 { 3674 struct ifnet *ifp = adapter->ifp; 3675 device_t dev = adapter->dev; 3676 struct ixgbe_hw *hw = &adapter->hw; 3677 struct tx_ring *txr; 3678 struct rx_ring *rxr; 3679 u32 txdctl, mhadd; 3680 u32 rxdctl, rxctrl; 3681 u32 ctrl_ext; 3682 int err = 0; 3683 3684 /* XXX check IFF_UP and IFF_RUNNING, power-saving state! */ 3685 3686 KASSERT(mutex_owned(&adapter->core_mtx)); 3687 INIT_DEBUGOUT("ixgbe_init_locked: begin"); 3688 3689 hw->adapter_stopped = FALSE; 3690 ixgbe_stop_adapter(hw); 3691 callout_stop(&adapter->timer); 3692 3693 /* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */ 3694 adapter->max_frame_size = 3695 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 3696 3697 /* Queue indices may change with IOV mode */ 3698 ixgbe_align_all_queue_indices(adapter); 3699 3700 /* reprogram the RAR[0] in case user changed it. */ 3701 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, IXGBE_RAH_AV); 3702 3703 /* Get the latest mac address, User can use a LAA */ 3704 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 3705 IXGBE_ETH_LENGTH_OF_ADDRESS); 3706 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, 1); 3707 hw->addr_ctrl.rar_used_count = 1; 3708 3709 /* Set hardware offload abilities from ifnet flags */ 3710 ixgbe_set_if_hwassist(adapter); 3711 3712 /* Prepare transmit descriptors and buffers */ 3713 if (ixgbe_setup_transmit_structures(adapter)) { 3714 device_printf(dev, "Could not setup transmit structures\n"); 3715 ixgbe_stop(adapter); 3716 return; 3717 } 3718 3719 ixgbe_init_hw(hw); 3720 ixgbe_initialize_iov(adapter); 3721 ixgbe_initialize_transmit_units(adapter); 3722 3723 /* Setup Multicast table */ 3724 ixgbe_set_multi(adapter); 3725 3726 /* Determine the correct mbuf pool, based on frame size */ 3727 if (adapter->max_frame_size <= MCLBYTES) 3728 adapter->rx_mbuf_sz = MCLBYTES; 3729 else 3730 adapter->rx_mbuf_sz = MJUMPAGESIZE; 3731 3732 /* Prepare receive descriptors and buffers */ 3733 if (ixgbe_setup_receive_structures(adapter)) { 3734 device_printf(dev, "Could not setup receive structures\n"); 3735 ixgbe_stop(adapter); 3736 return; 3737 } 3738 3739 /* Configure RX settings */ 3740 ixgbe_initialize_receive_units(adapter); 3741 3742 /* Enable SDP & MSI-X interrupts based on adapter */ 3743 ixgbe_config_gpie(adapter); 3744 3745 /* Set MTU size */ 3746 if (ifp->if_mtu > ETHERMTU) { 3747 /* aka IXGBE_MAXFRS on 82599 and newer */ 3748 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 3749 mhadd &= ~IXGBE_MHADD_MFS_MASK; 3750 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 3751 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 3752 } 3753 3754 /* Now enable all the queues */ 3755 for (int i = 0; i < adapter->num_queues; i++) { 3756 txr = &adapter->tx_rings[i]; 3757 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me)); 3758 txdctl |= IXGBE_TXDCTL_ENABLE; 3759 /* Set WTHRESH to 8, burst writeback */ 3760 txdctl |= (8 << 16); 3761 /* 3762 * When the internal queue falls below PTHRESH (32), 3763 * start prefetching as long as there are at least 3764 * HTHRESH (1) buffers ready. The values are taken 3765 * from the Intel linux driver 3.8.21. 3766 * Prefetching enables tx line rate even with 1 queue. 3767 */ 3768 txdctl |= (32 << 0) | (1 << 8); 3769 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl); 3770 } 3771 3772 for (int i = 0, j = 0; i < adapter->num_queues; i++) { 3773 rxr = &adapter->rx_rings[i]; 3774 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 3775 if (hw->mac.type == ixgbe_mac_82598EB) { 3776 /* 3777 * PTHRESH = 21 3778 * HTHRESH = 4 3779 * WTHRESH = 8 3780 */ 3781 rxdctl &= ~0x3FFFFF; 3782 rxdctl |= 0x080420; 3783 } 3784 rxdctl |= IXGBE_RXDCTL_ENABLE; 3785 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl); 3786 for (; j < 10; j++) { 3787 if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) & 3788 IXGBE_RXDCTL_ENABLE) 3789 break; 3790 else 3791 msec_delay(1); 3792 } 3793 wmb(); 3794 3795 /* 3796 * In netmap mode, we must preserve the buffers made 3797 * available to userspace before the if_init() 3798 * (this is true by default on the TX side, because 3799 * init makes all buffers available to userspace). 3800 * 3801 * netmap_reset() and the device specific routines 3802 * (e.g. ixgbe_setup_receive_rings()) map these 3803 * buffers at the end of the NIC ring, so here we 3804 * must set the RDT (tail) register to make sure 3805 * they are not overwritten. 3806 * 3807 * In this driver the NIC ring starts at RDH = 0, 3808 * RDT points to the last slot available for reception (?), 3809 * so RDT = num_rx_desc - 1 means the whole ring is available. 3810 */ 3811 #ifdef DEV_NETMAP 3812 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 3813 (ifp->if_capenable & IFCAP_NETMAP)) { 3814 struct netmap_adapter *na = NA(adapter->ifp); 3815 struct netmap_kring *kring = &na->rx_rings[i]; 3816 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 3817 3818 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), t); 3819 } else 3820 #endif /* DEV_NETMAP */ 3821 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), 3822 adapter->num_rx_desc - 1); 3823 } 3824 3825 /* Enable Receive engine */ 3826 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 3827 if (hw->mac.type == ixgbe_mac_82598EB) 3828 rxctrl |= IXGBE_RXCTRL_DMBYPS; 3829 rxctrl |= IXGBE_RXCTRL_RXEN; 3830 ixgbe_enable_rx_dma(hw, rxctrl); 3831 3832 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 3833 3834 /* Set up MSI-X routing */ 3835 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 3836 ixgbe_configure_ivars(adapter); 3837 /* Set up auto-mask */ 3838 if (hw->mac.type == ixgbe_mac_82598EB) 3839 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 3840 else { 3841 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF); 3842 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF); 3843 } 3844 } else { /* Simple settings for Legacy/MSI */ 3845 ixgbe_set_ivar(adapter, 0, 0, 0); 3846 ixgbe_set_ivar(adapter, 0, 0, 1); 3847 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 3848 } 3849 3850 ixgbe_init_fdir(adapter); 3851 3852 /* 3853 * Check on any SFP devices that 3854 * need to be kick-started 3855 */ 3856 if (hw->phy.type == ixgbe_phy_none) { 3857 err = hw->phy.ops.identify(hw); 3858 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3859 device_printf(dev, 3860 "Unsupported SFP+ module type was detected.\n"); 3861 return; 3862 } 3863 } 3864 3865 /* Set moderation on the Link interrupt */ 3866 IXGBE_WRITE_REG(hw, IXGBE_EITR(adapter->vector), IXGBE_LINK_ITR); 3867 3868 /* Config/Enable Link */ 3869 ixgbe_config_link(adapter); 3870 3871 /* Hardware Packet Buffer & Flow Control setup */ 3872 ixgbe_config_delay_values(adapter); 3873 3874 /* Initialize the FC settings */ 3875 ixgbe_start_hw(hw); 3876 3877 /* Set up VLAN support and filter */ 3878 ixgbe_setup_vlan_hw_support(adapter); 3879 3880 /* Setup DMA Coalescing */ 3881 ixgbe_config_dmac(adapter); 3882 3883 /* And now turn on interrupts */ 3884 ixgbe_enable_intr(adapter); 3885 3886 /* Enable the use of the MBX by the VF's */ 3887 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) { 3888 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 3889 ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD; 3890 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 3891 } 3892 3893 /* Update saved flags. See ixgbe_ifflags_cb() */ 3894 adapter->if_flags = ifp->if_flags; 3895 3896 /* Now inform the stack we're ready */ 3897 ifp->if_flags |= IFF_RUNNING; 3898 3899 return; 3900 } /* ixgbe_init_locked */ 3901 3902 /************************************************************************ 3903 * ixgbe_init 3904 ************************************************************************/ 3905 static int 3906 ixgbe_init(struct ifnet *ifp) 3907 { 3908 struct adapter *adapter = ifp->if_softc; 3909 3910 IXGBE_CORE_LOCK(adapter); 3911 ixgbe_init_locked(adapter); 3912 IXGBE_CORE_UNLOCK(adapter); 3913 3914 return 0; /* XXX ixgbe_init_locked cannot fail? really? */ 3915 } /* ixgbe_init */ 3916 3917 /************************************************************************ 3918 * ixgbe_set_ivar 3919 * 3920 * Setup the correct IVAR register for a particular MSI-X interrupt 3921 * (yes this is all very magic and confusing :) 3922 * - entry is the register array entry 3923 * - vector is the MSI-X vector for this queue 3924 * - type is RX/TX/MISC 3925 ************************************************************************/ 3926 static void 3927 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 3928 { 3929 struct ixgbe_hw *hw = &adapter->hw; 3930 u32 ivar, index; 3931 3932 vector |= IXGBE_IVAR_ALLOC_VAL; 3933 3934 switch (hw->mac.type) { 3935 case ixgbe_mac_82598EB: 3936 if (type == -1) 3937 entry = IXGBE_IVAR_OTHER_CAUSES_INDEX; 3938 else 3939 entry += (type * 64); 3940 index = (entry >> 2) & 0x1F; 3941 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index)); 3942 ivar &= ~(0xFF << (8 * (entry & 0x3))); 3943 ivar |= (vector << (8 * (entry & 0x3))); 3944 IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar); 3945 break; 3946 case ixgbe_mac_82599EB: 3947 case ixgbe_mac_X540: 3948 case ixgbe_mac_X550: 3949 case ixgbe_mac_X550EM_x: 3950 case ixgbe_mac_X550EM_a: 3951 if (type == -1) { /* MISC IVAR */ 3952 index = (entry & 1) * 8; 3953 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC); 3954 ivar &= ~(0xFF << index); 3955 ivar |= (vector << index); 3956 IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar); 3957 } else { /* RX/TX IVARS */ 3958 index = (16 * (entry & 1)) + (8 * type); 3959 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1)); 3960 ivar &= ~(0xFF << index); 3961 ivar |= (vector << index); 3962 IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar); 3963 } 3964 break; 3965 default: 3966 break; 3967 } 3968 } /* ixgbe_set_ivar */ 3969 3970 /************************************************************************ 3971 * ixgbe_configure_ivars 3972 ************************************************************************/ 3973 static void 3974 ixgbe_configure_ivars(struct adapter *adapter) 3975 { 3976 struct ix_queue *que = adapter->queues; 3977 u32 newitr; 3978 3979 if (ixgbe_max_interrupt_rate > 0) 3980 newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8; 3981 else { 3982 /* 3983 * Disable DMA coalescing if interrupt moderation is 3984 * disabled. 3985 */ 3986 adapter->dmac = 0; 3987 newitr = 0; 3988 } 3989 3990 for (int i = 0; i < adapter->num_queues; i++, que++) { 3991 struct rx_ring *rxr = &adapter->rx_rings[i]; 3992 struct tx_ring *txr = &adapter->tx_rings[i]; 3993 /* First the RX queue entry */ 3994 ixgbe_set_ivar(adapter, rxr->me, que->msix, 0); 3995 /* ... and the TX */ 3996 ixgbe_set_ivar(adapter, txr->me, que->msix, 1); 3997 /* Set an Initial EITR value */ 3998 ixgbe_eitr_write(que, newitr); 3999 } 4000 4001 /* For the Link interrupt */ 4002 ixgbe_set_ivar(adapter, 1, adapter->vector, -1); 4003 } /* ixgbe_configure_ivars */ 4004 4005 /************************************************************************ 4006 * ixgbe_config_gpie 4007 ************************************************************************/ 4008 static void 4009 ixgbe_config_gpie(struct adapter *adapter) 4010 { 4011 struct ixgbe_hw *hw = &adapter->hw; 4012 u32 gpie; 4013 4014 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE); 4015 4016 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4017 /* Enable Enhanced MSI-X mode */ 4018 gpie |= IXGBE_GPIE_MSIX_MODE 4019 | IXGBE_GPIE_EIAME 4020 | IXGBE_GPIE_PBA_SUPPORT 4021 | IXGBE_GPIE_OCD; 4022 } 4023 4024 /* Fan Failure Interrupt */ 4025 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4026 gpie |= IXGBE_SDP1_GPIEN; 4027 4028 /* Thermal Sensor Interrupt */ 4029 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) 4030 gpie |= IXGBE_SDP0_GPIEN_X540; 4031 4032 /* Link detection */ 4033 switch (hw->mac.type) { 4034 case ixgbe_mac_82599EB: 4035 gpie |= IXGBE_SDP1_GPIEN | IXGBE_SDP2_GPIEN; 4036 break; 4037 case ixgbe_mac_X550EM_x: 4038 case ixgbe_mac_X550EM_a: 4039 gpie |= IXGBE_SDP0_GPIEN_X540; 4040 break; 4041 default: 4042 break; 4043 } 4044 4045 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 4046 4047 } /* ixgbe_config_gpie */ 4048 4049 /************************************************************************ 4050 * ixgbe_config_delay_values 4051 * 4052 * Requires adapter->max_frame_size to be set. 4053 ************************************************************************/ 4054 static void 4055 ixgbe_config_delay_values(struct adapter *adapter) 4056 { 4057 struct ixgbe_hw *hw = &adapter->hw; 4058 u32 rxpb, frame, size, tmp; 4059 4060 frame = adapter->max_frame_size; 4061 4062 /* Calculate High Water */ 4063 switch (hw->mac.type) { 4064 case ixgbe_mac_X540: 4065 case ixgbe_mac_X550: 4066 case ixgbe_mac_X550EM_x: 4067 case ixgbe_mac_X550EM_a: 4068 tmp = IXGBE_DV_X540(frame, frame); 4069 break; 4070 default: 4071 tmp = IXGBE_DV(frame, frame); 4072 break; 4073 } 4074 size = IXGBE_BT2KB(tmp); 4075 rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10; 4076 hw->fc.high_water[0] = rxpb - size; 4077 4078 /* Now calculate Low Water */ 4079 switch (hw->mac.type) { 4080 case ixgbe_mac_X540: 4081 case ixgbe_mac_X550: 4082 case ixgbe_mac_X550EM_x: 4083 case ixgbe_mac_X550EM_a: 4084 tmp = IXGBE_LOW_DV_X540(frame); 4085 break; 4086 default: 4087 tmp = IXGBE_LOW_DV(frame); 4088 break; 4089 } 4090 hw->fc.low_water[0] = IXGBE_BT2KB(tmp); 4091 4092 hw->fc.pause_time = IXGBE_FC_PAUSE; 4093 hw->fc.send_xon = TRUE; 4094 } /* ixgbe_config_delay_values */ 4095 4096 /************************************************************************ 4097 * ixgbe_set_multi - Multicast Update 4098 * 4099 * Called whenever multicast address list is updated. 4100 ************************************************************************/ 4101 static void 4102 ixgbe_set_multi(struct adapter *adapter) 4103 { 4104 struct ixgbe_mc_addr *mta; 4105 struct ifnet *ifp = adapter->ifp; 4106 u8 *update_ptr; 4107 int mcnt = 0; 4108 u32 fctrl; 4109 struct ethercom *ec = &adapter->osdep.ec; 4110 struct ether_multi *enm; 4111 struct ether_multistep step; 4112 4113 KASSERT(mutex_owned(&adapter->core_mtx)); 4114 IOCTL_DEBUGOUT("ixgbe_set_multi: begin"); 4115 4116 mta = adapter->mta; 4117 bzero(mta, sizeof(*mta) * MAX_NUM_MULTICAST_ADDRESSES); 4118 4119 ifp->if_flags &= ~IFF_ALLMULTI; 4120 ETHER_LOCK(ec); 4121 ETHER_FIRST_MULTI(step, ec, enm); 4122 while (enm != NULL) { 4123 if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) || 4124 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 4125 ETHER_ADDR_LEN) != 0)) { 4126 ifp->if_flags |= IFF_ALLMULTI; 4127 break; 4128 } 4129 bcopy(enm->enm_addrlo, 4130 mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS); 4131 mta[mcnt].vmdq = adapter->pool; 4132 mcnt++; 4133 ETHER_NEXT_MULTI(step, enm); 4134 } 4135 ETHER_UNLOCK(ec); 4136 4137 fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 4138 fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4139 if (ifp->if_flags & IFF_PROMISC) 4140 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4141 else if (ifp->if_flags & IFF_ALLMULTI) { 4142 fctrl |= IXGBE_FCTRL_MPE; 4143 } 4144 4145 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl); 4146 4147 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) { 4148 update_ptr = (u8 *)mta; 4149 ixgbe_update_mc_addr_list(&adapter->hw, update_ptr, mcnt, 4150 ixgbe_mc_array_itr, TRUE); 4151 } 4152 4153 } /* ixgbe_set_multi */ 4154 4155 /************************************************************************ 4156 * ixgbe_mc_array_itr 4157 * 4158 * An iterator function needed by the multicast shared code. 4159 * It feeds the shared code routine the addresses in the 4160 * array of ixgbe_set_multi() one by one. 4161 ************************************************************************/ 4162 static u8 * 4163 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 4164 { 4165 struct ixgbe_mc_addr *mta; 4166 4167 mta = (struct ixgbe_mc_addr *)*update_ptr; 4168 *vmdq = mta->vmdq; 4169 4170 *update_ptr = (u8*)(mta + 1); 4171 4172 return (mta->addr); 4173 } /* ixgbe_mc_array_itr */ 4174 4175 /************************************************************************ 4176 * ixgbe_local_timer - Timer routine 4177 * 4178 * Checks for link status, updates statistics, 4179 * and runs the watchdog check. 4180 ************************************************************************/ 4181 static void 4182 ixgbe_local_timer(void *arg) 4183 { 4184 struct adapter *adapter = arg; 4185 4186 IXGBE_CORE_LOCK(adapter); 4187 ixgbe_local_timer1(adapter); 4188 IXGBE_CORE_UNLOCK(adapter); 4189 } 4190 4191 static void 4192 ixgbe_local_timer1(void *arg) 4193 { 4194 struct adapter *adapter = arg; 4195 device_t dev = adapter->dev; 4196 struct ix_queue *que = adapter->queues; 4197 u64 queues = 0; 4198 u64 v0, v1, v2, v3, v4, v5, v6, v7; 4199 int hung = 0; 4200 int i; 4201 4202 KASSERT(mutex_owned(&adapter->core_mtx)); 4203 4204 /* Check for pluggable optics */ 4205 if (adapter->sfp_probe) 4206 if (!ixgbe_sfp_probe(adapter)) 4207 goto out; /* Nothing to do */ 4208 4209 ixgbe_update_link_status(adapter); 4210 ixgbe_update_stats_counters(adapter); 4211 4212 /* Update some event counters */ 4213 v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0; 4214 que = adapter->queues; 4215 for (i = 0; i < adapter->num_queues; i++, que++) { 4216 struct tx_ring *txr = que->txr; 4217 4218 v0 += txr->q_efbig_tx_dma_setup; 4219 v1 += txr->q_mbuf_defrag_failed; 4220 v2 += txr->q_efbig2_tx_dma_setup; 4221 v3 += txr->q_einval_tx_dma_setup; 4222 v4 += txr->q_other_tx_dma_setup; 4223 v5 += txr->q_eagain_tx_dma_setup; 4224 v6 += txr->q_enomem_tx_dma_setup; 4225 v7 += txr->q_tso_err; 4226 } 4227 adapter->efbig_tx_dma_setup.ev_count = v0; 4228 adapter->mbuf_defrag_failed.ev_count = v1; 4229 adapter->efbig2_tx_dma_setup.ev_count = v2; 4230 adapter->einval_tx_dma_setup.ev_count = v3; 4231 adapter->other_tx_dma_setup.ev_count = v4; 4232 adapter->eagain_tx_dma_setup.ev_count = v5; 4233 adapter->enomem_tx_dma_setup.ev_count = v6; 4234 adapter->tso_err.ev_count = v7; 4235 4236 /* 4237 * Check the TX queues status 4238 * - mark hung queues so we don't schedule on them 4239 * - watchdog only if all queues show hung 4240 */ 4241 que = adapter->queues; 4242 for (i = 0; i < adapter->num_queues; i++, que++) { 4243 /* Keep track of queues with work for soft irq */ 4244 if (que->txr->busy) 4245 queues |= ((u64)1 << que->me); 4246 /* 4247 * Each time txeof runs without cleaning, but there 4248 * are uncleaned descriptors it increments busy. If 4249 * we get to the MAX we declare it hung. 4250 */ 4251 if (que->busy == IXGBE_QUEUE_HUNG) { 4252 ++hung; 4253 /* Mark the queue as inactive */ 4254 adapter->active_queues &= ~((u64)1 << que->me); 4255 continue; 4256 } else { 4257 /* Check if we've come back from hung */ 4258 if ((adapter->active_queues & ((u64)1 << que->me)) == 0) 4259 adapter->active_queues |= ((u64)1 << que->me); 4260 } 4261 if (que->busy >= IXGBE_MAX_TX_BUSY) { 4262 device_printf(dev, 4263 "Warning queue %d appears to be hung!\n", i); 4264 que->txr->busy = IXGBE_QUEUE_HUNG; 4265 ++hung; 4266 } 4267 } 4268 4269 /* Only truely watchdog if all queues show hung */ 4270 if (hung == adapter->num_queues) 4271 goto watchdog; 4272 else if (queues != 0) { /* Force an IRQ on queues with work */ 4273 que = adapter->queues; 4274 for (i = 0; i < adapter->num_queues; i++, que++) { 4275 mutex_enter(&que->im_mtx); 4276 if (que->im_nest == 0) 4277 ixgbe_rearm_queues(adapter, 4278 queues & ((u64)1 << i)); 4279 mutex_exit(&que->im_mtx); 4280 } 4281 } 4282 4283 out: 4284 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4285 return; 4286 4287 watchdog: 4288 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 4289 adapter->ifp->if_flags &= ~IFF_RUNNING; 4290 adapter->watchdog_events.ev_count++; 4291 ixgbe_init_locked(adapter); 4292 } /* ixgbe_local_timer */ 4293 4294 /************************************************************************ 4295 * ixgbe_sfp_probe 4296 * 4297 * Determine if a port had optics inserted. 4298 ************************************************************************/ 4299 static bool 4300 ixgbe_sfp_probe(struct adapter *adapter) 4301 { 4302 struct ixgbe_hw *hw = &adapter->hw; 4303 device_t dev = adapter->dev; 4304 bool result = FALSE; 4305 4306 if ((hw->phy.type == ixgbe_phy_nl) && 4307 (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) { 4308 s32 ret = hw->phy.ops.identify_sfp(hw); 4309 if (ret) 4310 goto out; 4311 ret = hw->phy.ops.reset(hw); 4312 adapter->sfp_probe = FALSE; 4313 if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4314 device_printf(dev,"Unsupported SFP+ module detected!"); 4315 device_printf(dev, 4316 "Reload driver with supported module.\n"); 4317 goto out; 4318 } else 4319 device_printf(dev, "SFP+ module detected!\n"); 4320 /* We now have supported optics */ 4321 result = TRUE; 4322 } 4323 out: 4324 4325 return (result); 4326 } /* ixgbe_sfp_probe */ 4327 4328 /************************************************************************ 4329 * ixgbe_handle_mod - Tasklet for SFP module interrupts 4330 ************************************************************************/ 4331 static void 4332 ixgbe_handle_mod(void *context) 4333 { 4334 struct adapter *adapter = context; 4335 struct ixgbe_hw *hw = &adapter->hw; 4336 device_t dev = adapter->dev; 4337 u32 err, cage_full = 0; 4338 4339 if (adapter->hw.need_crosstalk_fix) { 4340 switch (hw->mac.type) { 4341 case ixgbe_mac_82599EB: 4342 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4343 IXGBE_ESDP_SDP2; 4344 break; 4345 case ixgbe_mac_X550EM_x: 4346 case ixgbe_mac_X550EM_a: 4347 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4348 IXGBE_ESDP_SDP0; 4349 break; 4350 default: 4351 break; 4352 } 4353 4354 if (!cage_full) 4355 return; 4356 } 4357 4358 err = hw->phy.ops.identify_sfp(hw); 4359 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4360 device_printf(dev, 4361 "Unsupported SFP+ module type was detected.\n"); 4362 return; 4363 } 4364 4365 err = hw->mac.ops.setup_sfp(hw); 4366 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4367 device_printf(dev, 4368 "Setup failure - unsupported SFP+ module type.\n"); 4369 return; 4370 } 4371 softint_schedule(adapter->msf_si); 4372 } /* ixgbe_handle_mod */ 4373 4374 4375 /************************************************************************ 4376 * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts 4377 ************************************************************************/ 4378 static void 4379 ixgbe_handle_msf(void *context) 4380 { 4381 struct adapter *adapter = context; 4382 struct ixgbe_hw *hw = &adapter->hw; 4383 u32 autoneg; 4384 bool negotiate; 4385 4386 /* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */ 4387 adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 4388 4389 autoneg = hw->phy.autoneg_advertised; 4390 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 4391 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 4392 else 4393 negotiate = 0; 4394 if (hw->mac.ops.setup_link) 4395 hw->mac.ops.setup_link(hw, autoneg, TRUE); 4396 4397 /* Adjust media types shown in ifconfig */ 4398 ifmedia_removeall(&adapter->media); 4399 ixgbe_add_media_types(adapter); 4400 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 4401 } /* ixgbe_handle_msf */ 4402 4403 /************************************************************************ 4404 * ixgbe_handle_phy - Tasklet for external PHY interrupts 4405 ************************************************************************/ 4406 static void 4407 ixgbe_handle_phy(void *context) 4408 { 4409 struct adapter *adapter = context; 4410 struct ixgbe_hw *hw = &adapter->hw; 4411 int error; 4412 4413 error = hw->phy.ops.handle_lasi(hw); 4414 if (error == IXGBE_ERR_OVERTEMP) 4415 device_printf(adapter->dev, 4416 "CRITICAL: EXTERNAL PHY OVER TEMP!! " 4417 " PHY will downshift to lower power state!\n"); 4418 else if (error) 4419 device_printf(adapter->dev, 4420 "Error handling LASI interrupt: %d\n", error); 4421 } /* ixgbe_handle_phy */ 4422 4423 static void 4424 ixgbe_ifstop(struct ifnet *ifp, int disable) 4425 { 4426 struct adapter *adapter = ifp->if_softc; 4427 4428 IXGBE_CORE_LOCK(adapter); 4429 ixgbe_stop(adapter); 4430 IXGBE_CORE_UNLOCK(adapter); 4431 } 4432 4433 /************************************************************************ 4434 * ixgbe_stop - Stop the hardware 4435 * 4436 * Disables all traffic on the adapter by issuing a 4437 * global reset on the MAC and deallocates TX/RX buffers. 4438 ************************************************************************/ 4439 static void 4440 ixgbe_stop(void *arg) 4441 { 4442 struct ifnet *ifp; 4443 struct adapter *adapter = arg; 4444 struct ixgbe_hw *hw = &adapter->hw; 4445 4446 ifp = adapter->ifp; 4447 4448 KASSERT(mutex_owned(&adapter->core_mtx)); 4449 4450 INIT_DEBUGOUT("ixgbe_stop: begin\n"); 4451 ixgbe_disable_intr(adapter); 4452 callout_stop(&adapter->timer); 4453 4454 /* Let the stack know...*/ 4455 ifp->if_flags &= ~IFF_RUNNING; 4456 4457 ixgbe_reset_hw(hw); 4458 hw->adapter_stopped = FALSE; 4459 ixgbe_stop_adapter(hw); 4460 if (hw->mac.type == ixgbe_mac_82599EB) 4461 ixgbe_stop_mac_link_on_d3_82599(hw); 4462 /* Turn off the laser - noop with no optics */ 4463 ixgbe_disable_tx_laser(hw); 4464 4465 /* Update the stack */ 4466 adapter->link_up = FALSE; 4467 ixgbe_update_link_status(adapter); 4468 4469 /* reprogram the RAR[0] in case user changed it. */ 4470 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 4471 4472 return; 4473 } /* ixgbe_stop */ 4474 4475 /************************************************************************ 4476 * ixgbe_update_link_status - Update OS on link state 4477 * 4478 * Note: Only updates the OS on the cached link state. 4479 * The real check of the hardware only happens with 4480 * a link interrupt. 4481 ************************************************************************/ 4482 static void 4483 ixgbe_update_link_status(struct adapter *adapter) 4484 { 4485 struct ifnet *ifp = adapter->ifp; 4486 device_t dev = adapter->dev; 4487 struct ixgbe_hw *hw = &adapter->hw; 4488 4489 KASSERT(mutex_owned(&adapter->core_mtx)); 4490 4491 if (adapter->link_up) { 4492 if (adapter->link_active == FALSE) { 4493 if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){ 4494 /* 4495 * Discard count for both MAC Local Fault and 4496 * Remote Fault because those registers are 4497 * valid only when the link speed is up and 4498 * 10Gbps. 4499 */ 4500 IXGBE_READ_REG(hw, IXGBE_MLFC); 4501 IXGBE_READ_REG(hw, IXGBE_MRFC); 4502 } 4503 4504 if (bootverbose) { 4505 const char *bpsmsg; 4506 4507 switch (adapter->link_speed) { 4508 case IXGBE_LINK_SPEED_10GB_FULL: 4509 bpsmsg = "10 Gbps"; 4510 break; 4511 case IXGBE_LINK_SPEED_5GB_FULL: 4512 bpsmsg = "5 Gbps"; 4513 break; 4514 case IXGBE_LINK_SPEED_2_5GB_FULL: 4515 bpsmsg = "2.5 Gbps"; 4516 break; 4517 case IXGBE_LINK_SPEED_1GB_FULL: 4518 bpsmsg = "1 Gbps"; 4519 break; 4520 case IXGBE_LINK_SPEED_100_FULL: 4521 bpsmsg = "100 Mbps"; 4522 break; 4523 case IXGBE_LINK_SPEED_10_FULL: 4524 bpsmsg = "10 Mbps"; 4525 break; 4526 default: 4527 bpsmsg = "unknown speed"; 4528 break; 4529 } 4530 device_printf(dev, "Link is up %s %s \n", 4531 bpsmsg, "Full Duplex"); 4532 } 4533 adapter->link_active = TRUE; 4534 /* Update any Flow Control changes */ 4535 ixgbe_fc_enable(&adapter->hw); 4536 /* Update DMA coalescing config */ 4537 ixgbe_config_dmac(adapter); 4538 if_link_state_change(ifp, LINK_STATE_UP); 4539 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4540 ixgbe_ping_all_vfs(adapter); 4541 } 4542 } else { /* Link down */ 4543 if (adapter->link_active == TRUE) { 4544 if (bootverbose) 4545 device_printf(dev, "Link is Down\n"); 4546 if_link_state_change(ifp, LINK_STATE_DOWN); 4547 adapter->link_active = FALSE; 4548 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4549 ixgbe_ping_all_vfs(adapter); 4550 } 4551 } 4552 } /* ixgbe_update_link_status */ 4553 4554 /************************************************************************ 4555 * ixgbe_config_dmac - Configure DMA Coalescing 4556 ************************************************************************/ 4557 static void 4558 ixgbe_config_dmac(struct adapter *adapter) 4559 { 4560 struct ixgbe_hw *hw = &adapter->hw; 4561 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 4562 4563 if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config) 4564 return; 4565 4566 if (dcfg->watchdog_timer ^ adapter->dmac || 4567 dcfg->link_speed ^ adapter->link_speed) { 4568 dcfg->watchdog_timer = adapter->dmac; 4569 dcfg->fcoe_en = false; 4570 dcfg->link_speed = adapter->link_speed; 4571 dcfg->num_tcs = 1; 4572 4573 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 4574 dcfg->watchdog_timer, dcfg->link_speed); 4575 4576 hw->mac.ops.dmac_config(hw); 4577 } 4578 } /* ixgbe_config_dmac */ 4579 4580 /************************************************************************ 4581 * ixgbe_enable_intr 4582 ************************************************************************/ 4583 static void 4584 ixgbe_enable_intr(struct adapter *adapter) 4585 { 4586 struct ixgbe_hw *hw = &adapter->hw; 4587 struct ix_queue *que = adapter->queues; 4588 u32 mask, fwsm; 4589 4590 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 4591 4592 switch (adapter->hw.mac.type) { 4593 case ixgbe_mac_82599EB: 4594 mask |= IXGBE_EIMS_ECC; 4595 /* Temperature sensor on some adapters */ 4596 mask |= IXGBE_EIMS_GPI_SDP0; 4597 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 4598 mask |= IXGBE_EIMS_GPI_SDP1; 4599 mask |= IXGBE_EIMS_GPI_SDP2; 4600 break; 4601 case ixgbe_mac_X540: 4602 /* Detect if Thermal Sensor is enabled */ 4603 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 4604 if (fwsm & IXGBE_FWSM_TS_ENABLED) 4605 mask |= IXGBE_EIMS_TS; 4606 mask |= IXGBE_EIMS_ECC; 4607 break; 4608 case ixgbe_mac_X550: 4609 /* MAC thermal sensor is automatically enabled */ 4610 mask |= IXGBE_EIMS_TS; 4611 mask |= IXGBE_EIMS_ECC; 4612 break; 4613 case ixgbe_mac_X550EM_x: 4614 case ixgbe_mac_X550EM_a: 4615 /* Some devices use SDP0 for important information */ 4616 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 4617 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP || 4618 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N || 4619 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 4620 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 4621 if (hw->phy.type == ixgbe_phy_x550em_ext_t) 4622 mask |= IXGBE_EICR_GPI_SDP0_X540; 4623 mask |= IXGBE_EIMS_ECC; 4624 break; 4625 default: 4626 break; 4627 } 4628 4629 /* Enable Fan Failure detection */ 4630 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4631 mask |= IXGBE_EIMS_GPI_SDP1; 4632 /* Enable SR-IOV */ 4633 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4634 mask |= IXGBE_EIMS_MAILBOX; 4635 /* Enable Flow Director */ 4636 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 4637 mask |= IXGBE_EIMS_FLOW_DIR; 4638 4639 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 4640 4641 /* With MSI-X we use auto clear */ 4642 if (adapter->msix_mem) { 4643 mask = IXGBE_EIMS_ENABLE_MASK; 4644 /* Don't autoclear Link */ 4645 mask &= ~IXGBE_EIMS_OTHER; 4646 mask &= ~IXGBE_EIMS_LSC; 4647 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 4648 mask &= ~IXGBE_EIMS_MAILBOX; 4649 IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask); 4650 } 4651 4652 /* 4653 * Now enable all queues, this is done separately to 4654 * allow for handling the extended (beyond 32) MSI-X 4655 * vectors that can be used by 82599 4656 */ 4657 for (int i = 0; i < adapter->num_queues; i++, que++) 4658 ixgbe_enable_queue(adapter, que->msix); 4659 4660 IXGBE_WRITE_FLUSH(hw); 4661 4662 return; 4663 } /* ixgbe_enable_intr */ 4664 4665 /************************************************************************ 4666 * ixgbe_disable_intr 4667 ************************************************************************/ 4668 static void 4669 ixgbe_disable_intr(struct adapter *adapter) 4670 { 4671 struct ix_queue *que = adapter->queues; 4672 4673 /* disable interrupts other than queues */ 4674 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE); 4675 4676 if (adapter->msix_mem) 4677 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 4678 4679 for (int i = 0; i < adapter->num_queues; i++, que++) 4680 ixgbe_disable_queue(adapter, que->msix); 4681 4682 IXGBE_WRITE_FLUSH(&adapter->hw); 4683 4684 } /* ixgbe_disable_intr */ 4685 4686 /************************************************************************ 4687 * ixgbe_legacy_irq - Legacy Interrupt Service routine 4688 ************************************************************************/ 4689 static int 4690 ixgbe_legacy_irq(void *arg) 4691 { 4692 struct ix_queue *que = arg; 4693 struct adapter *adapter = que->adapter; 4694 struct ixgbe_hw *hw = &adapter->hw; 4695 struct ifnet *ifp = adapter->ifp; 4696 struct tx_ring *txr = adapter->tx_rings; 4697 bool more = false; 4698 u32 eicr, eicr_mask; 4699 4700 /* Silicon errata #26 on 82598 */ 4701 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 4702 4703 eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 4704 4705 adapter->stats.pf.legint.ev_count++; 4706 ++que->irqs.ev_count; 4707 if (eicr == 0) { 4708 adapter->stats.pf.intzero.ev_count++; 4709 if ((ifp->if_flags & IFF_UP) != 0) 4710 ixgbe_enable_intr(adapter); 4711 return 0; 4712 } 4713 4714 if ((ifp->if_flags & IFF_RUNNING) != 0) { 4715 #ifdef __NetBSD__ 4716 /* Don't run ixgbe_rxeof in interrupt context */ 4717 more = true; 4718 #else 4719 more = ixgbe_rxeof(que); 4720 #endif 4721 4722 IXGBE_TX_LOCK(txr); 4723 ixgbe_txeof(txr); 4724 #ifdef notyet 4725 if (!ixgbe_ring_empty(ifp, txr->br)) 4726 ixgbe_start_locked(ifp, txr); 4727 #endif 4728 IXGBE_TX_UNLOCK(txr); 4729 } 4730 4731 /* Check for fan failure */ 4732 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 4733 ixgbe_check_fan_failure(adapter, eicr, true); 4734 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 4735 } 4736 4737 /* Link status change */ 4738 if (eicr & IXGBE_EICR_LSC) 4739 softint_schedule(adapter->link_si); 4740 4741 if (ixgbe_is_sfp(hw)) { 4742 /* Pluggable optics-related interrupt */ 4743 if (hw->mac.type >= ixgbe_mac_X540) 4744 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 4745 else 4746 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 4747 4748 if (eicr & eicr_mask) { 4749 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 4750 softint_schedule(adapter->mod_si); 4751 } 4752 4753 if ((hw->mac.type == ixgbe_mac_82599EB) && 4754 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 4755 IXGBE_WRITE_REG(hw, IXGBE_EICR, 4756 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 4757 softint_schedule(adapter->msf_si); 4758 } 4759 } 4760 4761 /* External PHY interrupt */ 4762 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 4763 (eicr & IXGBE_EICR_GPI_SDP0_X540)) 4764 softint_schedule(adapter->phy_si); 4765 4766 if (more) { 4767 que->req.ev_count++; 4768 ixgbe_sched_handle_que(adapter, que); 4769 } else 4770 ixgbe_enable_intr(adapter); 4771 4772 return 1; 4773 } /* ixgbe_legacy_irq */ 4774 4775 /************************************************************************ 4776 * ixgbe_free_pciintr_resources 4777 ************************************************************************/ 4778 static void 4779 ixgbe_free_pciintr_resources(struct adapter *adapter) 4780 { 4781 struct ix_queue *que = adapter->queues; 4782 int rid; 4783 4784 /* 4785 * Release all msix queue resources: 4786 */ 4787 for (int i = 0; i < adapter->num_queues; i++, que++) { 4788 if (que->res != NULL) { 4789 pci_intr_disestablish(adapter->osdep.pc, 4790 adapter->osdep.ihs[i]); 4791 adapter->osdep.ihs[i] = NULL; 4792 } 4793 } 4794 4795 /* Clean the Legacy or Link interrupt last */ 4796 if (adapter->vector) /* we are doing MSIX */ 4797 rid = adapter->vector; 4798 else 4799 rid = 0; 4800 4801 if (adapter->osdep.ihs[rid] != NULL) { 4802 pci_intr_disestablish(adapter->osdep.pc, 4803 adapter->osdep.ihs[rid]); 4804 adapter->osdep.ihs[rid] = NULL; 4805 } 4806 4807 if (adapter->osdep.intrs != NULL) { 4808 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 4809 adapter->osdep.nintrs); 4810 adapter->osdep.intrs = NULL; 4811 } 4812 4813 return; 4814 } /* ixgbe_free_pciintr_resources */ 4815 4816 /************************************************************************ 4817 * ixgbe_free_pci_resources 4818 ************************************************************************/ 4819 static void 4820 ixgbe_free_pci_resources(struct adapter *adapter) 4821 { 4822 4823 ixgbe_free_pciintr_resources(adapter); 4824 4825 if (adapter->osdep.mem_size != 0) { 4826 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 4827 adapter->osdep.mem_bus_space_handle, 4828 adapter->osdep.mem_size); 4829 } 4830 4831 return; 4832 } /* ixgbe_free_pci_resources */ 4833 4834 /************************************************************************ 4835 * ixgbe_set_sysctl_value 4836 ************************************************************************/ 4837 static void 4838 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 4839 const char *description, int *limit, int value) 4840 { 4841 device_t dev = adapter->dev; 4842 struct sysctllog **log; 4843 const struct sysctlnode *rnode, *cnode; 4844 4845 log = &adapter->sysctllog; 4846 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 4847 aprint_error_dev(dev, "could not create sysctl root\n"); 4848 return; 4849 } 4850 if (sysctl_createv(log, 0, &rnode, &cnode, 4851 CTLFLAG_READWRITE, CTLTYPE_INT, 4852 name, SYSCTL_DESCR(description), 4853 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 4854 aprint_error_dev(dev, "could not create sysctl\n"); 4855 *limit = value; 4856 } /* ixgbe_set_sysctl_value */ 4857 4858 /************************************************************************ 4859 * ixgbe_sysctl_flowcntl 4860 * 4861 * SYSCTL wrapper around setting Flow Control 4862 ************************************************************************/ 4863 static int 4864 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 4865 { 4866 struct sysctlnode node = *rnode; 4867 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4868 int error, fc; 4869 4870 fc = adapter->hw.fc.current_mode; 4871 node.sysctl_data = &fc; 4872 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4873 if (error != 0 || newp == NULL) 4874 return error; 4875 4876 /* Don't bother if it's not changed */ 4877 if (fc == adapter->hw.fc.current_mode) 4878 return (0); 4879 4880 return ixgbe_set_flowcntl(adapter, fc); 4881 } /* ixgbe_sysctl_flowcntl */ 4882 4883 /************************************************************************ 4884 * ixgbe_set_flowcntl - Set flow control 4885 * 4886 * Flow control values: 4887 * 0 - off 4888 * 1 - rx pause 4889 * 2 - tx pause 4890 * 3 - full 4891 ************************************************************************/ 4892 static int 4893 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 4894 { 4895 switch (fc) { 4896 case ixgbe_fc_rx_pause: 4897 case ixgbe_fc_tx_pause: 4898 case ixgbe_fc_full: 4899 adapter->hw.fc.requested_mode = fc; 4900 if (adapter->num_queues > 1) 4901 ixgbe_disable_rx_drop(adapter); 4902 break; 4903 case ixgbe_fc_none: 4904 adapter->hw.fc.requested_mode = ixgbe_fc_none; 4905 if (adapter->num_queues > 1) 4906 ixgbe_enable_rx_drop(adapter); 4907 break; 4908 default: 4909 return (EINVAL); 4910 } 4911 4912 #if 0 /* XXX NetBSD */ 4913 /* Don't autoneg if forcing a value */ 4914 adapter->hw.fc.disable_fc_autoneg = TRUE; 4915 #endif 4916 ixgbe_fc_enable(&adapter->hw); 4917 4918 return (0); 4919 } /* ixgbe_set_flowcntl */ 4920 4921 /************************************************************************ 4922 * ixgbe_enable_rx_drop 4923 * 4924 * Enable the hardware to drop packets when the buffer is 4925 * full. This is useful with multiqueue, so that no single 4926 * queue being full stalls the entire RX engine. We only 4927 * enable this when Multiqueue is enabled AND Flow Control 4928 * is disabled. 4929 ************************************************************************/ 4930 static void 4931 ixgbe_enable_rx_drop(struct adapter *adapter) 4932 { 4933 struct ixgbe_hw *hw = &adapter->hw; 4934 struct rx_ring *rxr; 4935 u32 srrctl; 4936 4937 for (int i = 0; i < adapter->num_queues; i++) { 4938 rxr = &adapter->rx_rings[i]; 4939 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 4940 srrctl |= IXGBE_SRRCTL_DROP_EN; 4941 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 4942 } 4943 4944 /* enable drop for each vf */ 4945 for (int i = 0; i < adapter->num_vfs; i++) { 4946 IXGBE_WRITE_REG(hw, IXGBE_QDE, 4947 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 4948 IXGBE_QDE_ENABLE)); 4949 } 4950 } /* ixgbe_enable_rx_drop */ 4951 4952 /************************************************************************ 4953 * ixgbe_disable_rx_drop 4954 ************************************************************************/ 4955 static void 4956 ixgbe_disable_rx_drop(struct adapter *adapter) 4957 { 4958 struct ixgbe_hw *hw = &adapter->hw; 4959 struct rx_ring *rxr; 4960 u32 srrctl; 4961 4962 for (int i = 0; i < adapter->num_queues; i++) { 4963 rxr = &adapter->rx_rings[i]; 4964 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 4965 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 4966 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 4967 } 4968 4969 /* disable drop for each vf */ 4970 for (int i = 0; i < adapter->num_vfs; i++) { 4971 IXGBE_WRITE_REG(hw, IXGBE_QDE, 4972 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 4973 } 4974 } /* ixgbe_disable_rx_drop */ 4975 4976 /************************************************************************ 4977 * ixgbe_sysctl_advertise 4978 * 4979 * SYSCTL wrapper around setting advertised speed 4980 ************************************************************************/ 4981 static int 4982 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 4983 { 4984 struct sysctlnode node = *rnode; 4985 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4986 int error = 0, advertise; 4987 4988 advertise = adapter->advertise; 4989 node.sysctl_data = &advertise; 4990 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4991 if (error != 0 || newp == NULL) 4992 return error; 4993 4994 return ixgbe_set_advertise(adapter, advertise); 4995 } /* ixgbe_sysctl_advertise */ 4996 4997 /************************************************************************ 4998 * ixgbe_set_advertise - Control advertised link speed 4999 * 5000 * Flags: 5001 * 0x00 - Default (all capable link speed) 5002 * 0x01 - advertise 100 Mb 5003 * 0x02 - advertise 1G 5004 * 0x04 - advertise 10G 5005 * 0x08 - advertise 10 Mb 5006 * 0x10 - advertise 2.5G 5007 * 0x20 - advertise 5G 5008 ************************************************************************/ 5009 static int 5010 ixgbe_set_advertise(struct adapter *adapter, int advertise) 5011 { 5012 device_t dev; 5013 struct ixgbe_hw *hw; 5014 ixgbe_link_speed speed = 0; 5015 ixgbe_link_speed link_caps = 0; 5016 s32 err = IXGBE_NOT_IMPLEMENTED; 5017 bool negotiate = FALSE; 5018 5019 /* Checks to validate new value */ 5020 if (adapter->advertise == advertise) /* no change */ 5021 return (0); 5022 5023 dev = adapter->dev; 5024 hw = &adapter->hw; 5025 5026 /* No speed changes for backplane media */ 5027 if (hw->phy.media_type == ixgbe_media_type_backplane) 5028 return (ENODEV); 5029 5030 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5031 (hw->phy.multispeed_fiber))) { 5032 device_printf(dev, 5033 "Advertised speed can only be set on copper or " 5034 "multispeed fiber media types.\n"); 5035 return (EINVAL); 5036 } 5037 5038 if (advertise < 0x0 || advertise > 0x2f) { 5039 device_printf(dev, 5040 "Invalid advertised speed; valid modes are 0x0 through 0x7\n"); 5041 return (EINVAL); 5042 } 5043 5044 if (hw->mac.ops.get_link_capabilities) { 5045 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 5046 &negotiate); 5047 if (err != IXGBE_SUCCESS) { 5048 device_printf(dev, "Unable to determine supported advertise speeds\n"); 5049 return (ENODEV); 5050 } 5051 } 5052 5053 /* Set new value and report new advertised mode */ 5054 if (advertise & 0x1) { 5055 if (!(link_caps & IXGBE_LINK_SPEED_100_FULL)) { 5056 device_printf(dev, "Interface does not support 100Mb advertised speed\n"); 5057 return (EINVAL); 5058 } 5059 speed |= IXGBE_LINK_SPEED_100_FULL; 5060 } 5061 if (advertise & 0x2) { 5062 if (!(link_caps & IXGBE_LINK_SPEED_1GB_FULL)) { 5063 device_printf(dev, "Interface does not support 1Gb advertised speed\n"); 5064 return (EINVAL); 5065 } 5066 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5067 } 5068 if (advertise & 0x4) { 5069 if (!(link_caps & IXGBE_LINK_SPEED_10GB_FULL)) { 5070 device_printf(dev, "Interface does not support 10Gb advertised speed\n"); 5071 return (EINVAL); 5072 } 5073 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5074 } 5075 if (advertise & 0x8) { 5076 if (!(link_caps & IXGBE_LINK_SPEED_10_FULL)) { 5077 device_printf(dev, "Interface does not support 10Mb advertised speed\n"); 5078 return (EINVAL); 5079 } 5080 speed |= IXGBE_LINK_SPEED_10_FULL; 5081 } 5082 if (advertise & 0x10) { 5083 if (!(link_caps & IXGBE_LINK_SPEED_2_5GB_FULL)) { 5084 device_printf(dev, "Interface does not support 2.5Gb advertised speed\n"); 5085 return (EINVAL); 5086 } 5087 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 5088 } 5089 if (advertise & 0x20) { 5090 if (!(link_caps & IXGBE_LINK_SPEED_5GB_FULL)) { 5091 device_printf(dev, "Interface does not support 5Gb advertised speed\n"); 5092 return (EINVAL); 5093 } 5094 speed |= IXGBE_LINK_SPEED_5GB_FULL; 5095 } 5096 if (advertise == 0) 5097 speed = link_caps; /* All capable link speed */ 5098 5099 hw->mac.autotry_restart = TRUE; 5100 hw->mac.ops.setup_link(hw, speed, TRUE); 5101 adapter->advertise = advertise; 5102 5103 return (0); 5104 } /* ixgbe_set_advertise */ 5105 5106 /************************************************************************ 5107 * ixgbe_get_advertise - Get current advertised speed settings 5108 * 5109 * Formatted for sysctl usage. 5110 * Flags: 5111 * 0x01 - advertise 100 Mb 5112 * 0x02 - advertise 1G 5113 * 0x04 - advertise 10G 5114 * 0x08 - advertise 10 Mb (yes, Mb) 5115 * 0x10 - advertise 2.5G 5116 * 0x20 - advertise 5G 5117 ************************************************************************/ 5118 static int 5119 ixgbe_get_advertise(struct adapter *adapter) 5120 { 5121 struct ixgbe_hw *hw = &adapter->hw; 5122 int speed; 5123 ixgbe_link_speed link_caps = 0; 5124 s32 err; 5125 bool negotiate = FALSE; 5126 5127 /* 5128 * Advertised speed means nothing unless it's copper or 5129 * multi-speed fiber 5130 */ 5131 if (!(hw->phy.media_type == ixgbe_media_type_copper) && 5132 !(hw->phy.multispeed_fiber)) 5133 return (0); 5134 5135 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, &negotiate); 5136 if (err != IXGBE_SUCCESS) 5137 return (0); 5138 5139 speed = 5140 ((link_caps & IXGBE_LINK_SPEED_10GB_FULL) ? 0x04 : 0) | 5141 ((link_caps & IXGBE_LINK_SPEED_1GB_FULL) ? 0x02 : 0) | 5142 ((link_caps & IXGBE_LINK_SPEED_100_FULL) ? 0x01 : 0) | 5143 ((link_caps & IXGBE_LINK_SPEED_10_FULL) ? 0x08 : 0) | 5144 ((link_caps & IXGBE_LINK_SPEED_2_5GB_FULL) ? 0x10 : 0) | 5145 ((link_caps & IXGBE_LINK_SPEED_5GB_FULL) ? 0x20 : 0); 5146 5147 return speed; 5148 } /* ixgbe_get_advertise */ 5149 5150 /************************************************************************ 5151 * ixgbe_sysctl_dmac - Manage DMA Coalescing 5152 * 5153 * Control values: 5154 * 0/1 - off / on (use default value of 1000) 5155 * 5156 * Legal timer values are: 5157 * 50,100,250,500,1000,2000,5000,10000 5158 * 5159 * Turning off interrupt moderation will also turn this off. 5160 ************************************************************************/ 5161 static int 5162 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5163 { 5164 struct sysctlnode node = *rnode; 5165 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5166 struct ifnet *ifp = adapter->ifp; 5167 int error; 5168 int newval; 5169 5170 newval = adapter->dmac; 5171 node.sysctl_data = &newval; 5172 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5173 if ((error) || (newp == NULL)) 5174 return (error); 5175 5176 switch (newval) { 5177 case 0: 5178 /* Disabled */ 5179 adapter->dmac = 0; 5180 break; 5181 case 1: 5182 /* Enable and use default */ 5183 adapter->dmac = 1000; 5184 break; 5185 case 50: 5186 case 100: 5187 case 250: 5188 case 500: 5189 case 1000: 5190 case 2000: 5191 case 5000: 5192 case 10000: 5193 /* Legal values - allow */ 5194 adapter->dmac = newval; 5195 break; 5196 default: 5197 /* Do nothing, illegal value */ 5198 return (EINVAL); 5199 } 5200 5201 /* Re-initialize hardware if it's already running */ 5202 if (ifp->if_flags & IFF_RUNNING) 5203 ifp->if_init(ifp); 5204 5205 return (0); 5206 } 5207 5208 #ifdef IXGBE_DEBUG 5209 /************************************************************************ 5210 * ixgbe_sysctl_power_state 5211 * 5212 * Sysctl to test power states 5213 * Values: 5214 * 0 - set device to D0 5215 * 3 - set device to D3 5216 * (none) - get current device power state 5217 ************************************************************************/ 5218 static int 5219 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5220 { 5221 #ifdef notyet 5222 struct sysctlnode node = *rnode; 5223 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5224 device_t dev = adapter->dev; 5225 int curr_ps, new_ps, error = 0; 5226 5227 curr_ps = new_ps = pci_get_powerstate(dev); 5228 5229 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5230 if ((error) || (req->newp == NULL)) 5231 return (error); 5232 5233 if (new_ps == curr_ps) 5234 return (0); 5235 5236 if (new_ps == 3 && curr_ps == 0) 5237 error = DEVICE_SUSPEND(dev); 5238 else if (new_ps == 0 && curr_ps == 3) 5239 error = DEVICE_RESUME(dev); 5240 else 5241 return (EINVAL); 5242 5243 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5244 5245 return (error); 5246 #else 5247 return 0; 5248 #endif 5249 } /* ixgbe_sysctl_power_state */ 5250 #endif 5251 5252 /************************************************************************ 5253 * ixgbe_sysctl_wol_enable 5254 * 5255 * Sysctl to enable/disable the WoL capability, 5256 * if supported by the adapter. 5257 * 5258 * Values: 5259 * 0 - disabled 5260 * 1 - enabled 5261 ************************************************************************/ 5262 static int 5263 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5264 { 5265 struct sysctlnode node = *rnode; 5266 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5267 struct ixgbe_hw *hw = &adapter->hw; 5268 bool new_wol_enabled; 5269 int error = 0; 5270 5271 new_wol_enabled = hw->wol_enabled; 5272 node.sysctl_data = &new_wol_enabled; 5273 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5274 if ((error) || (newp == NULL)) 5275 return (error); 5276 if (new_wol_enabled == hw->wol_enabled) 5277 return (0); 5278 5279 if (new_wol_enabled && !adapter->wol_support) 5280 return (ENODEV); 5281 else 5282 hw->wol_enabled = new_wol_enabled; 5283 5284 return (0); 5285 } /* ixgbe_sysctl_wol_enable */ 5286 5287 /************************************************************************ 5288 * ixgbe_sysctl_wufc - Wake Up Filter Control 5289 * 5290 * Sysctl to enable/disable the types of packets that the 5291 * adapter will wake up on upon receipt. 5292 * Flags: 5293 * 0x1 - Link Status Change 5294 * 0x2 - Magic Packet 5295 * 0x4 - Direct Exact 5296 * 0x8 - Directed Multicast 5297 * 0x10 - Broadcast 5298 * 0x20 - ARP/IPv4 Request Packet 5299 * 0x40 - Direct IPv4 Packet 5300 * 0x80 - Direct IPv6 Packet 5301 * 5302 * Settings not listed above will cause the sysctl to return an error. 5303 ************************************************************************/ 5304 static int 5305 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5306 { 5307 struct sysctlnode node = *rnode; 5308 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5309 int error = 0; 5310 u32 new_wufc; 5311 5312 new_wufc = adapter->wufc; 5313 node.sysctl_data = &new_wufc; 5314 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5315 if ((error) || (newp == NULL)) 5316 return (error); 5317 if (new_wufc == adapter->wufc) 5318 return (0); 5319 5320 if (new_wufc & 0xffffff00) 5321 return (EINVAL); 5322 5323 new_wufc &= 0xff; 5324 new_wufc |= (0xffffff & adapter->wufc); 5325 adapter->wufc = new_wufc; 5326 5327 return (0); 5328 } /* ixgbe_sysctl_wufc */ 5329 5330 #ifdef IXGBE_DEBUG 5331 /************************************************************************ 5332 * ixgbe_sysctl_print_rss_config 5333 ************************************************************************/ 5334 static int 5335 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5336 { 5337 #ifdef notyet 5338 struct sysctlnode node = *rnode; 5339 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5340 struct ixgbe_hw *hw = &adapter->hw; 5341 device_t dev = adapter->dev; 5342 struct sbuf *buf; 5343 int error = 0, reta_size; 5344 u32 reg; 5345 5346 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5347 if (!buf) { 5348 device_printf(dev, "Could not allocate sbuf for output.\n"); 5349 return (ENOMEM); 5350 } 5351 5352 // TODO: use sbufs to make a string to print out 5353 /* Set multiplier for RETA setup and table size based on MAC */ 5354 switch (adapter->hw.mac.type) { 5355 case ixgbe_mac_X550: 5356 case ixgbe_mac_X550EM_x: 5357 case ixgbe_mac_X550EM_a: 5358 reta_size = 128; 5359 break; 5360 default: 5361 reta_size = 32; 5362 break; 5363 } 5364 5365 /* Print out the redirection table */ 5366 sbuf_cat(buf, "\n"); 5367 for (int i = 0; i < reta_size; i++) { 5368 if (i < 32) { 5369 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5370 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5371 } else { 5372 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5373 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5374 } 5375 } 5376 5377 // TODO: print more config 5378 5379 error = sbuf_finish(buf); 5380 if (error) 5381 device_printf(dev, "Error finishing sbuf: %d\n", error); 5382 5383 sbuf_delete(buf); 5384 #endif 5385 return (0); 5386 } /* ixgbe_sysctl_print_rss_config */ 5387 #endif /* IXGBE_DEBUG */ 5388 5389 /************************************************************************ 5390 * ixgbe_sysctl_phy_temp - Retrieve temperature of PHY 5391 * 5392 * For X552/X557-AT devices using an external PHY 5393 ************************************************************************/ 5394 static int 5395 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5396 { 5397 struct sysctlnode node = *rnode; 5398 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5399 struct ixgbe_hw *hw = &adapter->hw; 5400 int val; 5401 u16 reg; 5402 int error; 5403 5404 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5405 device_printf(adapter->dev, 5406 "Device has no supported external thermal sensor.\n"); 5407 return (ENODEV); 5408 } 5409 5410 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5411 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5412 device_printf(adapter->dev, 5413 "Error reading from PHY's current temperature register\n"); 5414 return (EAGAIN); 5415 } 5416 5417 node.sysctl_data = &val; 5418 5419 /* Shift temp for output */ 5420 val = reg >> 8; 5421 5422 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5423 if ((error) || (newp == NULL)) 5424 return (error); 5425 5426 return (0); 5427 } /* ixgbe_sysctl_phy_temp */ 5428 5429 /************************************************************************ 5430 * ixgbe_sysctl_phy_overtemp_occurred 5431 * 5432 * Reports (directly from the PHY) whether the current PHY 5433 * temperature is over the overtemp threshold. 5434 ************************************************************************/ 5435 static int 5436 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 5437 { 5438 struct sysctlnode node = *rnode; 5439 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5440 struct ixgbe_hw *hw = &adapter->hw; 5441 int val, error; 5442 u16 reg; 5443 5444 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5445 device_printf(adapter->dev, 5446 "Device has no supported external thermal sensor.\n"); 5447 return (ENODEV); 5448 } 5449 5450 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 5451 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5452 device_printf(adapter->dev, 5453 "Error reading from PHY's temperature status register\n"); 5454 return (EAGAIN); 5455 } 5456 5457 node.sysctl_data = &val; 5458 5459 /* Get occurrence bit */ 5460 val = !!(reg & 0x4000); 5461 5462 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5463 if ((error) || (newp == NULL)) 5464 return (error); 5465 5466 return (0); 5467 } /* ixgbe_sysctl_phy_overtemp_occurred */ 5468 5469 /************************************************************************ 5470 * ixgbe_sysctl_eee_state 5471 * 5472 * Sysctl to set EEE power saving feature 5473 * Values: 5474 * 0 - disable EEE 5475 * 1 - enable EEE 5476 * (none) - get current device EEE state 5477 ************************************************************************/ 5478 static int 5479 ixgbe_sysctl_eee_state(SYSCTLFN_ARGS) 5480 { 5481 struct sysctlnode node = *rnode; 5482 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5483 struct ifnet *ifp = adapter->ifp; 5484 device_t dev = adapter->dev; 5485 int curr_eee, new_eee, error = 0; 5486 s32 retval; 5487 5488 curr_eee = new_eee = !!(adapter->feat_en & IXGBE_FEATURE_EEE); 5489 node.sysctl_data = &new_eee; 5490 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5491 if ((error) || (newp == NULL)) 5492 return (error); 5493 5494 /* Nothing to do */ 5495 if (new_eee == curr_eee) 5496 return (0); 5497 5498 /* Not supported */ 5499 if (!(adapter->feat_cap & IXGBE_FEATURE_EEE)) 5500 return (EINVAL); 5501 5502 /* Bounds checking */ 5503 if ((new_eee < 0) || (new_eee > 1)) 5504 return (EINVAL); 5505 5506 retval = adapter->hw.mac.ops.setup_eee(&adapter->hw, new_eee); 5507 if (retval) { 5508 device_printf(dev, "Error in EEE setup: 0x%08X\n", retval); 5509 return (EINVAL); 5510 } 5511 5512 /* Restart auto-neg */ 5513 ifp->if_init(ifp); 5514 5515 device_printf(dev, "New EEE state: %d\n", new_eee); 5516 5517 /* Cache new value */ 5518 if (new_eee) 5519 adapter->feat_en |= IXGBE_FEATURE_EEE; 5520 else 5521 adapter->feat_en &= ~IXGBE_FEATURE_EEE; 5522 5523 return (error); 5524 } /* ixgbe_sysctl_eee_state */ 5525 5526 /************************************************************************ 5527 * ixgbe_init_device_features 5528 ************************************************************************/ 5529 static void 5530 ixgbe_init_device_features(struct adapter *adapter) 5531 { 5532 adapter->feat_cap = IXGBE_FEATURE_NETMAP 5533 | IXGBE_FEATURE_RSS 5534 | IXGBE_FEATURE_MSI 5535 | IXGBE_FEATURE_MSIX 5536 | IXGBE_FEATURE_LEGACY_IRQ 5537 | IXGBE_FEATURE_LEGACY_TX; 5538 5539 /* Set capabilities first... */ 5540 switch (adapter->hw.mac.type) { 5541 case ixgbe_mac_82598EB: 5542 if (adapter->hw.device_id == IXGBE_DEV_ID_82598AT) 5543 adapter->feat_cap |= IXGBE_FEATURE_FAN_FAIL; 5544 break; 5545 case ixgbe_mac_X540: 5546 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5547 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5548 if ((adapter->hw.device_id == IXGBE_DEV_ID_X540_BYPASS) && 5549 (adapter->hw.bus.func == 0)) 5550 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 5551 break; 5552 case ixgbe_mac_X550: 5553 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 5554 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5555 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5556 break; 5557 case ixgbe_mac_X550EM_x: 5558 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5559 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5560 if (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_X_KR) 5561 adapter->feat_cap |= IXGBE_FEATURE_EEE; 5562 break; 5563 case ixgbe_mac_X550EM_a: 5564 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5565 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5566 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 5567 if ((adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T) || 5568 (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)) { 5569 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 5570 adapter->feat_cap |= IXGBE_FEATURE_EEE; 5571 } 5572 break; 5573 case ixgbe_mac_82599EB: 5574 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5575 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5576 if ((adapter->hw.device_id == IXGBE_DEV_ID_82599_BYPASS) && 5577 (adapter->hw.bus.func == 0)) 5578 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 5579 if (adapter->hw.device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) 5580 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 5581 break; 5582 default: 5583 break; 5584 } 5585 5586 /* Enabled by default... */ 5587 /* Fan failure detection */ 5588 if (adapter->feat_cap & IXGBE_FEATURE_FAN_FAIL) 5589 adapter->feat_en |= IXGBE_FEATURE_FAN_FAIL; 5590 /* Netmap */ 5591 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 5592 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 5593 /* EEE */ 5594 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 5595 adapter->feat_en |= IXGBE_FEATURE_EEE; 5596 /* Thermal Sensor */ 5597 if (adapter->feat_cap & IXGBE_FEATURE_TEMP_SENSOR) 5598 adapter->feat_en |= IXGBE_FEATURE_TEMP_SENSOR; 5599 5600 /* Enabled via global sysctl... */ 5601 /* Flow Director */ 5602 if (ixgbe_enable_fdir) { 5603 if (adapter->feat_cap & IXGBE_FEATURE_FDIR) 5604 adapter->feat_en |= IXGBE_FEATURE_FDIR; 5605 else 5606 device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled."); 5607 } 5608 /* Legacy (single queue) transmit */ 5609 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 5610 ixgbe_enable_legacy_tx) 5611 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 5612 /* 5613 * Message Signal Interrupts - Extended (MSI-X) 5614 * Normal MSI is only enabled if MSI-X calls fail. 5615 */ 5616 if (!ixgbe_enable_msix) 5617 adapter->feat_cap &= ~IXGBE_FEATURE_MSIX; 5618 /* Receive-Side Scaling (RSS) */ 5619 if ((adapter->feat_cap & IXGBE_FEATURE_RSS) && ixgbe_enable_rss) 5620 adapter->feat_en |= IXGBE_FEATURE_RSS; 5621 5622 /* Disable features with unmet dependencies... */ 5623 /* No MSI-X */ 5624 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) { 5625 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 5626 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 5627 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 5628 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 5629 } 5630 } /* ixgbe_init_device_features */ 5631 5632 /************************************************************************ 5633 * ixgbe_probe - Device identification routine 5634 * 5635 * Determines if the driver should be loaded on 5636 * adapter based on its PCI vendor/device ID. 5637 * 5638 * return BUS_PROBE_DEFAULT on success, positive on failure 5639 ************************************************************************/ 5640 static int 5641 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 5642 { 5643 const struct pci_attach_args *pa = aux; 5644 5645 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 5646 } 5647 5648 static ixgbe_vendor_info_t * 5649 ixgbe_lookup(const struct pci_attach_args *pa) 5650 { 5651 ixgbe_vendor_info_t *ent; 5652 pcireg_t subid; 5653 5654 INIT_DEBUGOUT("ixgbe_lookup: begin"); 5655 5656 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 5657 return NULL; 5658 5659 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 5660 5661 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 5662 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 5663 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 5664 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 5665 (ent->subvendor_id == 0)) && 5666 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 5667 (ent->subdevice_id == 0))) { 5668 ++ixgbe_total_ports; 5669 return ent; 5670 } 5671 } 5672 return NULL; 5673 } 5674 5675 static int 5676 ixgbe_ifflags_cb(struct ethercom *ec) 5677 { 5678 struct ifnet *ifp = &ec->ec_if; 5679 struct adapter *adapter = ifp->if_softc; 5680 int change = ifp->if_flags ^ adapter->if_flags, rc = 0; 5681 5682 IXGBE_CORE_LOCK(adapter); 5683 5684 if (change != 0) 5685 adapter->if_flags = ifp->if_flags; 5686 5687 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) 5688 rc = ENETRESET; 5689 else if ((change & (IFF_PROMISC | IFF_ALLMULTI)) != 0) 5690 ixgbe_set_promisc(adapter); 5691 5692 /* Set up VLAN support and filter */ 5693 ixgbe_setup_vlan_hw_support(adapter); 5694 5695 IXGBE_CORE_UNLOCK(adapter); 5696 5697 return rc; 5698 } 5699 5700 /************************************************************************ 5701 * ixgbe_ioctl - Ioctl entry point 5702 * 5703 * Called when the user wants to configure the interface. 5704 * 5705 * return 0 on success, positive on failure 5706 ************************************************************************/ 5707 static int 5708 ixgbe_ioctl(struct ifnet * ifp, u_long command, void *data) 5709 { 5710 struct adapter *adapter = ifp->if_softc; 5711 struct ixgbe_hw *hw = &adapter->hw; 5712 struct ifcapreq *ifcr = data; 5713 struct ifreq *ifr = data; 5714 int error = 0; 5715 int l4csum_en; 5716 const int l4csum = IFCAP_CSUM_TCPv4_Rx|IFCAP_CSUM_UDPv4_Rx| 5717 IFCAP_CSUM_TCPv6_Rx|IFCAP_CSUM_UDPv6_Rx; 5718 5719 switch (command) { 5720 case SIOCSIFFLAGS: 5721 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 5722 break; 5723 case SIOCADDMULTI: 5724 case SIOCDELMULTI: 5725 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 5726 break; 5727 case SIOCSIFMEDIA: 5728 case SIOCGIFMEDIA: 5729 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 5730 break; 5731 case SIOCSIFCAP: 5732 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 5733 break; 5734 case SIOCSIFMTU: 5735 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 5736 break; 5737 #ifdef __NetBSD__ 5738 case SIOCINITIFADDR: 5739 IOCTL_DEBUGOUT("ioctl: SIOCINITIFADDR"); 5740 break; 5741 case SIOCGIFFLAGS: 5742 IOCTL_DEBUGOUT("ioctl: SIOCGIFFLAGS"); 5743 break; 5744 case SIOCGIFAFLAG_IN: 5745 IOCTL_DEBUGOUT("ioctl: SIOCGIFAFLAG_IN"); 5746 break; 5747 case SIOCGIFADDR: 5748 IOCTL_DEBUGOUT("ioctl: SIOCGIFADDR"); 5749 break; 5750 case SIOCGIFMTU: 5751 IOCTL_DEBUGOUT("ioctl: SIOCGIFMTU (Get Interface MTU)"); 5752 break; 5753 case SIOCGIFCAP: 5754 IOCTL_DEBUGOUT("ioctl: SIOCGIFCAP (Get IF cap)"); 5755 break; 5756 case SIOCGETHERCAP: 5757 IOCTL_DEBUGOUT("ioctl: SIOCGETHERCAP (Get ethercap)"); 5758 break; 5759 case SIOCGLIFADDR: 5760 IOCTL_DEBUGOUT("ioctl: SIOCGLIFADDR (Get Interface addr)"); 5761 break; 5762 case SIOCZIFDATA: 5763 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 5764 hw->mac.ops.clear_hw_cntrs(hw); 5765 ixgbe_clear_evcnt(adapter); 5766 break; 5767 case SIOCAIFADDR: 5768 IOCTL_DEBUGOUT("ioctl: SIOCAIFADDR (add/chg IF alias)"); 5769 break; 5770 #endif 5771 default: 5772 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 5773 break; 5774 } 5775 5776 switch (command) { 5777 case SIOCSIFMEDIA: 5778 case SIOCGIFMEDIA: 5779 return ifmedia_ioctl(ifp, ifr, &adapter->media, command); 5780 case SIOCGI2C: 5781 { 5782 struct ixgbe_i2c_req i2c; 5783 5784 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 5785 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 5786 if (error != 0) 5787 break; 5788 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 5789 error = EINVAL; 5790 break; 5791 } 5792 if (i2c.len > sizeof(i2c.data)) { 5793 error = EINVAL; 5794 break; 5795 } 5796 5797 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 5798 i2c.dev_addr, i2c.data); 5799 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 5800 break; 5801 } 5802 case SIOCSIFCAP: 5803 /* Layer-4 Rx checksum offload has to be turned on and 5804 * off as a unit. 5805 */ 5806 l4csum_en = ifcr->ifcr_capenable & l4csum; 5807 if (l4csum_en != l4csum && l4csum_en != 0) 5808 return EINVAL; 5809 /*FALLTHROUGH*/ 5810 case SIOCADDMULTI: 5811 case SIOCDELMULTI: 5812 case SIOCSIFFLAGS: 5813 case SIOCSIFMTU: 5814 default: 5815 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 5816 return error; 5817 if ((ifp->if_flags & IFF_RUNNING) == 0) 5818 ; 5819 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 5820 IXGBE_CORE_LOCK(adapter); 5821 if ((ifp->if_flags & IFF_RUNNING) != 0) 5822 ixgbe_init_locked(adapter); 5823 ixgbe_recalculate_max_frame(adapter); 5824 IXGBE_CORE_UNLOCK(adapter); 5825 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 5826 /* 5827 * Multicast list has changed; set the hardware filter 5828 * accordingly. 5829 */ 5830 IXGBE_CORE_LOCK(adapter); 5831 ixgbe_disable_intr(adapter); 5832 ixgbe_set_multi(adapter); 5833 ixgbe_enable_intr(adapter); 5834 IXGBE_CORE_UNLOCK(adapter); 5835 } 5836 return 0; 5837 } 5838 5839 return error; 5840 } /* ixgbe_ioctl */ 5841 5842 /************************************************************************ 5843 * ixgbe_check_fan_failure 5844 ************************************************************************/ 5845 static void 5846 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt) 5847 { 5848 u32 mask; 5849 5850 mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) : 5851 IXGBE_ESDP_SDP1; 5852 5853 if (reg & mask) 5854 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n"); 5855 } /* ixgbe_check_fan_failure */ 5856 5857 /************************************************************************ 5858 * ixgbe_handle_que 5859 ************************************************************************/ 5860 static void 5861 ixgbe_handle_que(void *context) 5862 { 5863 struct ix_queue *que = context; 5864 struct adapter *adapter = que->adapter; 5865 struct tx_ring *txr = que->txr; 5866 struct ifnet *ifp = adapter->ifp; 5867 bool more = false; 5868 5869 que->handleq.ev_count++; 5870 5871 if (ifp->if_flags & IFF_RUNNING) { 5872 more = ixgbe_rxeof(que); 5873 IXGBE_TX_LOCK(txr); 5874 more |= ixgbe_txeof(txr); 5875 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 5876 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 5877 ixgbe_mq_start_locked(ifp, txr); 5878 /* Only for queue 0 */ 5879 /* NetBSD still needs this for CBQ */ 5880 if ((&adapter->queues[0] == que) 5881 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 5882 ixgbe_legacy_start_locked(ifp, txr); 5883 IXGBE_TX_UNLOCK(txr); 5884 } 5885 5886 if (more) { 5887 que->req.ev_count++; 5888 ixgbe_sched_handle_que(adapter, que); 5889 } else if (que->res != NULL) { 5890 /* Re-enable this interrupt */ 5891 ixgbe_enable_queue(adapter, que->msix); 5892 } else 5893 ixgbe_enable_intr(adapter); 5894 5895 return; 5896 } /* ixgbe_handle_que */ 5897 5898 /************************************************************************ 5899 * ixgbe_handle_que_work 5900 ************************************************************************/ 5901 static void 5902 ixgbe_handle_que_work(struct work *wk, void *context) 5903 { 5904 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 5905 5906 /* 5907 * "enqueued flag" is not required here. 5908 * See ixgbe_msix_que(). 5909 */ 5910 ixgbe_handle_que(que); 5911 } 5912 5913 /************************************************************************ 5914 * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler 5915 ************************************************************************/ 5916 static int 5917 ixgbe_allocate_legacy(struct adapter *adapter, 5918 const struct pci_attach_args *pa) 5919 { 5920 device_t dev = adapter->dev; 5921 struct ix_queue *que = adapter->queues; 5922 struct tx_ring *txr = adapter->tx_rings; 5923 int counts[PCI_INTR_TYPE_SIZE]; 5924 pci_intr_type_t intr_type, max_type; 5925 char intrbuf[PCI_INTRSTR_LEN]; 5926 const char *intrstr = NULL; 5927 5928 /* We allocate a single interrupt resource */ 5929 max_type = PCI_INTR_TYPE_MSI; 5930 counts[PCI_INTR_TYPE_MSIX] = 0; 5931 counts[PCI_INTR_TYPE_MSI] = 5932 (adapter->feat_en & IXGBE_FEATURE_MSI) ? 1 : 0; 5933 /* Check not feat_en but feat_cap to fallback to INTx */ 5934 counts[PCI_INTR_TYPE_INTX] = 5935 (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) ? 1 : 0; 5936 5937 alloc_retry: 5938 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 5939 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 5940 return ENXIO; 5941 } 5942 adapter->osdep.nintrs = 1; 5943 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 5944 intrbuf, sizeof(intrbuf)); 5945 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 5946 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 5947 device_xname(dev)); 5948 intr_type = pci_intr_type(adapter->osdep.pc, adapter->osdep.intrs[0]); 5949 if (adapter->osdep.ihs[0] == NULL) { 5950 aprint_error_dev(dev,"unable to establish %s\n", 5951 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 5952 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 5953 adapter->osdep.intrs = NULL; 5954 switch (intr_type) { 5955 case PCI_INTR_TYPE_MSI: 5956 /* The next try is for INTx: Disable MSI */ 5957 max_type = PCI_INTR_TYPE_INTX; 5958 counts[PCI_INTR_TYPE_INTX] = 1; 5959 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 5960 if (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) { 5961 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 5962 goto alloc_retry; 5963 } else 5964 break; 5965 case PCI_INTR_TYPE_INTX: 5966 default: 5967 /* See below */ 5968 break; 5969 } 5970 } 5971 if (intr_type == PCI_INTR_TYPE_INTX) { 5972 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 5973 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 5974 } 5975 if (adapter->osdep.ihs[0] == NULL) { 5976 aprint_error_dev(dev, 5977 "couldn't establish interrupt%s%s\n", 5978 intrstr ? " at " : "", intrstr ? intrstr : ""); 5979 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 5980 adapter->osdep.intrs = NULL; 5981 return ENXIO; 5982 } 5983 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 5984 /* 5985 * Try allocating a fast interrupt and the associated deferred 5986 * processing contexts. 5987 */ 5988 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 5989 txr->txr_si = 5990 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 5991 ixgbe_deferred_mq_start, txr); 5992 que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 5993 ixgbe_handle_que, que); 5994 5995 if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) 5996 & (txr->txr_si == NULL)) || (que->que_si == NULL)) { 5997 aprint_error_dev(dev, 5998 "could not establish software interrupts\n"); 5999 6000 return ENXIO; 6001 } 6002 /* For simplicity in the handlers */ 6003 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 6004 6005 return (0); 6006 } /* ixgbe_allocate_legacy */ 6007 6008 /************************************************************************ 6009 * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers 6010 ************************************************************************/ 6011 static int 6012 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 6013 { 6014 device_t dev = adapter->dev; 6015 struct ix_queue *que = adapter->queues; 6016 struct tx_ring *txr = adapter->tx_rings; 6017 pci_chipset_tag_t pc; 6018 char intrbuf[PCI_INTRSTR_LEN]; 6019 char intr_xname[32]; 6020 char wqname[MAXCOMLEN]; 6021 const char *intrstr = NULL; 6022 int error, vector = 0; 6023 int cpu_id = 0; 6024 kcpuset_t *affinity; 6025 #ifdef RSS 6026 unsigned int rss_buckets = 0; 6027 kcpuset_t cpu_mask; 6028 #endif 6029 6030 pc = adapter->osdep.pc; 6031 #ifdef RSS 6032 /* 6033 * If we're doing RSS, the number of queues needs to 6034 * match the number of RSS buckets that are configured. 6035 * 6036 * + If there's more queues than RSS buckets, we'll end 6037 * up with queues that get no traffic. 6038 * 6039 * + If there's more RSS buckets than queues, we'll end 6040 * up having multiple RSS buckets map to the same queue, 6041 * so there'll be some contention. 6042 */ 6043 rss_buckets = rss_getnumbuckets(); 6044 if ((adapter->feat_en & IXGBE_FEATURE_RSS) && 6045 (adapter->num_queues != rss_buckets)) { 6046 device_printf(dev, 6047 "%s: number of queues (%d) != number of RSS buckets (%d)" 6048 "; performance will be impacted.\n", 6049 __func__, adapter->num_queues, rss_buckets); 6050 } 6051 #endif 6052 6053 adapter->osdep.nintrs = adapter->num_queues + 1; 6054 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 6055 adapter->osdep.nintrs) != 0) { 6056 aprint_error_dev(dev, 6057 "failed to allocate MSI-X interrupt\n"); 6058 return (ENXIO); 6059 } 6060 6061 kcpuset_create(&affinity, false); 6062 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 6063 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 6064 device_xname(dev), i); 6065 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 6066 sizeof(intrbuf)); 6067 #ifdef IXGBE_MPSAFE 6068 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 6069 true); 6070 #endif 6071 /* Set the handler function */ 6072 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 6073 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 6074 intr_xname); 6075 if (que->res == NULL) { 6076 aprint_error_dev(dev, 6077 "Failed to register QUE handler\n"); 6078 error = ENXIO; 6079 goto err_out; 6080 } 6081 que->msix = vector; 6082 adapter->active_queues |= (u64)(1 << que->msix); 6083 6084 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 6085 #ifdef RSS 6086 /* 6087 * The queue ID is used as the RSS layer bucket ID. 6088 * We look up the queue ID -> RSS CPU ID and select 6089 * that. 6090 */ 6091 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 6092 CPU_SETOF(cpu_id, &cpu_mask); 6093 #endif 6094 } else { 6095 /* 6096 * Bind the MSI-X vector, and thus the 6097 * rings to the corresponding CPU. 6098 * 6099 * This just happens to match the default RSS 6100 * round-robin bucket -> queue -> CPU allocation. 6101 */ 6102 if (adapter->num_queues > 1) 6103 cpu_id = i; 6104 } 6105 /* Round-robin affinity */ 6106 kcpuset_zero(affinity); 6107 kcpuset_set(affinity, cpu_id % ncpu); 6108 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 6109 NULL); 6110 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 6111 intrstr); 6112 if (error == 0) { 6113 #if 1 /* def IXGBE_DEBUG */ 6114 #ifdef RSS 6115 aprintf_normal(", bound RSS bucket %d to CPU %d", i, 6116 cpu_id % ncpu); 6117 #else 6118 aprint_normal(", bound queue %d to cpu %d", i, 6119 cpu_id % ncpu); 6120 #endif 6121 #endif /* IXGBE_DEBUG */ 6122 } 6123 aprint_normal("\n"); 6124 6125 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6126 txr->txr_si = softint_establish( 6127 SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6128 ixgbe_deferred_mq_start, txr); 6129 if (txr->txr_si == NULL) { 6130 aprint_error_dev(dev, 6131 "couldn't establish software interrupt\n"); 6132 error = ENXIO; 6133 goto err_out; 6134 } 6135 } 6136 que->que_si 6137 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6138 ixgbe_handle_que, que); 6139 if (que->que_si == NULL) { 6140 aprint_error_dev(dev, 6141 "couldn't establish software interrupt\n"); 6142 error = ENXIO; 6143 goto err_out; 6144 } 6145 } 6146 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6147 error = workqueue_create(&adapter->txr_wq, wqname, 6148 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6149 IXGBE_WORKQUEUE_FLAGS); 6150 if (error) { 6151 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 6152 goto err_out; 6153 } 6154 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6155 6156 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6157 error = workqueue_create(&adapter->que_wq, wqname, 6158 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6159 IXGBE_WORKQUEUE_FLAGS); 6160 if (error) { 6161 aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n"); 6162 goto err_out; 6163 } 6164 6165 /* and Link */ 6166 cpu_id++; 6167 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 6168 adapter->vector = vector; 6169 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 6170 sizeof(intrbuf)); 6171 #ifdef IXGBE_MPSAFE 6172 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 6173 true); 6174 #endif 6175 /* Set the link handler function */ 6176 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 6177 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_link, adapter, 6178 intr_xname); 6179 if (adapter->osdep.ihs[vector] == NULL) { 6180 adapter->res = NULL; 6181 aprint_error_dev(dev, "Failed to register LINK handler\n"); 6182 error = ENXIO; 6183 goto err_out; 6184 } 6185 /* Round-robin affinity */ 6186 kcpuset_zero(affinity); 6187 kcpuset_set(affinity, cpu_id % ncpu); 6188 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 6189 NULL); 6190 6191 aprint_normal_dev(dev, 6192 "for link, interrupting at %s", intrstr); 6193 if (error == 0) 6194 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 6195 else 6196 aprint_normal("\n"); 6197 6198 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 6199 adapter->mbx_si = 6200 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6201 ixgbe_handle_mbx, adapter); 6202 if (adapter->mbx_si == NULL) { 6203 aprint_error_dev(dev, 6204 "could not establish software interrupts\n"); 6205 6206 error = ENXIO; 6207 goto err_out; 6208 } 6209 } 6210 6211 kcpuset_destroy(affinity); 6212 aprint_normal_dev(dev, 6213 "Using MSI-X interrupts with %d vectors\n", vector + 1); 6214 6215 return (0); 6216 6217 err_out: 6218 kcpuset_destroy(affinity); 6219 ixgbe_free_softint(adapter); 6220 ixgbe_free_pciintr_resources(adapter); 6221 return (error); 6222 } /* ixgbe_allocate_msix */ 6223 6224 /************************************************************************ 6225 * ixgbe_configure_interrupts 6226 * 6227 * Setup MSI-X, MSI, or legacy interrupts (in that order). 6228 * This will also depend on user settings. 6229 ************************************************************************/ 6230 static int 6231 ixgbe_configure_interrupts(struct adapter *adapter) 6232 { 6233 device_t dev = adapter->dev; 6234 struct ixgbe_mac_info *mac = &adapter->hw.mac; 6235 int want, queues, msgs; 6236 6237 /* Default to 1 queue if MSI-X setup fails */ 6238 adapter->num_queues = 1; 6239 6240 /* Override by tuneable */ 6241 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) 6242 goto msi; 6243 6244 /* 6245 * NetBSD only: Use single vector MSI when number of CPU is 1 to save 6246 * interrupt slot. 6247 */ 6248 if (ncpu == 1) 6249 goto msi; 6250 6251 /* First try MSI-X */ 6252 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 6253 msgs = MIN(msgs, IXG_MAX_NINTR); 6254 if (msgs < 2) 6255 goto msi; 6256 6257 adapter->msix_mem = (void *)1; /* XXX */ 6258 6259 /* Figure out a reasonable auto config value */ 6260 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 6261 6262 #ifdef RSS 6263 /* If we're doing RSS, clamp at the number of RSS buckets */ 6264 if (adapter->feat_en & IXGBE_FEATURE_RSS) 6265 queues = min(queues, rss_getnumbuckets()); 6266 #endif 6267 if (ixgbe_num_queues > queues) { 6268 aprint_error_dev(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues); 6269 ixgbe_num_queues = queues; 6270 } 6271 6272 if (ixgbe_num_queues != 0) 6273 queues = ixgbe_num_queues; 6274 else 6275 queues = min(queues, 6276 min(mac->max_tx_queues, mac->max_rx_queues)); 6277 6278 /* reflect correct sysctl value */ 6279 ixgbe_num_queues = queues; 6280 6281 /* 6282 * Want one vector (RX/TX pair) per queue 6283 * plus an additional for Link. 6284 */ 6285 want = queues + 1; 6286 if (msgs >= want) 6287 msgs = want; 6288 else { 6289 aprint_error_dev(dev, "MSI-X Configuration Problem, " 6290 "%d vectors but %d queues wanted!\n", 6291 msgs, want); 6292 goto msi; 6293 } 6294 adapter->num_queues = queues; 6295 adapter->feat_en |= IXGBE_FEATURE_MSIX; 6296 return (0); 6297 6298 /* 6299 * MSI-X allocation failed or provided us with 6300 * less vectors than needed. Free MSI-X resources 6301 * and we'll try enabling MSI. 6302 */ 6303 msi: 6304 /* Without MSI-X, some features are no longer supported */ 6305 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6306 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6307 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6308 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6309 6310 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 6311 adapter->msix_mem = NULL; /* XXX */ 6312 if (msgs > 1) 6313 msgs = 1; 6314 if (msgs != 0) { 6315 msgs = 1; 6316 adapter->feat_en |= IXGBE_FEATURE_MSI; 6317 return (0); 6318 } 6319 6320 if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) { 6321 aprint_error_dev(dev, 6322 "Device does not support legacy interrupts.\n"); 6323 return 1; 6324 } 6325 6326 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6327 6328 return (0); 6329 } /* ixgbe_configure_interrupts */ 6330 6331 6332 /************************************************************************ 6333 * ixgbe_handle_link - Tasklet for MSI-X Link interrupts 6334 * 6335 * Done outside of interrupt context since the driver might sleep 6336 ************************************************************************/ 6337 static void 6338 ixgbe_handle_link(void *context) 6339 { 6340 struct adapter *adapter = context; 6341 struct ixgbe_hw *hw = &adapter->hw; 6342 6343 IXGBE_CORE_LOCK(adapter); 6344 6345 ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0); 6346 ixgbe_update_link_status(adapter); 6347 6348 /* Re-enable link interrupts */ 6349 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 6350 6351 IXGBE_CORE_UNLOCK(adapter); 6352 } /* ixgbe_handle_link */ 6353 6354 /************************************************************************ 6355 * ixgbe_rearm_queues 6356 ************************************************************************/ 6357 static void 6358 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 6359 { 6360 u32 mask; 6361 6362 switch (adapter->hw.mac.type) { 6363 case ixgbe_mac_82598EB: 6364 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 6365 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 6366 break; 6367 case ixgbe_mac_82599EB: 6368 case ixgbe_mac_X540: 6369 case ixgbe_mac_X550: 6370 case ixgbe_mac_X550EM_x: 6371 case ixgbe_mac_X550EM_a: 6372 mask = (queues & 0xFFFFFFFF); 6373 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 6374 mask = (queues >> 32); 6375 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 6376 break; 6377 default: 6378 break; 6379 } 6380 } /* ixgbe_rearm_queues */ 6381
Indexes created Thu Oct 23 22:10:10 GMT 2025