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