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