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