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