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