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