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