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