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