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