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