ixgbe.c revision 1.230
1 /* $NetBSD: ixgbe.c,v 1.230 2020/06/12 09:28:48 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_SOFTINT_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_SOFTINT_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 INIT_DEBUGOUT("ixgbe_initialize_transmit_units"); 681 682 /* Setup the Base and Length of the Tx Descriptor Ring */ 683 for (i = 0; i < adapter->num_queues; i++, txr++) { 684 u64 tdba = txr->txdma.dma_paddr; 685 u32 txctrl = 0; 686 u32 tqsmreg, reg; 687 int regnum = i / 4; /* 1 register per 4 queues */ 688 int regshift = i % 4; /* 4 bits per 1 queue */ 689 int j = txr->me; 690 691 IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j), 692 (tdba & 0x00000000ffffffffULL)); 693 IXGBE_WRITE_REG(hw, IXGBE_TDBAH(j), (tdba >> 32)); 694 IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), 695 adapter->num_tx_desc * sizeof(union ixgbe_adv_tx_desc)); 696 697 /* 698 * Set TQSMR (Transmit Queue Statistic Mapping) register. 699 * Register location is different between 82598 and others. 700 */ 701 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 702 tqsmreg = IXGBE_TQSMR(regnum); 703 else 704 tqsmreg = IXGBE_TQSM(regnum); 705 reg = IXGBE_READ_REG(hw, tqsmreg); 706 reg &= ~(0x000000ffUL << (regshift * 8)); 707 reg |= i << (regshift * 8); 708 IXGBE_WRITE_REG(hw, tqsmreg, reg); 709 710 /* Setup the HW Tx Head and Tail descriptor pointers */ 711 IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0); 712 IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0); 713 714 /* Cache the tail address */ 715 txr->tail = IXGBE_TDT(j); 716 717 txr->txr_no_space = false; 718 719 /* Disable Head Writeback */ 720 /* 721 * Note: for X550 series devices, these registers are actually 722 * prefixed with TPH_ isntead of DCA_, but the addresses and 723 * fields remain the same. 724 */ 725 switch (hw->mac.type) { 726 case ixgbe_mac_82598EB: 727 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j)); 728 break; 729 default: 730 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(j)); 731 break; 732 } 733 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 734 switch (hw->mac.type) { 735 case ixgbe_mac_82598EB: 736 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl); 737 break; 738 default: 739 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(j), txctrl); 740 break; 741 } 742 743 } 744 745 if (hw->mac.type != ixgbe_mac_82598EB) { 746 u32 dmatxctl, rttdcs; 747 748 dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL); 749 dmatxctl |= IXGBE_DMATXCTL_TE; 750 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl); 751 /* Disable arbiter to set MTQC */ 752 rttdcs = IXGBE_READ_REG(hw, IXGBE_RTTDCS); 753 rttdcs |= IXGBE_RTTDCS_ARBDIS; 754 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 755 IXGBE_WRITE_REG(hw, IXGBE_MTQC, 756 ixgbe_get_mtqc(adapter->iov_mode)); 757 rttdcs &= ~IXGBE_RTTDCS_ARBDIS; 758 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 759 } 760 761 return; 762 } /* ixgbe_initialize_transmit_units */ 763 764 /************************************************************************ 765 * ixgbe_attach - Device initialization routine 766 * 767 * Called when the driver is being loaded. 768 * Identifies the type of hardware, allocates all resources 769 * and initializes the hardware. 770 * 771 * return 0 on success, positive on failure 772 ************************************************************************/ 773 static void 774 ixgbe_attach(device_t parent, device_t dev, void *aux) 775 { 776 struct adapter *adapter; 777 struct ixgbe_hw *hw; 778 int error = -1; 779 u32 ctrl_ext; 780 u16 high, low, nvmreg; 781 pcireg_t id, subid; 782 const ixgbe_vendor_info_t *ent; 783 struct pci_attach_args *pa = aux; 784 bool unsupported_sfp = false; 785 const char *str; 786 char buf[256]; 787 788 INIT_DEBUGOUT("ixgbe_attach: begin"); 789 790 /* Allocate, clear, and link in our adapter structure */ 791 adapter = device_private(dev); 792 adapter->hw.back = adapter; 793 adapter->dev = dev; 794 hw = &adapter->hw; 795 adapter->osdep.pc = pa->pa_pc; 796 adapter->osdep.tag = pa->pa_tag; 797 if (pci_dma64_available(pa)) 798 adapter->osdep.dmat = pa->pa_dmat64; 799 else 800 adapter->osdep.dmat = pa->pa_dmat; 801 adapter->osdep.attached = false; 802 803 ent = ixgbe_lookup(pa); 804 805 KASSERT(ent != NULL); 806 807 aprint_normal(": %s, Version - %s\n", 808 ixgbe_strings[ent->index], ixgbe_driver_version); 809 810 /* Core Lock Init*/ 811 IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev)); 812 813 /* Set up the timer callout */ 814 callout_init(&adapter->timer, IXGBE_CALLOUT_FLAGS); 815 816 /* Determine hardware revision */ 817 id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG); 818 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 819 820 hw->vendor_id = PCI_VENDOR(id); 821 hw->device_id = PCI_PRODUCT(id); 822 hw->revision_id = 823 PCI_REVISION(pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG)); 824 hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid); 825 hw->subsystem_device_id = PCI_SUBSYS_ID(subid); 826 827 /* 828 * Make sure BUSMASTER is set 829 */ 830 ixgbe_pci_enable_busmaster(pa->pa_pc, pa->pa_tag); 831 832 /* Do base PCI setup - map BAR0 */ 833 if (ixgbe_allocate_pci_resources(adapter, pa)) { 834 aprint_error_dev(dev, "Allocation of PCI resources failed\n"); 835 error = ENXIO; 836 goto err_out; 837 } 838 839 /* let hardware know driver is loaded */ 840 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 841 ctrl_ext |= IXGBE_CTRL_EXT_DRV_LOAD; 842 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 843 844 /* 845 * Initialize the shared code 846 */ 847 if (ixgbe_init_shared_code(hw) != 0) { 848 aprint_error_dev(dev, "Unable to initialize the shared code\n"); 849 error = ENXIO; 850 goto err_out; 851 } 852 853 switch (hw->mac.type) { 854 case ixgbe_mac_82598EB: 855 str = "82598EB"; 856 break; 857 case ixgbe_mac_82599EB: 858 str = "82599EB"; 859 break; 860 case ixgbe_mac_X540: 861 str = "X540"; 862 break; 863 case ixgbe_mac_X550: 864 str = "X550"; 865 break; 866 case ixgbe_mac_X550EM_x: 867 str = "X550EM"; 868 break; 869 case ixgbe_mac_X550EM_a: 870 str = "X550EM A"; 871 break; 872 default: 873 str = "Unknown"; 874 break; 875 } 876 aprint_normal_dev(dev, "device %s\n", str); 877 878 if (hw->mbx.ops.init_params) 879 hw->mbx.ops.init_params(hw); 880 881 hw->allow_unsupported_sfp = allow_unsupported_sfp; 882 883 /* Pick up the 82599 settings */ 884 if (hw->mac.type != ixgbe_mac_82598EB) { 885 hw->phy.smart_speed = ixgbe_smart_speed; 886 adapter->num_segs = IXGBE_82599_SCATTER; 887 } else 888 adapter->num_segs = IXGBE_82598_SCATTER; 889 890 /* Ensure SW/FW semaphore is free */ 891 ixgbe_init_swfw_semaphore(hw); 892 893 hw->mac.ops.set_lan_id(hw); 894 ixgbe_init_device_features(adapter); 895 896 if (ixgbe_configure_interrupts(adapter)) { 897 error = ENXIO; 898 goto err_out; 899 } 900 901 /* Allocate multicast array memory. */ 902 adapter->mta = malloc(sizeof(*adapter->mta) * 903 MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_WAITOK); 904 905 /* Enable WoL (if supported) */ 906 ixgbe_check_wol_support(adapter); 907 908 /* Register for VLAN events */ 909 ether_set_vlan_cb(&adapter->osdep.ec, ixgbe_vlan_cb); 910 911 /* Verify adapter fan is still functional (if applicable) */ 912 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 913 u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 914 ixgbe_check_fan_failure(adapter, esdp, FALSE); 915 } 916 917 /* Set an initial default flow control value */ 918 hw->fc.requested_mode = ixgbe_flow_control; 919 920 /* Sysctls for limiting the amount of work done in the taskqueues */ 921 ixgbe_set_sysctl_value(adapter, "rx_processing_limit", 922 "max number of rx packets to process", 923 &adapter->rx_process_limit, ixgbe_rx_process_limit); 924 925 ixgbe_set_sysctl_value(adapter, "tx_processing_limit", 926 "max number of tx packets to process", 927 &adapter->tx_process_limit, ixgbe_tx_process_limit); 928 929 /* Do descriptor calc and sanity checks */ 930 if (((ixgbe_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 || 931 ixgbe_txd < MIN_TXD || ixgbe_txd > MAX_TXD) { 932 aprint_error_dev(dev, "TXD config issue, using default!\n"); 933 adapter->num_tx_desc = DEFAULT_TXD; 934 } else 935 adapter->num_tx_desc = ixgbe_txd; 936 937 if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 || 938 ixgbe_rxd < MIN_RXD || ixgbe_rxd > MAX_RXD) { 939 aprint_error_dev(dev, "RXD config issue, using default!\n"); 940 adapter->num_rx_desc = DEFAULT_RXD; 941 } else 942 adapter->num_rx_desc = ixgbe_rxd; 943 944 /* Allocate our TX/RX Queues */ 945 if (ixgbe_allocate_queues(adapter)) { 946 error = ENOMEM; 947 goto err_out; 948 } 949 950 hw->phy.reset_if_overtemp = TRUE; 951 error = ixgbe_reset_hw(hw); 952 hw->phy.reset_if_overtemp = FALSE; 953 if (error == IXGBE_ERR_SFP_NOT_PRESENT) { 954 /* 955 * No optics in this port, set up 956 * so the timer routine will probe 957 * for later insertion. 958 */ 959 adapter->sfp_probe = TRUE; 960 error = IXGBE_SUCCESS; 961 } else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) { 962 aprint_error_dev(dev, "Unsupported SFP+ module detected!\n"); 963 unsupported_sfp = true; 964 error = IXGBE_SUCCESS; 965 } else if (error) { 966 aprint_error_dev(dev, "Hardware initialization failed\n"); 967 error = EIO; 968 goto err_late; 969 } 970 971 /* Make sure we have a good EEPROM before we read from it */ 972 if (ixgbe_validate_eeprom_checksum(&adapter->hw, NULL) < 0) { 973 aprint_error_dev(dev, "The EEPROM Checksum Is Not Valid\n"); 974 error = EIO; 975 goto err_late; 976 } 977 978 aprint_normal("%s:", device_xname(dev)); 979 /* NVM Image Version */ 980 high = low = 0; 981 switch (hw->mac.type) { 982 case ixgbe_mac_X540: 983 case ixgbe_mac_X550EM_a: 984 hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg); 985 if (nvmreg == 0xffff) 986 break; 987 high = (nvmreg >> 12) & 0x0f; 988 low = (nvmreg >> 4) & 0xff; 989 id = nvmreg & 0x0f; 990 aprint_normal(" NVM Image Version %u.", high); 991 if (hw->mac.type == ixgbe_mac_X540) 992 str = "%x"; 993 else 994 str = "%02x"; 995 aprint_normal(str, low); 996 aprint_normal(" ID 0x%x,", id); 997 break; 998 case ixgbe_mac_X550EM_x: 999 case ixgbe_mac_X550: 1000 hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg); 1001 if (nvmreg == 0xffff) 1002 break; 1003 high = (nvmreg >> 12) & 0x0f; 1004 low = nvmreg & 0xff; 1005 aprint_normal(" NVM Image Version %u.%02x,", high, low); 1006 break; 1007 default: 1008 break; 1009 } 1010 hw->eeprom.nvm_image_ver_high = high; 1011 hw->eeprom.nvm_image_ver_low = low; 1012 1013 /* PHY firmware revision */ 1014 switch (hw->mac.type) { 1015 case ixgbe_mac_X540: 1016 case ixgbe_mac_X550: 1017 hw->eeprom.ops.read(hw, IXGBE_PHYFW_REV, &nvmreg); 1018 if (nvmreg == 0xffff) 1019 break; 1020 high = (nvmreg >> 12) & 0x0f; 1021 low = (nvmreg >> 4) & 0xff; 1022 id = nvmreg & 0x000f; 1023 aprint_normal(" PHY FW Revision %u.", high); 1024 if (hw->mac.type == ixgbe_mac_X540) 1025 str = "%x"; 1026 else 1027 str = "%02x"; 1028 aprint_normal(str, low); 1029 aprint_normal(" ID 0x%x,", id); 1030 break; 1031 default: 1032 break; 1033 } 1034 1035 /* NVM Map version & OEM NVM Image version */ 1036 switch (hw->mac.type) { 1037 case ixgbe_mac_X550: 1038 case ixgbe_mac_X550EM_x: 1039 case ixgbe_mac_X550EM_a: 1040 hw->eeprom.ops.read(hw, IXGBE_NVM_MAP_VER, &nvmreg); 1041 if (nvmreg != 0xffff) { 1042 high = (nvmreg >> 12) & 0x0f; 1043 low = nvmreg & 0x00ff; 1044 aprint_normal(" NVM Map version %u.%02x,", high, low); 1045 } 1046 hw->eeprom.ops.read(hw, IXGBE_OEM_NVM_IMAGE_VER, &nvmreg); 1047 if (nvmreg != 0xffff) { 1048 high = (nvmreg >> 12) & 0x0f; 1049 low = nvmreg & 0x00ff; 1050 aprint_verbose(" OEM NVM Image version %u.%02x,", high, 1051 low); 1052 } 1053 break; 1054 default: 1055 break; 1056 } 1057 1058 /* Print the ETrackID */ 1059 hw->eeprom.ops.read(hw, IXGBE_ETRACKID_H, &high); 1060 hw->eeprom.ops.read(hw, IXGBE_ETRACKID_L, &low); 1061 aprint_normal(" ETrackID %08x\n", ((uint32_t)high << 16) | low); 1062 1063 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 1064 error = ixgbe_allocate_msix(adapter, pa); 1065 if (error) { 1066 /* Free allocated queue structures first */ 1067 ixgbe_free_queues(adapter); 1068 1069 /* Fallback to legacy interrupt */ 1070 adapter->feat_en &= ~IXGBE_FEATURE_MSIX; 1071 if (adapter->feat_cap & IXGBE_FEATURE_MSI) 1072 adapter->feat_en |= IXGBE_FEATURE_MSI; 1073 adapter->num_queues = 1; 1074 1075 /* Allocate our TX/RX Queues again */ 1076 if (ixgbe_allocate_queues(adapter)) { 1077 error = ENOMEM; 1078 goto err_out; 1079 } 1080 } 1081 } 1082 /* Recovery mode */ 1083 switch (adapter->hw.mac.type) { 1084 case ixgbe_mac_X550: 1085 case ixgbe_mac_X550EM_x: 1086 case ixgbe_mac_X550EM_a: 1087 /* >= 2.00 */ 1088 if (hw->eeprom.nvm_image_ver_high >= 2) { 1089 adapter->feat_cap |= IXGBE_FEATURE_RECOVERY_MODE; 1090 adapter->feat_en |= IXGBE_FEATURE_RECOVERY_MODE; 1091 } 1092 break; 1093 default: 1094 break; 1095 } 1096 1097 if ((adapter->feat_en & IXGBE_FEATURE_MSIX) == 0) 1098 error = ixgbe_allocate_legacy(adapter, pa); 1099 if (error) 1100 goto err_late; 1101 1102 /* Tasklets for Link, SFP, Multispeed Fiber and Flow Director */ 1103 adapter->link_si = softint_establish(SOFTINT_NET |IXGBE_SOFTINT_FLAGS, 1104 ixgbe_handle_link, adapter); 1105 adapter->mod_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 1106 ixgbe_handle_mod, adapter); 1107 adapter->phy_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 1108 ixgbe_handle_phy, adapter); 1109 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 1110 adapter->fdir_si = 1111 softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 1112 ixgbe_reinit_fdir, adapter); 1113 if ((adapter->link_si == NULL) || (adapter->mod_si == NULL) 1114 || (adapter->phy_si == NULL) 1115 || ((adapter->feat_en & IXGBE_FEATURE_FDIR) 1116 && (adapter->fdir_si == NULL))) { 1117 aprint_error_dev(dev, 1118 "could not establish software interrupts ()\n"); 1119 goto err_out; 1120 } 1121 char wqname[MAXCOMLEN]; 1122 snprintf(wqname, sizeof(wqname), "%s-msf", device_xname(dev)); 1123 error = workqueue_create(&adapter->msf_wq, wqname, 1124 ixgbe_handle_msf, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 1125 IXGBE_TASKLET_WQ_FLAGS); 1126 if (error) { 1127 aprint_error_dev(dev, 1128 "could not create MSF workqueue (%d)\n", error); 1129 goto err_out; 1130 } 1131 1132 error = ixgbe_start_hw(hw); 1133 switch (error) { 1134 case IXGBE_ERR_EEPROM_VERSION: 1135 aprint_error_dev(dev, "This device is a pre-production adapter/" 1136 "LOM. Please be aware there may be issues associated " 1137 "with your hardware.\nIf you are experiencing problems " 1138 "please contact your Intel or hardware representative " 1139 "who provided you with this hardware.\n"); 1140 break; 1141 default: 1142 break; 1143 } 1144 1145 /* Setup OS specific network interface */ 1146 if (ixgbe_setup_interface(dev, adapter) != 0) 1147 goto err_late; 1148 1149 /* 1150 * Print PHY ID only for copper PHY. On device which has SFP(+) cage 1151 * and a module is inserted, phy.id is not MII PHY id but SFF 8024 ID. 1152 */ 1153 if (hw->phy.media_type == ixgbe_media_type_copper) { 1154 uint16_t id1, id2; 1155 int oui, model, rev; 1156 const char *descr; 1157 1158 id1 = hw->phy.id >> 16; 1159 id2 = hw->phy.id & 0xffff; 1160 oui = MII_OUI(id1, id2); 1161 model = MII_MODEL(id2); 1162 rev = MII_REV(id2); 1163 if ((descr = mii_get_descr(oui, model)) != NULL) 1164 aprint_normal_dev(dev, 1165 "PHY: %s (OUI 0x%06x, model 0x%04x), rev. %d\n", 1166 descr, oui, model, rev); 1167 else 1168 aprint_normal_dev(dev, 1169 "PHY OUI 0x%06x, model 0x%04x, rev. %d\n", 1170 oui, model, rev); 1171 } 1172 1173 /* Enable EEE power saving */ 1174 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 1175 hw->mac.ops.setup_eee(hw, 1176 adapter->feat_en & IXGBE_FEATURE_EEE); 1177 1178 /* Enable power to the phy. */ 1179 if (!unsupported_sfp) { 1180 /* Enable the optics for 82599 SFP+ fiber */ 1181 ixgbe_enable_tx_laser(hw); 1182 1183 /* 1184 * XXX Currently, ixgbe_set_phy_power() supports only copper 1185 * PHY, so it's not required to test with !unsupported_sfp. 1186 */ 1187 ixgbe_set_phy_power(hw, TRUE); 1188 } 1189 1190 /* Initialize statistics */ 1191 ixgbe_update_stats_counters(adapter); 1192 1193 /* Check PCIE slot type/speed/width */ 1194 ixgbe_get_slot_info(adapter); 1195 1196 /* 1197 * Do time init and sysctl init here, but 1198 * only on the first port of a bypass adapter. 1199 */ 1200 ixgbe_bypass_init(adapter); 1201 1202 /* Set an initial dmac value */ 1203 adapter->dmac = 0; 1204 /* Set initial advertised speeds (if applicable) */ 1205 adapter->advertise = ixgbe_get_advertise(adapter); 1206 1207 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 1208 ixgbe_define_iov_schemas(dev, &error); 1209 1210 /* Add sysctls */ 1211 ixgbe_add_device_sysctls(adapter); 1212 ixgbe_add_hw_stats(adapter); 1213 1214 /* For Netmap */ 1215 adapter->init_locked = ixgbe_init_locked; 1216 adapter->stop_locked = ixgbe_stop; 1217 1218 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 1219 ixgbe_netmap_attach(adapter); 1220 1221 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_cap); 1222 aprint_verbose_dev(dev, "feature cap %s\n", buf); 1223 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_en); 1224 aprint_verbose_dev(dev, "feature ena %s\n", buf); 1225 1226 if (pmf_device_register(dev, ixgbe_suspend, ixgbe_resume)) 1227 pmf_class_network_register(dev, adapter->ifp); 1228 else 1229 aprint_error_dev(dev, "couldn't establish power handler\n"); 1230 1231 /* Init recovery mode timer and state variable */ 1232 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) { 1233 adapter->recovery_mode = 0; 1234 1235 /* Set up the timer callout */ 1236 callout_init(&adapter->recovery_mode_timer, 1237 IXGBE_CALLOUT_FLAGS); 1238 1239 /* Start the task */ 1240 callout_reset(&adapter->recovery_mode_timer, hz, 1241 ixgbe_recovery_mode_timer, adapter); 1242 } 1243 1244 INIT_DEBUGOUT("ixgbe_attach: end"); 1245 adapter->osdep.attached = true; 1246 1247 return; 1248 1249 err_late: 1250 ixgbe_free_queues(adapter); 1251 err_out: 1252 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 1253 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 1254 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 1255 ixgbe_free_softint(adapter); 1256 ixgbe_free_pci_resources(adapter); 1257 if (adapter->mta != NULL) 1258 free(adapter->mta, M_DEVBUF); 1259 IXGBE_CORE_LOCK_DESTROY(adapter); 1260 1261 return; 1262 } /* ixgbe_attach */ 1263 1264 /************************************************************************ 1265 * ixgbe_check_wol_support 1266 * 1267 * Checks whether the adapter's ports are capable of 1268 * Wake On LAN by reading the adapter's NVM. 1269 * 1270 * Sets each port's hw->wol_enabled value depending 1271 * on the value read here. 1272 ************************************************************************/ 1273 static void 1274 ixgbe_check_wol_support(struct adapter *adapter) 1275 { 1276 struct ixgbe_hw *hw = &adapter->hw; 1277 u16 dev_caps = 0; 1278 1279 /* Find out WoL support for port */ 1280 adapter->wol_support = hw->wol_enabled = 0; 1281 ixgbe_get_device_caps(hw, &dev_caps); 1282 if ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0_1) || 1283 ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0) && 1284 hw->bus.func == 0)) 1285 adapter->wol_support = hw->wol_enabled = 1; 1286 1287 /* Save initial wake up filter configuration */ 1288 adapter->wufc = IXGBE_READ_REG(hw, IXGBE_WUFC); 1289 1290 return; 1291 } /* ixgbe_check_wol_support */ 1292 1293 /************************************************************************ 1294 * ixgbe_setup_interface 1295 * 1296 * Setup networking device structure and register an interface. 1297 ************************************************************************/ 1298 static int 1299 ixgbe_setup_interface(device_t dev, struct adapter *adapter) 1300 { 1301 struct ethercom *ec = &adapter->osdep.ec; 1302 struct ifnet *ifp; 1303 int rv; 1304 1305 INIT_DEBUGOUT("ixgbe_setup_interface: begin"); 1306 1307 ifp = adapter->ifp = &ec->ec_if; 1308 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 1309 ifp->if_baudrate = IF_Gbps(10); 1310 ifp->if_init = ixgbe_init; 1311 ifp->if_stop = ixgbe_ifstop; 1312 ifp->if_softc = adapter; 1313 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1314 #ifdef IXGBE_MPSAFE 1315 ifp->if_extflags = IFEF_MPSAFE; 1316 #endif 1317 ifp->if_ioctl = ixgbe_ioctl; 1318 #if __FreeBSD_version >= 1100045 1319 /* TSO parameters */ 1320 ifp->if_hw_tsomax = 65518; 1321 ifp->if_hw_tsomaxsegcount = IXGBE_82599_SCATTER; 1322 ifp->if_hw_tsomaxsegsize = 2048; 1323 #endif 1324 if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) { 1325 #if 0 1326 ixgbe_start_locked = ixgbe_legacy_start_locked; 1327 #endif 1328 } else { 1329 ifp->if_transmit = ixgbe_mq_start; 1330 #if 0 1331 ixgbe_start_locked = ixgbe_mq_start_locked; 1332 #endif 1333 } 1334 ifp->if_start = ixgbe_legacy_start; 1335 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 1336 IFQ_SET_READY(&ifp->if_snd); 1337 1338 rv = if_initialize(ifp); 1339 if (rv != 0) { 1340 aprint_error_dev(dev, "if_initialize failed(%d)\n", rv); 1341 return rv; 1342 } 1343 adapter->ipq = if_percpuq_create(&adapter->osdep.ec.ec_if); 1344 ether_ifattach(ifp, adapter->hw.mac.addr); 1345 aprint_normal_dev(dev, "Ethernet address %s\n", 1346 ether_sprintf(adapter->hw.mac.addr)); 1347 /* 1348 * We use per TX queue softint, so if_deferred_start_init() isn't 1349 * used. 1350 */ 1351 ether_set_ifflags_cb(ec, ixgbe_ifflags_cb); 1352 1353 adapter->max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 1354 1355 /* 1356 * Tell the upper layer(s) we support long frames. 1357 */ 1358 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 1359 1360 /* Set capability flags */ 1361 ifp->if_capabilities |= IFCAP_RXCSUM 1362 | IFCAP_TXCSUM 1363 | IFCAP_TSOv4 1364 | IFCAP_TSOv6; 1365 ifp->if_capenable = 0; 1366 1367 ec->ec_capabilities |= ETHERCAP_VLAN_HWTAGGING 1368 | ETHERCAP_VLAN_HWCSUM 1369 | ETHERCAP_JUMBO_MTU 1370 | ETHERCAP_VLAN_MTU; 1371 1372 /* Enable the above capabilities by default */ 1373 ec->ec_capenable = ec->ec_capabilities; 1374 1375 /* 1376 * Don't turn this on by default, if vlans are 1377 * created on another pseudo device (eg. lagg) 1378 * then vlan events are not passed thru, breaking 1379 * operation, but with HW FILTER off it works. If 1380 * using vlans directly on the ixgbe driver you can 1381 * enable this and get full hardware tag filtering. 1382 */ 1383 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER; 1384 1385 /* 1386 * Specify the media types supported by this adapter and register 1387 * callbacks to update media and link information 1388 */ 1389 ec->ec_ifmedia = &adapter->media; 1390 ifmedia_init_with_lock(&adapter->media, IFM_IMASK, ixgbe_media_change, 1391 ixgbe_media_status, &adapter->core_mtx); 1392 1393 adapter->phy_layer = ixgbe_get_supported_physical_layer(&adapter->hw); 1394 ixgbe_add_media_types(adapter); 1395 1396 /* Set autoselect media by default */ 1397 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1398 1399 if_register(ifp); 1400 1401 return (0); 1402 } /* ixgbe_setup_interface */ 1403 1404 /************************************************************************ 1405 * ixgbe_add_media_types 1406 ************************************************************************/ 1407 static void 1408 ixgbe_add_media_types(struct adapter *adapter) 1409 { 1410 struct ixgbe_hw *hw = &adapter->hw; 1411 u64 layer; 1412 1413 layer = adapter->phy_layer; 1414 1415 #define ADD(mm, dd) \ 1416 ifmedia_add(&adapter->media, IFM_ETHER | (mm), (dd), NULL); 1417 1418 ADD(IFM_NONE, 0); 1419 1420 /* Media types with matching NetBSD media defines */ 1421 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T) { 1422 ADD(IFM_10G_T | IFM_FDX, 0); 1423 } 1424 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T) { 1425 ADD(IFM_1000_T | IFM_FDX, 0); 1426 } 1427 if (layer & IXGBE_PHYSICAL_LAYER_100BASE_TX) { 1428 ADD(IFM_100_TX | IFM_FDX, 0); 1429 } 1430 if (layer & IXGBE_PHYSICAL_LAYER_10BASE_T) { 1431 ADD(IFM_10_T | IFM_FDX, 0); 1432 } 1433 1434 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 1435 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) { 1436 ADD(IFM_10G_TWINAX | IFM_FDX, 0); 1437 } 1438 1439 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) { 1440 ADD(IFM_10G_LR | IFM_FDX, 0); 1441 if (hw->phy.multispeed_fiber) { 1442 ADD(IFM_1000_LX | IFM_FDX, 0); 1443 } 1444 } 1445 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) { 1446 ADD(IFM_10G_SR | IFM_FDX, 0); 1447 if (hw->phy.multispeed_fiber) { 1448 ADD(IFM_1000_SX | IFM_FDX, 0); 1449 } 1450 } else if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) { 1451 ADD(IFM_1000_SX | IFM_FDX, 0); 1452 } 1453 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) { 1454 ADD(IFM_10G_CX4 | IFM_FDX, 0); 1455 } 1456 1457 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) { 1458 ADD(IFM_10G_KR | IFM_FDX, 0); 1459 } 1460 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) { 1461 ADD(IFM_10G_KX4 | IFM_FDX, 0); 1462 } 1463 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) { 1464 ADD(IFM_1000_KX | IFM_FDX, 0); 1465 } 1466 if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX) { 1467 ADD(IFM_2500_KX | IFM_FDX, 0); 1468 } 1469 if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_T) { 1470 ADD(IFM_2500_T | IFM_FDX, 0); 1471 } 1472 if (layer & IXGBE_PHYSICAL_LAYER_5GBASE_T) { 1473 ADD(IFM_5000_T | IFM_FDX, 0); 1474 } 1475 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_BX) 1476 ADD(IFM_1000_BX10 | IFM_FDX, 0); 1477 /* XXX no ifmedia_set? */ 1478 1479 ADD(IFM_AUTO, 0); 1480 1481 #undef ADD 1482 } /* ixgbe_add_media_types */ 1483 1484 /************************************************************************ 1485 * ixgbe_is_sfp 1486 ************************************************************************/ 1487 static inline bool 1488 ixgbe_is_sfp(struct ixgbe_hw *hw) 1489 { 1490 switch (hw->mac.type) { 1491 case ixgbe_mac_82598EB: 1492 if (hw->phy.type == ixgbe_phy_nl) 1493 return (TRUE); 1494 return (FALSE); 1495 case ixgbe_mac_82599EB: 1496 case ixgbe_mac_X550EM_x: 1497 case ixgbe_mac_X550EM_a: 1498 switch (hw->mac.ops.get_media_type(hw)) { 1499 case ixgbe_media_type_fiber: 1500 case ixgbe_media_type_fiber_qsfp: 1501 return (TRUE); 1502 default: 1503 return (FALSE); 1504 } 1505 default: 1506 return (FALSE); 1507 } 1508 } /* ixgbe_is_sfp */ 1509 1510 static void 1511 ixgbe_schedule_msf_tasklet(struct adapter *adapter) 1512 { 1513 if (adapter->schedule_wqs_ok) { 1514 if (!adapter->msf_pending) { 1515 adapter->msf_pending = true; 1516 workqueue_enqueue(adapter->msf_wq, 1517 &adapter->msf_wc, NULL); 1518 } 1519 } 1520 } 1521 1522 /************************************************************************ 1523 * ixgbe_config_link 1524 ************************************************************************/ 1525 static void 1526 ixgbe_config_link(struct adapter *adapter) 1527 { 1528 struct ixgbe_hw *hw = &adapter->hw; 1529 u32 autoneg, err = 0; 1530 bool sfp, negotiate = false; 1531 1532 sfp = ixgbe_is_sfp(hw); 1533 1534 if (sfp) { 1535 if (hw->phy.multispeed_fiber) { 1536 ixgbe_enable_tx_laser(hw); 1537 kpreempt_disable(); 1538 ixgbe_schedule_msf_tasklet(adapter); 1539 kpreempt_enable(); 1540 } 1541 softint_schedule(adapter->mod_si); 1542 } else { 1543 struct ifmedia *ifm = &adapter->media; 1544 1545 if (hw->mac.ops.check_link) 1546 err = ixgbe_check_link(hw, &adapter->link_speed, 1547 &adapter->link_up, FALSE); 1548 if (err) 1549 return; 1550 1551 /* 1552 * Check if it's the first call. If it's the first call, 1553 * get value for auto negotiation. 1554 */ 1555 autoneg = hw->phy.autoneg_advertised; 1556 if ((IFM_SUBTYPE(ifm->ifm_cur->ifm_media) != IFM_NONE) 1557 && ((!autoneg) && (hw->mac.ops.get_link_capabilities))) 1558 err = hw->mac.ops.get_link_capabilities(hw, &autoneg, 1559 &negotiate); 1560 if (err) 1561 return; 1562 if (hw->mac.ops.setup_link) 1563 err = hw->mac.ops.setup_link(hw, autoneg, 1564 adapter->link_up); 1565 } 1566 1567 } /* ixgbe_config_link */ 1568 1569 /************************************************************************ 1570 * ixgbe_update_stats_counters - Update board statistics counters. 1571 ************************************************************************/ 1572 static void 1573 ixgbe_update_stats_counters(struct adapter *adapter) 1574 { 1575 struct ifnet *ifp = adapter->ifp; 1576 struct ixgbe_hw *hw = &adapter->hw; 1577 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1578 u32 missed_rx = 0, bprc, lxon, lxoff, total; 1579 u64 total_missed_rx = 0; 1580 uint64_t crcerrs, rlec; 1581 unsigned int queue_counters; 1582 int i; 1583 1584 crcerrs = IXGBE_READ_REG(hw, IXGBE_CRCERRS); 1585 stats->crcerrs.ev_count += crcerrs; 1586 stats->illerrc.ev_count += IXGBE_READ_REG(hw, IXGBE_ILLERRC); 1587 stats->errbc.ev_count += IXGBE_READ_REG(hw, IXGBE_ERRBC); 1588 stats->mspdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MSPDC); 1589 if (hw->mac.type >= ixgbe_mac_X550) 1590 stats->mbsdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MBSDC); 1591 1592 /* 16 registers exist */ 1593 queue_counters = uimin(__arraycount(stats->qprc), adapter->num_queues); 1594 for (i = 0; i < queue_counters; i++) { 1595 stats->qprc[i].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRC(i)); 1596 stats->qptc[i].ev_count += IXGBE_READ_REG(hw, IXGBE_QPTC(i)); 1597 if (hw->mac.type >= ixgbe_mac_82599EB) { 1598 stats->qprdc[i].ev_count 1599 += IXGBE_READ_REG(hw, IXGBE_QPRDC(i)); 1600 } 1601 } 1602 1603 /* 8 registers exist */ 1604 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 1605 uint32_t mp; 1606 1607 /* MPC */ 1608 mp = IXGBE_READ_REG(hw, IXGBE_MPC(i)); 1609 /* global total per queue */ 1610 stats->mpc[i].ev_count += mp; 1611 /* running comprehensive total for stats display */ 1612 total_missed_rx += mp; 1613 1614 if (hw->mac.type == ixgbe_mac_82598EB) 1615 stats->rnbc[i].ev_count 1616 += IXGBE_READ_REG(hw, IXGBE_RNBC(i)); 1617 1618 stats->pxontxc[i].ev_count 1619 += IXGBE_READ_REG(hw, IXGBE_PXONTXC(i)); 1620 stats->pxofftxc[i].ev_count 1621 += IXGBE_READ_REG(hw, IXGBE_PXOFFTXC(i)); 1622 if (hw->mac.type >= ixgbe_mac_82599EB) { 1623 stats->pxonrxc[i].ev_count 1624 += IXGBE_READ_REG(hw, IXGBE_PXONRXCNT(i)); 1625 stats->pxoffrxc[i].ev_count 1626 += IXGBE_READ_REG(hw, IXGBE_PXOFFRXCNT(i)); 1627 stats->pxon2offc[i].ev_count 1628 += IXGBE_READ_REG(hw, IXGBE_PXON2OFFCNT(i)); 1629 } else { 1630 stats->pxonrxc[i].ev_count 1631 += IXGBE_READ_REG(hw, IXGBE_PXONRXC(i)); 1632 stats->pxoffrxc[i].ev_count 1633 += IXGBE_READ_REG(hw, IXGBE_PXOFFRXC(i)); 1634 } 1635 } 1636 stats->mpctotal.ev_count += total_missed_rx; 1637 1638 /* Document says M[LR]FC are valid when link is up and 10Gbps */ 1639 if ((adapter->link_active == LINK_STATE_UP) 1640 && (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL)) { 1641 stats->mlfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MLFC); 1642 stats->mrfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MRFC); 1643 } 1644 rlec = IXGBE_READ_REG(hw, IXGBE_RLEC); 1645 stats->rlec.ev_count += rlec; 1646 1647 /* Hardware workaround, gprc counts missed packets */ 1648 stats->gprc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx; 1649 1650 lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC); 1651 stats->lxontxc.ev_count += lxon; 1652 lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC); 1653 stats->lxofftxc.ev_count += lxoff; 1654 total = lxon + lxoff; 1655 1656 if (hw->mac.type != ixgbe_mac_82598EB) { 1657 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCL) + 1658 ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32); 1659 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCL) + 1660 ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32) - total * ETHER_MIN_LEN; 1661 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORL) + 1662 ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32); 1663 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); 1664 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT); 1665 } else { 1666 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXC); 1667 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC); 1668 /* 82598 only has a counter in the high register */ 1669 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCH); 1670 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH) - total * ETHER_MIN_LEN; 1671 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORH); 1672 } 1673 1674 /* 1675 * Workaround: mprc hardware is incorrectly counting 1676 * broadcasts, so for now we subtract those. 1677 */ 1678 bprc = IXGBE_READ_REG(hw, IXGBE_BPRC); 1679 stats->bprc.ev_count += bprc; 1680 stats->mprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPRC) 1681 - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0); 1682 1683 stats->prc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC64); 1684 stats->prc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC127); 1685 stats->prc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC255); 1686 stats->prc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC511); 1687 stats->prc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1023); 1688 stats->prc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1522); 1689 1690 stats->gptc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPTC) - total; 1691 stats->mptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPTC) - total; 1692 stats->ptc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC64) - total; 1693 1694 stats->ruc.ev_count += IXGBE_READ_REG(hw, IXGBE_RUC); 1695 stats->rfc.ev_count += IXGBE_READ_REG(hw, IXGBE_RFC); 1696 stats->roc.ev_count += IXGBE_READ_REG(hw, IXGBE_ROC); 1697 stats->rjc.ev_count += IXGBE_READ_REG(hw, IXGBE_RJC); 1698 stats->mngprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPRC); 1699 stats->mngpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPDC); 1700 stats->mngptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPTC); 1701 stats->tpr.ev_count += IXGBE_READ_REG(hw, IXGBE_TPR); 1702 stats->tpt.ev_count += IXGBE_READ_REG(hw, IXGBE_TPT); 1703 stats->ptc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC127); 1704 stats->ptc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC255); 1705 stats->ptc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC511); 1706 stats->ptc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1023); 1707 stats->ptc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1522); 1708 stats->bptc.ev_count += IXGBE_READ_REG(hw, IXGBE_BPTC); 1709 stats->xec.ev_count += IXGBE_READ_REG(hw, IXGBE_XEC); 1710 stats->fccrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCCRC); 1711 stats->fclast.ev_count += IXGBE_READ_REG(hw, IXGBE_FCLAST); 1712 /* Only read FCOE on 82599 */ 1713 if (hw->mac.type != ixgbe_mac_82598EB) { 1714 stats->fcoerpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOERPDC); 1715 stats->fcoeprc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPRC); 1716 stats->fcoeptc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPTC); 1717 stats->fcoedwrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWRC); 1718 stats->fcoedwtc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWTC); 1719 } 1720 1721 /* 1722 * Fill out the OS statistics structure. Only RX errors are required 1723 * here because all TX counters are incremented in the TX path and 1724 * normal RX counters are prepared in ether_input(). 1725 */ 1726 net_stat_ref_t nsr = IF_STAT_GETREF(ifp); 1727 if_statadd_ref(nsr, if_iqdrops, total_missed_rx); 1728 if_statadd_ref(nsr, if_ierrors, crcerrs + rlec); 1729 IF_STAT_PUTREF(ifp); 1730 } /* ixgbe_update_stats_counters */ 1731 1732 /************************************************************************ 1733 * ixgbe_add_hw_stats 1734 * 1735 * Add sysctl variables, one per statistic, to the system. 1736 ************************************************************************/ 1737 static void 1738 ixgbe_add_hw_stats(struct adapter *adapter) 1739 { 1740 device_t dev = adapter->dev; 1741 const struct sysctlnode *rnode, *cnode; 1742 struct sysctllog **log = &adapter->sysctllog; 1743 struct tx_ring *txr = adapter->tx_rings; 1744 struct rx_ring *rxr = adapter->rx_rings; 1745 struct ixgbe_hw *hw = &adapter->hw; 1746 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1747 const char *xname = device_xname(dev); 1748 int i; 1749 1750 /* Driver Statistics */ 1751 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 1752 NULL, xname, "Driver tx dma soft fail EFBIG"); 1753 evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC, 1754 NULL, xname, "m_defrag() failed"); 1755 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 1756 NULL, xname, "Driver tx dma hard fail EFBIG"); 1757 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 1758 NULL, xname, "Driver tx dma hard fail EINVAL"); 1759 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 1760 NULL, xname, "Driver tx dma hard fail other"); 1761 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 1762 NULL, xname, "Driver tx dma soft fail EAGAIN"); 1763 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 1764 NULL, xname, "Driver tx dma soft fail ENOMEM"); 1765 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 1766 NULL, xname, "Watchdog timeouts"); 1767 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 1768 NULL, xname, "TSO errors"); 1769 evcnt_attach_dynamic(&adapter->link_irq, EVCNT_TYPE_INTR, 1770 NULL, xname, "Link MSI-X IRQ Handled"); 1771 evcnt_attach_dynamic(&adapter->link_sicount, EVCNT_TYPE_INTR, 1772 NULL, xname, "Link softint"); 1773 evcnt_attach_dynamic(&adapter->mod_sicount, EVCNT_TYPE_INTR, 1774 NULL, xname, "module softint"); 1775 evcnt_attach_dynamic(&adapter->msf_sicount, EVCNT_TYPE_INTR, 1776 NULL, xname, "multimode softint"); 1777 evcnt_attach_dynamic(&adapter->phy_sicount, EVCNT_TYPE_INTR, 1778 NULL, xname, "external PHY softint"); 1779 1780 /* Max number of traffic class is 8 */ 1781 KASSERT(IXGBE_DCB_MAX_TRAFFIC_CLASS == 8); 1782 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 1783 snprintf(adapter->tcs[i].evnamebuf, 1784 sizeof(adapter->tcs[i].evnamebuf), "%s tc%d", 1785 xname, i); 1786 if (i < __arraycount(stats->mpc)) { 1787 evcnt_attach_dynamic(&stats->mpc[i], 1788 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1789 "RX Missed Packet Count"); 1790 if (hw->mac.type == ixgbe_mac_82598EB) 1791 evcnt_attach_dynamic(&stats->rnbc[i], 1792 EVCNT_TYPE_MISC, NULL, 1793 adapter->tcs[i].evnamebuf, 1794 "Receive No Buffers"); 1795 } 1796 if (i < __arraycount(stats->pxontxc)) { 1797 evcnt_attach_dynamic(&stats->pxontxc[i], 1798 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1799 "pxontxc"); 1800 evcnt_attach_dynamic(&stats->pxonrxc[i], 1801 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1802 "pxonrxc"); 1803 evcnt_attach_dynamic(&stats->pxofftxc[i], 1804 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1805 "pxofftxc"); 1806 evcnt_attach_dynamic(&stats->pxoffrxc[i], 1807 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1808 "pxoffrxc"); 1809 if (hw->mac.type >= ixgbe_mac_82599EB) 1810 evcnt_attach_dynamic(&stats->pxon2offc[i], 1811 EVCNT_TYPE_MISC, NULL, 1812 adapter->tcs[i].evnamebuf, 1813 "pxon2offc"); 1814 } 1815 } 1816 1817 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 1818 #ifdef LRO 1819 struct lro_ctrl *lro = &rxr->lro; 1820 #endif /* LRO */ 1821 1822 snprintf(adapter->queues[i].evnamebuf, 1823 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 1824 xname, i); 1825 snprintf(adapter->queues[i].namebuf, 1826 sizeof(adapter->queues[i].namebuf), "q%d", i); 1827 1828 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 1829 aprint_error_dev(dev, "could not create sysctl root\n"); 1830 break; 1831 } 1832 1833 if (sysctl_createv(log, 0, &rnode, &rnode, 1834 0, CTLTYPE_NODE, 1835 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 1836 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 1837 break; 1838 1839 if (sysctl_createv(log, 0, &rnode, &cnode, 1840 CTLFLAG_READWRITE, CTLTYPE_INT, 1841 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 1842 ixgbe_sysctl_interrupt_rate_handler, 0, 1843 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 1844 break; 1845 1846 if (sysctl_createv(log, 0, &rnode, &cnode, 1847 CTLFLAG_READONLY, CTLTYPE_INT, 1848 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 1849 ixgbe_sysctl_tdh_handler, 0, (void *)txr, 1850 0, CTL_CREATE, CTL_EOL) != 0) 1851 break; 1852 1853 if (sysctl_createv(log, 0, &rnode, &cnode, 1854 CTLFLAG_READONLY, CTLTYPE_INT, 1855 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 1856 ixgbe_sysctl_tdt_handler, 0, (void *)txr, 1857 0, CTL_CREATE, CTL_EOL) != 0) 1858 break; 1859 1860 evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR, 1861 NULL, adapter->queues[i].evnamebuf, "IRQs on queue"); 1862 evcnt_attach_dynamic(&adapter->queues[i].handleq, 1863 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1864 "Handled queue in softint"); 1865 evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC, 1866 NULL, adapter->queues[i].evnamebuf, "Requeued in softint"); 1867 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 1868 NULL, adapter->queues[i].evnamebuf, "TSO"); 1869 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 1870 NULL, adapter->queues[i].evnamebuf, 1871 "Queue No Descriptor Available"); 1872 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 1873 NULL, adapter->queues[i].evnamebuf, 1874 "Queue Packets Transmitted"); 1875 #ifndef IXGBE_LEGACY_TX 1876 evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC, 1877 NULL, adapter->queues[i].evnamebuf, 1878 "Packets dropped in pcq"); 1879 #endif 1880 1881 if (sysctl_createv(log, 0, &rnode, &cnode, 1882 CTLFLAG_READONLY, 1883 CTLTYPE_INT, 1884 "rxd_nxck", SYSCTL_DESCR("Receive Descriptor next to check"), 1885 ixgbe_sysctl_next_to_check_handler, 0, (void *)rxr, 0, 1886 CTL_CREATE, CTL_EOL) != 0) 1887 break; 1888 1889 if (sysctl_createv(log, 0, &rnode, &cnode, 1890 CTLFLAG_READONLY, 1891 CTLTYPE_INT, 1892 "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"), 1893 ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0, 1894 CTL_CREATE, CTL_EOL) != 0) 1895 break; 1896 1897 if (sysctl_createv(log, 0, &rnode, &cnode, 1898 CTLFLAG_READONLY, 1899 CTLTYPE_INT, 1900 "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"), 1901 ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0, 1902 CTL_CREATE, CTL_EOL) != 0) 1903 break; 1904 1905 if (i < __arraycount(stats->qprc)) { 1906 evcnt_attach_dynamic(&stats->qprc[i], 1907 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1908 "qprc"); 1909 evcnt_attach_dynamic(&stats->qptc[i], 1910 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1911 "qptc"); 1912 evcnt_attach_dynamic(&stats->qbrc[i], 1913 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1914 "qbrc"); 1915 evcnt_attach_dynamic(&stats->qbtc[i], 1916 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1917 "qbtc"); 1918 if (hw->mac.type >= ixgbe_mac_82599EB) 1919 evcnt_attach_dynamic(&stats->qprdc[i], 1920 EVCNT_TYPE_MISC, NULL, 1921 adapter->queues[i].evnamebuf, "qprdc"); 1922 } 1923 1924 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 1925 NULL, adapter->queues[i].evnamebuf, "Queue Packets Received"); 1926 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 1927 NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received"); 1928 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 1929 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 1930 evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC, 1931 NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf"); 1932 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 1933 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 1934 #ifdef LRO 1935 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 1936 CTLFLAG_RD, &lro->lro_queued, 0, 1937 "LRO Queued"); 1938 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 1939 CTLFLAG_RD, &lro->lro_flushed, 0, 1940 "LRO Flushed"); 1941 #endif /* LRO */ 1942 } 1943 1944 /* MAC stats get their own sub node */ 1945 1946 snprintf(stats->namebuf, 1947 sizeof(stats->namebuf), "%s MAC Statistics", xname); 1948 1949 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 1950 stats->namebuf, "rx csum offload - IP"); 1951 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 1952 stats->namebuf, "rx csum offload - L4"); 1953 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 1954 stats->namebuf, "rx csum offload - IP bad"); 1955 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 1956 stats->namebuf, "rx csum offload - L4 bad"); 1957 evcnt_attach_dynamic(&stats->intzero, EVCNT_TYPE_MISC, NULL, 1958 stats->namebuf, "Interrupt conditions zero"); 1959 evcnt_attach_dynamic(&stats->legint, EVCNT_TYPE_MISC, NULL, 1960 stats->namebuf, "Legacy interrupts"); 1961 1962 evcnt_attach_dynamic(&stats->crcerrs, EVCNT_TYPE_MISC, NULL, 1963 stats->namebuf, "CRC Errors"); 1964 evcnt_attach_dynamic(&stats->illerrc, EVCNT_TYPE_MISC, NULL, 1965 stats->namebuf, "Illegal Byte Errors"); 1966 evcnt_attach_dynamic(&stats->errbc, EVCNT_TYPE_MISC, NULL, 1967 stats->namebuf, "Byte Errors"); 1968 evcnt_attach_dynamic(&stats->mspdc, EVCNT_TYPE_MISC, NULL, 1969 stats->namebuf, "MAC Short Packets Discarded"); 1970 if (hw->mac.type >= ixgbe_mac_X550) 1971 evcnt_attach_dynamic(&stats->mbsdc, EVCNT_TYPE_MISC, NULL, 1972 stats->namebuf, "Bad SFD"); 1973 evcnt_attach_dynamic(&stats->mpctotal, EVCNT_TYPE_MISC, NULL, 1974 stats->namebuf, "Total Packets Missed"); 1975 evcnt_attach_dynamic(&stats->mlfc, EVCNT_TYPE_MISC, NULL, 1976 stats->namebuf, "MAC Local Faults"); 1977 evcnt_attach_dynamic(&stats->mrfc, EVCNT_TYPE_MISC, NULL, 1978 stats->namebuf, "MAC Remote Faults"); 1979 evcnt_attach_dynamic(&stats->rlec, EVCNT_TYPE_MISC, NULL, 1980 stats->namebuf, "Receive Length Errors"); 1981 evcnt_attach_dynamic(&stats->lxontxc, EVCNT_TYPE_MISC, NULL, 1982 stats->namebuf, "Link XON Transmitted"); 1983 evcnt_attach_dynamic(&stats->lxonrxc, EVCNT_TYPE_MISC, NULL, 1984 stats->namebuf, "Link XON Received"); 1985 evcnt_attach_dynamic(&stats->lxofftxc, EVCNT_TYPE_MISC, NULL, 1986 stats->namebuf, "Link XOFF Transmitted"); 1987 evcnt_attach_dynamic(&stats->lxoffrxc, EVCNT_TYPE_MISC, NULL, 1988 stats->namebuf, "Link XOFF Received"); 1989 1990 /* Packet Reception Stats */ 1991 evcnt_attach_dynamic(&stats->tor, EVCNT_TYPE_MISC, NULL, 1992 stats->namebuf, "Total Octets Received"); 1993 evcnt_attach_dynamic(&stats->gorc, EVCNT_TYPE_MISC, NULL, 1994 stats->namebuf, "Good Octets Received"); 1995 evcnt_attach_dynamic(&stats->tpr, EVCNT_TYPE_MISC, NULL, 1996 stats->namebuf, "Total Packets Received"); 1997 evcnt_attach_dynamic(&stats->gprc, EVCNT_TYPE_MISC, NULL, 1998 stats->namebuf, "Good Packets Received"); 1999 evcnt_attach_dynamic(&stats->mprc, EVCNT_TYPE_MISC, NULL, 2000 stats->namebuf, "Multicast Packets Received"); 2001 evcnt_attach_dynamic(&stats->bprc, EVCNT_TYPE_MISC, NULL, 2002 stats->namebuf, "Broadcast Packets Received"); 2003 evcnt_attach_dynamic(&stats->prc64, EVCNT_TYPE_MISC, NULL, 2004 stats->namebuf, "64 byte frames received "); 2005 evcnt_attach_dynamic(&stats->prc127, EVCNT_TYPE_MISC, NULL, 2006 stats->namebuf, "65-127 byte frames received"); 2007 evcnt_attach_dynamic(&stats->prc255, EVCNT_TYPE_MISC, NULL, 2008 stats->namebuf, "128-255 byte frames received"); 2009 evcnt_attach_dynamic(&stats->prc511, EVCNT_TYPE_MISC, NULL, 2010 stats->namebuf, "256-511 byte frames received"); 2011 evcnt_attach_dynamic(&stats->prc1023, EVCNT_TYPE_MISC, NULL, 2012 stats->namebuf, "512-1023 byte frames received"); 2013 evcnt_attach_dynamic(&stats->prc1522, EVCNT_TYPE_MISC, NULL, 2014 stats->namebuf, "1023-1522 byte frames received"); 2015 evcnt_attach_dynamic(&stats->ruc, EVCNT_TYPE_MISC, NULL, 2016 stats->namebuf, "Receive Undersized"); 2017 evcnt_attach_dynamic(&stats->rfc, EVCNT_TYPE_MISC, NULL, 2018 stats->namebuf, "Fragmented Packets Received "); 2019 evcnt_attach_dynamic(&stats->roc, EVCNT_TYPE_MISC, NULL, 2020 stats->namebuf, "Oversized Packets Received"); 2021 evcnt_attach_dynamic(&stats->rjc, EVCNT_TYPE_MISC, NULL, 2022 stats->namebuf, "Received Jabber"); 2023 evcnt_attach_dynamic(&stats->mngprc, EVCNT_TYPE_MISC, NULL, 2024 stats->namebuf, "Management Packets Received"); 2025 evcnt_attach_dynamic(&stats->mngpdc, EVCNT_TYPE_MISC, NULL, 2026 stats->namebuf, "Management Packets Dropped"); 2027 evcnt_attach_dynamic(&stats->xec, EVCNT_TYPE_MISC, NULL, 2028 stats->namebuf, "Checksum Errors"); 2029 2030 /* Packet Transmission Stats */ 2031 evcnt_attach_dynamic(&stats->gotc, EVCNT_TYPE_MISC, NULL, 2032 stats->namebuf, "Good Octets Transmitted"); 2033 evcnt_attach_dynamic(&stats->tpt, EVCNT_TYPE_MISC, NULL, 2034 stats->namebuf, "Total Packets Transmitted"); 2035 evcnt_attach_dynamic(&stats->gptc, EVCNT_TYPE_MISC, NULL, 2036 stats->namebuf, "Good Packets Transmitted"); 2037 evcnt_attach_dynamic(&stats->bptc, EVCNT_TYPE_MISC, NULL, 2038 stats->namebuf, "Broadcast Packets Transmitted"); 2039 evcnt_attach_dynamic(&stats->mptc, EVCNT_TYPE_MISC, NULL, 2040 stats->namebuf, "Multicast Packets Transmitted"); 2041 evcnt_attach_dynamic(&stats->mngptc, EVCNT_TYPE_MISC, NULL, 2042 stats->namebuf, "Management Packets Transmitted"); 2043 evcnt_attach_dynamic(&stats->ptc64, EVCNT_TYPE_MISC, NULL, 2044 stats->namebuf, "64 byte frames transmitted "); 2045 evcnt_attach_dynamic(&stats->ptc127, EVCNT_TYPE_MISC, NULL, 2046 stats->namebuf, "65-127 byte frames transmitted"); 2047 evcnt_attach_dynamic(&stats->ptc255, EVCNT_TYPE_MISC, NULL, 2048 stats->namebuf, "128-255 byte frames transmitted"); 2049 evcnt_attach_dynamic(&stats->ptc511, EVCNT_TYPE_MISC, NULL, 2050 stats->namebuf, "256-511 byte frames transmitted"); 2051 evcnt_attach_dynamic(&stats->ptc1023, EVCNT_TYPE_MISC, NULL, 2052 stats->namebuf, "512-1023 byte frames transmitted"); 2053 evcnt_attach_dynamic(&stats->ptc1522, EVCNT_TYPE_MISC, NULL, 2054 stats->namebuf, "1024-1522 byte frames transmitted"); 2055 } /* ixgbe_add_hw_stats */ 2056 2057 static void 2058 ixgbe_clear_evcnt(struct adapter *adapter) 2059 { 2060 struct tx_ring *txr = adapter->tx_rings; 2061 struct rx_ring *rxr = adapter->rx_rings; 2062 struct ixgbe_hw *hw = &adapter->hw; 2063 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 2064 int i; 2065 2066 adapter->efbig_tx_dma_setup.ev_count = 0; 2067 adapter->mbuf_defrag_failed.ev_count = 0; 2068 adapter->efbig2_tx_dma_setup.ev_count = 0; 2069 adapter->einval_tx_dma_setup.ev_count = 0; 2070 adapter->other_tx_dma_setup.ev_count = 0; 2071 adapter->eagain_tx_dma_setup.ev_count = 0; 2072 adapter->enomem_tx_dma_setup.ev_count = 0; 2073 adapter->tso_err.ev_count = 0; 2074 adapter->watchdog_events.ev_count = 0; 2075 adapter->link_irq.ev_count = 0; 2076 adapter->link_sicount.ev_count = 0; 2077 adapter->mod_sicount.ev_count = 0; 2078 adapter->msf_sicount.ev_count = 0; 2079 adapter->phy_sicount.ev_count = 0; 2080 2081 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 2082 if (i < __arraycount(stats->mpc)) { 2083 stats->mpc[i].ev_count = 0; 2084 if (hw->mac.type == ixgbe_mac_82598EB) 2085 stats->rnbc[i].ev_count = 0; 2086 } 2087 if (i < __arraycount(stats->pxontxc)) { 2088 stats->pxontxc[i].ev_count = 0; 2089 stats->pxonrxc[i].ev_count = 0; 2090 stats->pxofftxc[i].ev_count = 0; 2091 stats->pxoffrxc[i].ev_count = 0; 2092 if (hw->mac.type >= ixgbe_mac_82599EB) 2093 stats->pxon2offc[i].ev_count = 0; 2094 } 2095 } 2096 2097 txr = adapter->tx_rings; 2098 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2099 adapter->queues[i].irqs.ev_count = 0; 2100 adapter->queues[i].handleq.ev_count = 0; 2101 adapter->queues[i].req.ev_count = 0; 2102 txr->no_desc_avail.ev_count = 0; 2103 txr->total_packets.ev_count = 0; 2104 txr->tso_tx.ev_count = 0; 2105 #ifndef IXGBE_LEGACY_TX 2106 txr->pcq_drops.ev_count = 0; 2107 #endif 2108 txr->q_efbig_tx_dma_setup = 0; 2109 txr->q_mbuf_defrag_failed = 0; 2110 txr->q_efbig2_tx_dma_setup = 0; 2111 txr->q_einval_tx_dma_setup = 0; 2112 txr->q_other_tx_dma_setup = 0; 2113 txr->q_eagain_tx_dma_setup = 0; 2114 txr->q_enomem_tx_dma_setup = 0; 2115 txr->q_tso_err = 0; 2116 2117 if (i < __arraycount(stats->qprc)) { 2118 stats->qprc[i].ev_count = 0; 2119 stats->qptc[i].ev_count = 0; 2120 stats->qbrc[i].ev_count = 0; 2121 stats->qbtc[i].ev_count = 0; 2122 if (hw->mac.type >= ixgbe_mac_82599EB) 2123 stats->qprdc[i].ev_count = 0; 2124 } 2125 2126 rxr->rx_packets.ev_count = 0; 2127 rxr->rx_bytes.ev_count = 0; 2128 rxr->rx_copies.ev_count = 0; 2129 rxr->no_jmbuf.ev_count = 0; 2130 rxr->rx_discarded.ev_count = 0; 2131 } 2132 stats->ipcs.ev_count = 0; 2133 stats->l4cs.ev_count = 0; 2134 stats->ipcs_bad.ev_count = 0; 2135 stats->l4cs_bad.ev_count = 0; 2136 stats->intzero.ev_count = 0; 2137 stats->legint.ev_count = 0; 2138 stats->crcerrs.ev_count = 0; 2139 stats->illerrc.ev_count = 0; 2140 stats->errbc.ev_count = 0; 2141 stats->mspdc.ev_count = 0; 2142 if (hw->mac.type >= ixgbe_mac_X550) 2143 stats->mbsdc.ev_count = 0; 2144 stats->mpctotal.ev_count = 0; 2145 stats->mlfc.ev_count = 0; 2146 stats->mrfc.ev_count = 0; 2147 stats->rlec.ev_count = 0; 2148 stats->lxontxc.ev_count = 0; 2149 stats->lxonrxc.ev_count = 0; 2150 stats->lxofftxc.ev_count = 0; 2151 stats->lxoffrxc.ev_count = 0; 2152 2153 /* Packet Reception Stats */ 2154 stats->tor.ev_count = 0; 2155 stats->gorc.ev_count = 0; 2156 stats->tpr.ev_count = 0; 2157 stats->gprc.ev_count = 0; 2158 stats->mprc.ev_count = 0; 2159 stats->bprc.ev_count = 0; 2160 stats->prc64.ev_count = 0; 2161 stats->prc127.ev_count = 0; 2162 stats->prc255.ev_count = 0; 2163 stats->prc511.ev_count = 0; 2164 stats->prc1023.ev_count = 0; 2165 stats->prc1522.ev_count = 0; 2166 stats->ruc.ev_count = 0; 2167 stats->rfc.ev_count = 0; 2168 stats->roc.ev_count = 0; 2169 stats->rjc.ev_count = 0; 2170 stats->mngprc.ev_count = 0; 2171 stats->mngpdc.ev_count = 0; 2172 stats->xec.ev_count = 0; 2173 2174 /* Packet Transmission Stats */ 2175 stats->gotc.ev_count = 0; 2176 stats->tpt.ev_count = 0; 2177 stats->gptc.ev_count = 0; 2178 stats->bptc.ev_count = 0; 2179 stats->mptc.ev_count = 0; 2180 stats->mngptc.ev_count = 0; 2181 stats->ptc64.ev_count = 0; 2182 stats->ptc127.ev_count = 0; 2183 stats->ptc255.ev_count = 0; 2184 stats->ptc511.ev_count = 0; 2185 stats->ptc1023.ev_count = 0; 2186 stats->ptc1522.ev_count = 0; 2187 } 2188 2189 /************************************************************************ 2190 * ixgbe_sysctl_tdh_handler - Transmit Descriptor Head handler function 2191 * 2192 * Retrieves the TDH value from the hardware 2193 ************************************************************************/ 2194 static int 2195 ixgbe_sysctl_tdh_handler(SYSCTLFN_ARGS) 2196 { 2197 struct sysctlnode node = *rnode; 2198 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2199 struct adapter *adapter; 2200 uint32_t val; 2201 2202 if (!txr) 2203 return (0); 2204 2205 adapter = txr->adapter; 2206 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2207 return (EPERM); 2208 2209 val = IXGBE_READ_REG(&adapter->hw, IXGBE_TDH(txr->me)); 2210 node.sysctl_data = &val; 2211 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2212 } /* ixgbe_sysctl_tdh_handler */ 2213 2214 /************************************************************************ 2215 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 2216 * 2217 * Retrieves the TDT value from the hardware 2218 ************************************************************************/ 2219 static int 2220 ixgbe_sysctl_tdt_handler(SYSCTLFN_ARGS) 2221 { 2222 struct sysctlnode node = *rnode; 2223 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2224 struct adapter *adapter; 2225 uint32_t val; 2226 2227 if (!txr) 2228 return (0); 2229 2230 adapter = txr->adapter; 2231 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2232 return (EPERM); 2233 2234 val = IXGBE_READ_REG(&adapter->hw, IXGBE_TDT(txr->me)); 2235 node.sysctl_data = &val; 2236 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2237 } /* ixgbe_sysctl_tdt_handler */ 2238 2239 /************************************************************************ 2240 * ixgbe_sysctl_next_to_check_handler - Receive Descriptor next to check 2241 * handler function 2242 * 2243 * Retrieves the next_to_check value 2244 ************************************************************************/ 2245 static int 2246 ixgbe_sysctl_next_to_check_handler(SYSCTLFN_ARGS) 2247 { 2248 struct sysctlnode node = *rnode; 2249 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2250 struct adapter *adapter; 2251 uint32_t val; 2252 2253 if (!rxr) 2254 return (0); 2255 2256 adapter = rxr->adapter; 2257 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2258 return (EPERM); 2259 2260 val = rxr->next_to_check; 2261 node.sysctl_data = &val; 2262 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2263 } /* ixgbe_sysctl_next_to_check_handler */ 2264 2265 /************************************************************************ 2266 * ixgbe_sysctl_rdh_handler - Receive Descriptor Head handler function 2267 * 2268 * Retrieves the RDH value from the hardware 2269 ************************************************************************/ 2270 static int 2271 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS) 2272 { 2273 struct sysctlnode node = *rnode; 2274 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2275 struct adapter *adapter; 2276 uint32_t val; 2277 2278 if (!rxr) 2279 return (0); 2280 2281 adapter = rxr->adapter; 2282 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2283 return (EPERM); 2284 2285 val = IXGBE_READ_REG(&adapter->hw, IXGBE_RDH(rxr->me)); 2286 node.sysctl_data = &val; 2287 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2288 } /* ixgbe_sysctl_rdh_handler */ 2289 2290 /************************************************************************ 2291 * ixgbe_sysctl_rdt_handler - Receive Descriptor Tail handler function 2292 * 2293 * Retrieves the RDT value from the hardware 2294 ************************************************************************/ 2295 static int 2296 ixgbe_sysctl_rdt_handler(SYSCTLFN_ARGS) 2297 { 2298 struct sysctlnode node = *rnode; 2299 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2300 struct adapter *adapter; 2301 uint32_t val; 2302 2303 if (!rxr) 2304 return (0); 2305 2306 adapter = rxr->adapter; 2307 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2308 return (EPERM); 2309 2310 val = IXGBE_READ_REG(&adapter->hw, IXGBE_RDT(rxr->me)); 2311 node.sysctl_data = &val; 2312 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2313 } /* ixgbe_sysctl_rdt_handler */ 2314 2315 static int 2316 ixgbe_vlan_cb(struct ethercom *ec, uint16_t vid, bool set) 2317 { 2318 struct ifnet *ifp = &ec->ec_if; 2319 struct adapter *adapter = ifp->if_softc; 2320 int rv; 2321 2322 if (set) 2323 rv = ixgbe_register_vlan(adapter, vid); 2324 else 2325 rv = ixgbe_unregister_vlan(adapter, vid); 2326 2327 if (rv != 0) 2328 return rv; 2329 2330 /* 2331 * Control VLAN HW tagging when ec_nvlan is changed from 1 to 0 2332 * or 0 to 1. 2333 */ 2334 if ((set && (ec->ec_nvlans == 1)) || (!set && (ec->ec_nvlans == 0))) 2335 ixgbe_setup_vlan_hw_tagging(adapter); 2336 2337 return rv; 2338 } 2339 2340 /************************************************************************ 2341 * ixgbe_register_vlan 2342 * 2343 * Run via vlan config EVENT, it enables us to use the 2344 * HW Filter table since we can get the vlan id. This 2345 * just creates the entry in the soft version of the 2346 * VFTA, init will repopulate the real table. 2347 ************************************************************************/ 2348 static int 2349 ixgbe_register_vlan(struct adapter *adapter, u16 vtag) 2350 { 2351 u16 index, bit; 2352 int error; 2353 2354 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2355 return EINVAL; 2356 2357 IXGBE_CORE_LOCK(adapter); 2358 index = (vtag >> 5) & 0x7F; 2359 bit = vtag & 0x1F; 2360 adapter->shadow_vfta[index] |= ((u32)1 << bit); 2361 error = adapter->hw.mac.ops.set_vfta(&adapter->hw, vtag, 0, true, 2362 true); 2363 IXGBE_CORE_UNLOCK(adapter); 2364 if (error != 0) 2365 error = EACCES; 2366 2367 return error; 2368 } /* ixgbe_register_vlan */ 2369 2370 /************************************************************************ 2371 * ixgbe_unregister_vlan 2372 * 2373 * Run via vlan unconfig EVENT, remove our entry in the soft vfta. 2374 ************************************************************************/ 2375 static int 2376 ixgbe_unregister_vlan(struct adapter *adapter, u16 vtag) 2377 { 2378 u16 index, bit; 2379 int error; 2380 2381 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2382 return EINVAL; 2383 2384 IXGBE_CORE_LOCK(adapter); 2385 index = (vtag >> 5) & 0x7F; 2386 bit = vtag & 0x1F; 2387 adapter->shadow_vfta[index] &= ~((u32)1 << bit); 2388 error = adapter->hw.mac.ops.set_vfta(&adapter->hw, vtag, 0, false, 2389 true); 2390 IXGBE_CORE_UNLOCK(adapter); 2391 if (error != 0) 2392 error = EACCES; 2393 2394 return error; 2395 } /* ixgbe_unregister_vlan */ 2396 2397 static void 2398 ixgbe_setup_vlan_hw_tagging(struct adapter *adapter) 2399 { 2400 struct ethercom *ec = &adapter->osdep.ec; 2401 struct ixgbe_hw *hw = &adapter->hw; 2402 struct rx_ring *rxr; 2403 u32 ctrl; 2404 int i; 2405 bool hwtagging; 2406 2407 /* Enable HW tagging only if any vlan is attached */ 2408 hwtagging = (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) 2409 && VLAN_ATTACHED(ec); 2410 2411 /* Setup the queues for vlans */ 2412 for (i = 0; i < adapter->num_queues; i++) { 2413 rxr = &adapter->rx_rings[i]; 2414 /* 2415 * On 82599 and later, the VLAN enable is per/queue in RXDCTL. 2416 */ 2417 if (hw->mac.type != ixgbe_mac_82598EB) { 2418 ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 2419 if (hwtagging) 2420 ctrl |= IXGBE_RXDCTL_VME; 2421 else 2422 ctrl &= ~IXGBE_RXDCTL_VME; 2423 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), ctrl); 2424 } 2425 rxr->vtag_strip = hwtagging ? TRUE : FALSE; 2426 } 2427 2428 /* VLAN hw tagging for 82598 */ 2429 if (hw->mac.type == ixgbe_mac_82598EB) { 2430 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2431 if (hwtagging) 2432 ctrl |= IXGBE_VLNCTRL_VME; 2433 else 2434 ctrl &= ~IXGBE_VLNCTRL_VME; 2435 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2436 } 2437 } /* ixgbe_setup_vlan_hw_tagging */ 2438 2439 static void 2440 ixgbe_setup_vlan_hw_support(struct adapter *adapter) 2441 { 2442 struct ethercom *ec = &adapter->osdep.ec; 2443 struct ixgbe_hw *hw = &adapter->hw; 2444 int i; 2445 u32 ctrl; 2446 struct vlanid_list *vlanidp; 2447 2448 /* 2449 * This function is called from both if_init and ifflags_cb() 2450 * on NetBSD. 2451 */ 2452 2453 /* 2454 * Part 1: 2455 * Setup VLAN HW tagging 2456 */ 2457 ixgbe_setup_vlan_hw_tagging(adapter); 2458 2459 /* 2460 * Part 2: 2461 * Setup VLAN HW filter 2462 */ 2463 /* Cleanup shadow_vfta */ 2464 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2465 adapter->shadow_vfta[i] = 0; 2466 /* Generate shadow_vfta from ec_vids */ 2467 ETHER_LOCK(ec); 2468 SIMPLEQ_FOREACH(vlanidp, &ec->ec_vids, vid_list) { 2469 uint32_t idx; 2470 2471 idx = vlanidp->vid / 32; 2472 KASSERT(idx < IXGBE_VFTA_SIZE); 2473 adapter->shadow_vfta[idx] |= (u32)1 << (vlanidp->vid % 32); 2474 } 2475 ETHER_UNLOCK(ec); 2476 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2477 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), adapter->shadow_vfta[i]); 2478 2479 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2480 /* Enable the Filter Table if enabled */ 2481 if (ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) 2482 ctrl |= IXGBE_VLNCTRL_VFE; 2483 else 2484 ctrl &= ~IXGBE_VLNCTRL_VFE; 2485 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2486 } /* ixgbe_setup_vlan_hw_support */ 2487 2488 /************************************************************************ 2489 * ixgbe_get_slot_info 2490 * 2491 * Get the width and transaction speed of 2492 * the slot this adapter is plugged into. 2493 ************************************************************************/ 2494 static void 2495 ixgbe_get_slot_info(struct adapter *adapter) 2496 { 2497 device_t dev = adapter->dev; 2498 struct ixgbe_hw *hw = &adapter->hw; 2499 u32 offset; 2500 u16 link; 2501 int bus_info_valid = TRUE; 2502 2503 /* Some devices are behind an internal bridge */ 2504 switch (hw->device_id) { 2505 case IXGBE_DEV_ID_82599_SFP_SF_QP: 2506 case IXGBE_DEV_ID_82599_QSFP_SF_QP: 2507 goto get_parent_info; 2508 default: 2509 break; 2510 } 2511 2512 ixgbe_get_bus_info(hw); 2513 2514 /* 2515 * Some devices don't use PCI-E, but there is no need 2516 * to display "Unknown" for bus speed and width. 2517 */ 2518 switch (hw->mac.type) { 2519 case ixgbe_mac_X550EM_x: 2520 case ixgbe_mac_X550EM_a: 2521 return; 2522 default: 2523 goto display; 2524 } 2525 2526 get_parent_info: 2527 /* 2528 * For the Quad port adapter we need to parse back 2529 * up the PCI tree to find the speed of the expansion 2530 * slot into which this adapter is plugged. A bit more work. 2531 */ 2532 dev = device_parent(device_parent(dev)); 2533 #if 0 2534 #ifdef IXGBE_DEBUG 2535 device_printf(dev, "parent pcib = %x,%x,%x\n", pci_get_bus(dev), 2536 pci_get_slot(dev), pci_get_function(dev)); 2537 #endif 2538 dev = device_parent(device_parent(dev)); 2539 #ifdef IXGBE_DEBUG 2540 device_printf(dev, "slot pcib = %x,%x,%x\n", pci_get_bus(dev), 2541 pci_get_slot(dev), pci_get_function(dev)); 2542 #endif 2543 #endif 2544 /* Now get the PCI Express Capabilities offset */ 2545 if (pci_get_capability(adapter->osdep.pc, adapter->osdep.tag, 2546 PCI_CAP_PCIEXPRESS, &offset, NULL)) { 2547 /* 2548 * Hmm...can't get PCI-Express capabilities. 2549 * Falling back to default method. 2550 */ 2551 bus_info_valid = FALSE; 2552 ixgbe_get_bus_info(hw); 2553 goto display; 2554 } 2555 /* ...and read the Link Status Register */ 2556 link = pci_conf_read(adapter->osdep.pc, adapter->osdep.tag, 2557 offset + PCIE_LCSR) >> 16; 2558 ixgbe_set_pci_config_data_generic(hw, link); 2559 2560 display: 2561 device_printf(dev, "PCI Express Bus: Speed %s Width %s\n", 2562 ((hw->bus.speed == ixgbe_bus_speed_8000) ? "8.0GT/s" : 2563 (hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0GT/s" : 2564 (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5GT/s" : 2565 "Unknown"), 2566 ((hw->bus.width == ixgbe_bus_width_pcie_x8) ? "x8" : 2567 (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "x4" : 2568 (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "x1" : 2569 "Unknown")); 2570 2571 if (bus_info_valid) { 2572 if ((hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) && 2573 ((hw->bus.width <= ixgbe_bus_width_pcie_x4) && 2574 (hw->bus.speed == ixgbe_bus_speed_2500))) { 2575 device_printf(dev, "PCI-Express bandwidth available" 2576 " for this card\n is not sufficient for" 2577 " optimal performance.\n"); 2578 device_printf(dev, "For optimal performance a x8 " 2579 "PCIE, or x4 PCIE Gen2 slot is required.\n"); 2580 } 2581 if ((hw->device_id == IXGBE_DEV_ID_82599_SFP_SF_QP) && 2582 ((hw->bus.width <= ixgbe_bus_width_pcie_x8) && 2583 (hw->bus.speed < ixgbe_bus_speed_8000))) { 2584 device_printf(dev, "PCI-Express bandwidth available" 2585 " for this card\n is not sufficient for" 2586 " optimal performance.\n"); 2587 device_printf(dev, "For optimal performance a x8 " 2588 "PCIE Gen3 slot is required.\n"); 2589 } 2590 } else 2591 device_printf(dev, "Unable to determine slot speed/width. The speed/width reported are that of the internal switch.\n"); 2592 2593 return; 2594 } /* ixgbe_get_slot_info */ 2595 2596 /************************************************************************ 2597 * ixgbe_enable_queue - MSI-X Interrupt Handlers and Tasklets 2598 ************************************************************************/ 2599 static inline void 2600 ixgbe_enable_queue(struct adapter *adapter, u32 vector) 2601 { 2602 struct ixgbe_hw *hw = &adapter->hw; 2603 struct ix_queue *que = &adapter->queues[vector]; 2604 u64 queue = 1ULL << vector; 2605 u32 mask; 2606 2607 mutex_enter(&que->dc_mtx); 2608 if (que->disabled_count > 0 && --que->disabled_count > 0) 2609 goto out; 2610 2611 if (hw->mac.type == ixgbe_mac_82598EB) { 2612 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2613 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 2614 } else { 2615 mask = (queue & 0xFFFFFFFF); 2616 if (mask) 2617 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask); 2618 mask = (queue >> 32); 2619 if (mask) 2620 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask); 2621 } 2622 out: 2623 mutex_exit(&que->dc_mtx); 2624 } /* ixgbe_enable_queue */ 2625 2626 /************************************************************************ 2627 * ixgbe_disable_queue_internal 2628 ************************************************************************/ 2629 static inline void 2630 ixgbe_disable_queue_internal(struct adapter *adapter, u32 vector, bool nestok) 2631 { 2632 struct ixgbe_hw *hw = &adapter->hw; 2633 struct ix_queue *que = &adapter->queues[vector]; 2634 u64 queue = 1ULL << vector; 2635 u32 mask; 2636 2637 mutex_enter(&que->dc_mtx); 2638 2639 if (que->disabled_count > 0) { 2640 if (nestok) 2641 que->disabled_count++; 2642 goto out; 2643 } 2644 que->disabled_count++; 2645 2646 if (hw->mac.type == ixgbe_mac_82598EB) { 2647 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2648 IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask); 2649 } else { 2650 mask = (queue & 0xFFFFFFFF); 2651 if (mask) 2652 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask); 2653 mask = (queue >> 32); 2654 if (mask) 2655 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask); 2656 } 2657 out: 2658 mutex_exit(&que->dc_mtx); 2659 } /* ixgbe_disable_queue_internal */ 2660 2661 /************************************************************************ 2662 * ixgbe_disable_queue 2663 ************************************************************************/ 2664 static inline void 2665 ixgbe_disable_queue(struct adapter *adapter, u32 vector) 2666 { 2667 2668 ixgbe_disable_queue_internal(adapter, vector, true); 2669 } /* ixgbe_disable_queue */ 2670 2671 /************************************************************************ 2672 * ixgbe_sched_handle_que - schedule deferred packet processing 2673 ************************************************************************/ 2674 static inline void 2675 ixgbe_sched_handle_que(struct adapter *adapter, struct ix_queue *que) 2676 { 2677 2678 if (que->txrx_use_workqueue) { 2679 /* 2680 * adapter->que_wq is bound to each CPU instead of 2681 * each NIC queue to reduce workqueue kthread. As we 2682 * should consider about interrupt affinity in this 2683 * function, the workqueue kthread must be WQ_PERCPU. 2684 * If create WQ_PERCPU workqueue kthread for each NIC 2685 * queue, that number of created workqueue kthread is 2686 * (number of used NIC queue) * (number of CPUs) = 2687 * (number of CPUs) ^ 2 most often. 2688 * 2689 * The same NIC queue's interrupts are avoided by 2690 * masking the queue's interrupt. And different 2691 * NIC queue's interrupts use different struct work 2692 * (que->wq_cookie). So, "enqueued flag" to avoid 2693 * twice workqueue_enqueue() is not required . 2694 */ 2695 workqueue_enqueue(adapter->que_wq, &que->wq_cookie, curcpu()); 2696 } else { 2697 softint_schedule(que->que_si); 2698 } 2699 } 2700 2701 /************************************************************************ 2702 * ixgbe_msix_que - MSI-X Queue Interrupt Service routine 2703 ************************************************************************/ 2704 static int 2705 ixgbe_msix_que(void *arg) 2706 { 2707 struct ix_queue *que = arg; 2708 struct adapter *adapter = que->adapter; 2709 struct ifnet *ifp = adapter->ifp; 2710 struct tx_ring *txr = que->txr; 2711 struct rx_ring *rxr = que->rxr; 2712 bool more; 2713 u32 newitr = 0; 2714 2715 /* Protect against spurious interrupts */ 2716 if ((ifp->if_flags & IFF_RUNNING) == 0) 2717 return 0; 2718 2719 ixgbe_disable_queue(adapter, que->msix); 2720 ++que->irqs.ev_count; 2721 2722 /* 2723 * Don't change "que->txrx_use_workqueue" from this point to avoid 2724 * flip-flopping softint/workqueue mode in one deferred processing. 2725 */ 2726 que->txrx_use_workqueue = adapter->txrx_use_workqueue; 2727 2728 #ifdef __NetBSD__ 2729 /* Don't run ixgbe_rxeof in interrupt context */ 2730 more = true; 2731 #else 2732 more = ixgbe_rxeof(que); 2733 #endif 2734 2735 IXGBE_TX_LOCK(txr); 2736 ixgbe_txeof(txr); 2737 IXGBE_TX_UNLOCK(txr); 2738 2739 /* Do AIM now? */ 2740 2741 if (adapter->enable_aim == false) 2742 goto no_calc; 2743 /* 2744 * Do Adaptive Interrupt Moderation: 2745 * - Write out last calculated setting 2746 * - Calculate based on average size over 2747 * the last interval. 2748 */ 2749 if (que->eitr_setting) 2750 ixgbe_eitr_write(adapter, que->msix, que->eitr_setting); 2751 2752 que->eitr_setting = 0; 2753 2754 /* Idle, do nothing */ 2755 if ((txr->bytes == 0) && (rxr->bytes == 0)) 2756 goto no_calc; 2757 2758 if ((txr->bytes) && (txr->packets)) 2759 newitr = txr->bytes/txr->packets; 2760 if ((rxr->bytes) && (rxr->packets)) 2761 newitr = uimax(newitr, (rxr->bytes / rxr->packets)); 2762 newitr += 24; /* account for hardware frame, crc */ 2763 2764 /* set an upper boundary */ 2765 newitr = uimin(newitr, 3000); 2766 2767 /* Be nice to the mid range */ 2768 if ((newitr > 300) && (newitr < 1200)) 2769 newitr = (newitr / 3); 2770 else 2771 newitr = (newitr / 2); 2772 2773 /* 2774 * When RSC is used, ITR interval must be larger than RSC_DELAY. 2775 * Currently, we use 2us for RSC_DELAY. The minimum value is always 2776 * greater than 2us on 100M (and 10M?(not documented)), but it's not 2777 * on 1G and higher. 2778 */ 2779 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2780 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2781 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 2782 newitr = IXGBE_MIN_RSC_EITR_10G1G; 2783 } 2784 2785 /* save for next interrupt */ 2786 que->eitr_setting = newitr; 2787 2788 /* Reset state */ 2789 txr->bytes = 0; 2790 txr->packets = 0; 2791 rxr->bytes = 0; 2792 rxr->packets = 0; 2793 2794 no_calc: 2795 if (more) 2796 ixgbe_sched_handle_que(adapter, que); 2797 else 2798 ixgbe_enable_queue(adapter, que->msix); 2799 2800 return 1; 2801 } /* ixgbe_msix_que */ 2802 2803 /************************************************************************ 2804 * ixgbe_media_status - Media Ioctl callback 2805 * 2806 * Called whenever the user queries the status of 2807 * the interface using ifconfig. 2808 ************************************************************************/ 2809 static void 2810 ixgbe_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 2811 { 2812 struct adapter *adapter = ifp->if_softc; 2813 struct ixgbe_hw *hw = &adapter->hw; 2814 int layer; 2815 2816 INIT_DEBUGOUT("ixgbe_media_status: begin"); 2817 ixgbe_update_link_status(adapter); 2818 2819 ifmr->ifm_status = IFM_AVALID; 2820 ifmr->ifm_active = IFM_ETHER; 2821 2822 if (adapter->link_active != LINK_STATE_UP) { 2823 ifmr->ifm_active |= IFM_NONE; 2824 return; 2825 } 2826 2827 ifmr->ifm_status |= IFM_ACTIVE; 2828 layer = adapter->phy_layer; 2829 2830 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T || 2831 layer & IXGBE_PHYSICAL_LAYER_5GBASE_T || 2832 layer & IXGBE_PHYSICAL_LAYER_2500BASE_T || 2833 layer & IXGBE_PHYSICAL_LAYER_1000BASE_T || 2834 layer & IXGBE_PHYSICAL_LAYER_100BASE_TX || 2835 layer & IXGBE_PHYSICAL_LAYER_10BASE_T) 2836 switch (adapter->link_speed) { 2837 case IXGBE_LINK_SPEED_10GB_FULL: 2838 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 2839 break; 2840 case IXGBE_LINK_SPEED_5GB_FULL: 2841 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 2842 break; 2843 case IXGBE_LINK_SPEED_2_5GB_FULL: 2844 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 2845 break; 2846 case IXGBE_LINK_SPEED_1GB_FULL: 2847 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 2848 break; 2849 case IXGBE_LINK_SPEED_100_FULL: 2850 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 2851 break; 2852 case IXGBE_LINK_SPEED_10_FULL: 2853 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 2854 break; 2855 } 2856 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 2857 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 2858 switch (adapter->link_speed) { 2859 case IXGBE_LINK_SPEED_10GB_FULL: 2860 ifmr->ifm_active |= IFM_10G_TWINAX | IFM_FDX; 2861 break; 2862 } 2863 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) 2864 switch (adapter->link_speed) { 2865 case IXGBE_LINK_SPEED_10GB_FULL: 2866 ifmr->ifm_active |= IFM_10G_LR | IFM_FDX; 2867 break; 2868 case IXGBE_LINK_SPEED_1GB_FULL: 2869 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2870 break; 2871 } 2872 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LRM) 2873 switch (adapter->link_speed) { 2874 case IXGBE_LINK_SPEED_10GB_FULL: 2875 ifmr->ifm_active |= IFM_10G_LRM | IFM_FDX; 2876 break; 2877 case IXGBE_LINK_SPEED_1GB_FULL: 2878 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2879 break; 2880 } 2881 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR || 2882 layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 2883 switch (adapter->link_speed) { 2884 case IXGBE_LINK_SPEED_10GB_FULL: 2885 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2886 break; 2887 case IXGBE_LINK_SPEED_1GB_FULL: 2888 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 2889 break; 2890 } 2891 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 2892 switch (adapter->link_speed) { 2893 case IXGBE_LINK_SPEED_10GB_FULL: 2894 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2895 break; 2896 } 2897 /* 2898 * XXX: These need to use the proper media types once 2899 * they're added. 2900 */ 2901 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 2902 switch (adapter->link_speed) { 2903 case IXGBE_LINK_SPEED_10GB_FULL: 2904 ifmr->ifm_active |= IFM_10G_KR | IFM_FDX; 2905 break; 2906 case IXGBE_LINK_SPEED_2_5GB_FULL: 2907 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2908 break; 2909 case IXGBE_LINK_SPEED_1GB_FULL: 2910 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2911 break; 2912 } 2913 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 || 2914 layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX || 2915 layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 2916 switch (adapter->link_speed) { 2917 case IXGBE_LINK_SPEED_10GB_FULL: 2918 ifmr->ifm_active |= IFM_10G_KX4 | IFM_FDX; 2919 break; 2920 case IXGBE_LINK_SPEED_2_5GB_FULL: 2921 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2922 break; 2923 case IXGBE_LINK_SPEED_1GB_FULL: 2924 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2925 break; 2926 } 2927 2928 /* If nothing is recognized... */ 2929 #if 0 2930 if (IFM_SUBTYPE(ifmr->ifm_active) == 0) 2931 ifmr->ifm_active |= IFM_UNKNOWN; 2932 #endif 2933 2934 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 2935 2936 /* Display current flow control setting used on link */ 2937 if (hw->fc.current_mode == ixgbe_fc_rx_pause || 2938 hw->fc.current_mode == ixgbe_fc_full) 2939 ifmr->ifm_active |= IFM_ETH_RXPAUSE; 2940 if (hw->fc.current_mode == ixgbe_fc_tx_pause || 2941 hw->fc.current_mode == ixgbe_fc_full) 2942 ifmr->ifm_active |= IFM_ETH_TXPAUSE; 2943 2944 return; 2945 } /* ixgbe_media_status */ 2946 2947 /************************************************************************ 2948 * ixgbe_media_change - Media Ioctl callback 2949 * 2950 * Called when the user changes speed/duplex using 2951 * media/mediopt option with ifconfig. 2952 ************************************************************************/ 2953 static int 2954 ixgbe_media_change(struct ifnet *ifp) 2955 { 2956 struct adapter *adapter = ifp->if_softc; 2957 struct ifmedia *ifm = &adapter->media; 2958 struct ixgbe_hw *hw = &adapter->hw; 2959 ixgbe_link_speed speed = 0; 2960 ixgbe_link_speed link_caps = 0; 2961 bool negotiate = false; 2962 s32 err = IXGBE_NOT_IMPLEMENTED; 2963 2964 INIT_DEBUGOUT("ixgbe_media_change: begin"); 2965 2966 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 2967 return (EINVAL); 2968 2969 if (hw->phy.media_type == ixgbe_media_type_backplane) 2970 return (EPERM); 2971 2972 /* 2973 * We don't actually need to check against the supported 2974 * media types of the adapter; ifmedia will take care of 2975 * that for us. 2976 */ 2977 switch (IFM_SUBTYPE(ifm->ifm_media)) { 2978 case IFM_AUTO: 2979 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 2980 &negotiate); 2981 if (err != IXGBE_SUCCESS) { 2982 device_printf(adapter->dev, "Unable to determine " 2983 "supported advertise speeds\n"); 2984 return (ENODEV); 2985 } 2986 speed |= link_caps; 2987 break; 2988 case IFM_10G_T: 2989 case IFM_10G_LRM: 2990 case IFM_10G_LR: 2991 case IFM_10G_TWINAX: 2992 case IFM_10G_SR: 2993 case IFM_10G_CX4: 2994 case IFM_10G_KR: 2995 case IFM_10G_KX4: 2996 speed |= IXGBE_LINK_SPEED_10GB_FULL; 2997 break; 2998 case IFM_5000_T: 2999 speed |= IXGBE_LINK_SPEED_5GB_FULL; 3000 break; 3001 case IFM_2500_T: 3002 case IFM_2500_KX: 3003 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 3004 break; 3005 case IFM_1000_T: 3006 case IFM_1000_LX: 3007 case IFM_1000_SX: 3008 case IFM_1000_KX: 3009 speed |= IXGBE_LINK_SPEED_1GB_FULL; 3010 break; 3011 case IFM_100_TX: 3012 speed |= IXGBE_LINK_SPEED_100_FULL; 3013 break; 3014 case IFM_10_T: 3015 speed |= IXGBE_LINK_SPEED_10_FULL; 3016 break; 3017 case IFM_NONE: 3018 break; 3019 default: 3020 goto invalid; 3021 } 3022 3023 hw->mac.autotry_restart = TRUE; 3024 hw->mac.ops.setup_link(hw, speed, TRUE); 3025 adapter->advertise = 0; 3026 if (IFM_SUBTYPE(ifm->ifm_media) != IFM_AUTO) { 3027 if ((speed & IXGBE_LINK_SPEED_10GB_FULL) != 0) 3028 adapter->advertise |= 1 << 2; 3029 if ((speed & IXGBE_LINK_SPEED_1GB_FULL) != 0) 3030 adapter->advertise |= 1 << 1; 3031 if ((speed & IXGBE_LINK_SPEED_100_FULL) != 0) 3032 adapter->advertise |= 1 << 0; 3033 if ((speed & IXGBE_LINK_SPEED_10_FULL) != 0) 3034 adapter->advertise |= 1 << 3; 3035 if ((speed & IXGBE_LINK_SPEED_2_5GB_FULL) != 0) 3036 adapter->advertise |= 1 << 4; 3037 if ((speed & IXGBE_LINK_SPEED_5GB_FULL) != 0) 3038 adapter->advertise |= 1 << 5; 3039 } 3040 3041 return (0); 3042 3043 invalid: 3044 device_printf(adapter->dev, "Invalid media type!\n"); 3045 3046 return (EINVAL); 3047 } /* ixgbe_media_change */ 3048 3049 /************************************************************************ 3050 * ixgbe_msix_link - Link status change ISR (MSI/MSI-X) 3051 ************************************************************************/ 3052 static int 3053 ixgbe_msix_link(void *arg) 3054 { 3055 struct adapter *adapter = arg; 3056 struct ixgbe_hw *hw = &adapter->hw; 3057 u32 eicr, eicr_mask; 3058 s32 retval; 3059 3060 ++adapter->link_irq.ev_count; 3061 3062 /* Pause other interrupts */ 3063 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_OTHER); 3064 3065 /* First get the cause */ 3066 /* 3067 * The specifications of 82598, 82599, X540 and X550 say EICS register 3068 * is write only. However, Linux says it is a workaround for silicon 3069 * errata to read EICS instead of EICR to get interrupt cause. It seems 3070 * there is a problem about read clear mechanism for EICR register. 3071 */ 3072 eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 3073 /* Be sure the queue bits are not cleared */ 3074 eicr &= ~IXGBE_EICR_RTX_QUEUE; 3075 /* Clear interrupt with write */ 3076 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr); 3077 3078 if (ixgbe_is_sfp(hw)) { 3079 /* Pluggable optics-related interrupt */ 3080 if (hw->mac.type >= ixgbe_mac_X540) 3081 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 3082 else 3083 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 3084 3085 /* 3086 * An interrupt might not arrive when a module is inserted. 3087 * When an link status change interrupt occurred and the driver 3088 * still regard SFP as unplugged, issue the module softint 3089 * and then issue LSC interrupt. 3090 */ 3091 if ((eicr & eicr_mask) 3092 || ((hw->phy.sfp_type == ixgbe_sfp_type_not_present) 3093 && (eicr & IXGBE_EICR_LSC))) { 3094 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 3095 softint_schedule(adapter->mod_si); 3096 } 3097 3098 if ((hw->mac.type == ixgbe_mac_82599EB) && 3099 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 3100 IXGBE_WRITE_REG(hw, IXGBE_EICR, 3101 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 3102 ixgbe_schedule_msf_tasklet(adapter); 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 /* OK to schedule workqueues. */ 4128 adapter->schedule_wqs_ok = true; 4129 4130 /* And now turn on interrupts */ 4131 ixgbe_enable_intr(adapter); 4132 4133 /* Enable the use of the MBX by the VF's */ 4134 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) { 4135 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 4136 ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD; 4137 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 4138 } 4139 4140 /* Update saved flags. See ixgbe_ifflags_cb() */ 4141 adapter->if_flags = ifp->if_flags; 4142 adapter->ec_capenable = adapter->osdep.ec.ec_capenable; 4143 4144 /* Now inform the stack we're ready */ 4145 ifp->if_flags |= IFF_RUNNING; 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 ixgbe_schedule_msf_tasklet(adapter); 4676 out: 4677 IXGBE_CORE_UNLOCK(adapter); 4678 } /* ixgbe_handle_mod */ 4679 4680 4681 /************************************************************************ 4682 * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts 4683 ************************************************************************/ 4684 static void 4685 ixgbe_handle_msf(struct work *wk, void *context) 4686 { 4687 struct adapter *adapter = context; 4688 struct ifnet *ifp = adapter->ifp; 4689 struct ixgbe_hw *hw = &adapter->hw; 4690 u32 autoneg; 4691 bool negotiate; 4692 4693 /* 4694 * Hold the IFNET_LOCK across this entire call. This will 4695 * prevent additional changes to adapter->phy_layer 4696 * and serialize calls to this tasklet. We cannot hold the 4697 * CORE_LOCK while calling into the ifmedia functions as 4698 * they may block while allocating memory. 4699 */ 4700 IFNET_LOCK(ifp); 4701 4702 IXGBE_CORE_LOCK(adapter); 4703 adapter->msf_pending = false; 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 adapter->msf_pending = false; 4756 } 4757 4758 /************************************************************************ 4759 * ixgbe_stop - Stop the hardware 4760 * 4761 * Disables all traffic on the adapter by issuing a 4762 * global reset on the MAC and deallocates TX/RX buffers. 4763 ************************************************************************/ 4764 static void 4765 ixgbe_stop(void *arg) 4766 { 4767 struct ifnet *ifp; 4768 struct adapter *adapter = arg; 4769 struct ixgbe_hw *hw = &adapter->hw; 4770 4771 ifp = adapter->ifp; 4772 4773 KASSERT(mutex_owned(&adapter->core_mtx)); 4774 4775 INIT_DEBUGOUT("ixgbe_stop: begin\n"); 4776 ixgbe_disable_intr(adapter); 4777 callout_stop(&adapter->timer); 4778 4779 /* Don't schedule workqueues. */ 4780 adapter->schedule_wqs_ok = false; 4781 4782 /* Let the stack know...*/ 4783 ifp->if_flags &= ~IFF_RUNNING; 4784 4785 ixgbe_reset_hw(hw); 4786 hw->adapter_stopped = FALSE; 4787 ixgbe_stop_adapter(hw); 4788 if (hw->mac.type == ixgbe_mac_82599EB) 4789 ixgbe_stop_mac_link_on_d3_82599(hw); 4790 /* Turn off the laser - noop with no optics */ 4791 ixgbe_disable_tx_laser(hw); 4792 4793 /* Update the stack */ 4794 adapter->link_up = FALSE; 4795 ixgbe_update_link_status(adapter); 4796 4797 /* reprogram the RAR[0] in case user changed it. */ 4798 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 4799 4800 return; 4801 } /* ixgbe_stop */ 4802 4803 /************************************************************************ 4804 * ixgbe_update_link_status - Update OS on link state 4805 * 4806 * Note: Only updates the OS on the cached link state. 4807 * The real check of the hardware only happens with 4808 * a link interrupt. 4809 ************************************************************************/ 4810 static void 4811 ixgbe_update_link_status(struct adapter *adapter) 4812 { 4813 struct ifnet *ifp = adapter->ifp; 4814 device_t dev = adapter->dev; 4815 struct ixgbe_hw *hw = &adapter->hw; 4816 4817 KASSERT(mutex_owned(&adapter->core_mtx)); 4818 4819 if (adapter->link_up) { 4820 if (adapter->link_active != LINK_STATE_UP) { 4821 /* 4822 * To eliminate influence of the previous state 4823 * in the same way as ixgbe_init_locked(). 4824 */ 4825 struct ix_queue *que = adapter->queues; 4826 for (int i = 0; i < adapter->num_queues; i++, que++) 4827 que->eitr_setting = 0; 4828 4829 if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){ 4830 /* 4831 * Discard count for both MAC Local Fault and 4832 * Remote Fault because those registers are 4833 * valid only when the link speed is up and 4834 * 10Gbps. 4835 */ 4836 IXGBE_READ_REG(hw, IXGBE_MLFC); 4837 IXGBE_READ_REG(hw, IXGBE_MRFC); 4838 } 4839 4840 if (bootverbose) { 4841 const char *bpsmsg; 4842 4843 switch (adapter->link_speed) { 4844 case IXGBE_LINK_SPEED_10GB_FULL: 4845 bpsmsg = "10 Gbps"; 4846 break; 4847 case IXGBE_LINK_SPEED_5GB_FULL: 4848 bpsmsg = "5 Gbps"; 4849 break; 4850 case IXGBE_LINK_SPEED_2_5GB_FULL: 4851 bpsmsg = "2.5 Gbps"; 4852 break; 4853 case IXGBE_LINK_SPEED_1GB_FULL: 4854 bpsmsg = "1 Gbps"; 4855 break; 4856 case IXGBE_LINK_SPEED_100_FULL: 4857 bpsmsg = "100 Mbps"; 4858 break; 4859 case IXGBE_LINK_SPEED_10_FULL: 4860 bpsmsg = "10 Mbps"; 4861 break; 4862 default: 4863 bpsmsg = "unknown speed"; 4864 break; 4865 } 4866 device_printf(dev, "Link is up %s %s \n", 4867 bpsmsg, "Full Duplex"); 4868 } 4869 adapter->link_active = LINK_STATE_UP; 4870 /* Update any Flow Control changes */ 4871 ixgbe_fc_enable(&adapter->hw); 4872 /* Update DMA coalescing config */ 4873 ixgbe_config_dmac(adapter); 4874 if_link_state_change(ifp, LINK_STATE_UP); 4875 4876 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4877 ixgbe_ping_all_vfs(adapter); 4878 } 4879 } else { 4880 /* 4881 * Do it when link active changes to DOWN. i.e. 4882 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN 4883 * b) LINK_STATE_UP -> LINK_STATE_DOWN 4884 */ 4885 if (adapter->link_active != LINK_STATE_DOWN) { 4886 if (bootverbose) 4887 device_printf(dev, "Link is Down\n"); 4888 if_link_state_change(ifp, LINK_STATE_DOWN); 4889 adapter->link_active = LINK_STATE_DOWN; 4890 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4891 ixgbe_ping_all_vfs(adapter); 4892 ixgbe_drain_all(adapter); 4893 } 4894 } 4895 } /* ixgbe_update_link_status */ 4896 4897 /************************************************************************ 4898 * ixgbe_config_dmac - Configure DMA Coalescing 4899 ************************************************************************/ 4900 static void 4901 ixgbe_config_dmac(struct adapter *adapter) 4902 { 4903 struct ixgbe_hw *hw = &adapter->hw; 4904 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 4905 4906 if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config) 4907 return; 4908 4909 if (dcfg->watchdog_timer ^ adapter->dmac || 4910 dcfg->link_speed ^ adapter->link_speed) { 4911 dcfg->watchdog_timer = adapter->dmac; 4912 dcfg->fcoe_en = false; 4913 dcfg->link_speed = adapter->link_speed; 4914 dcfg->num_tcs = 1; 4915 4916 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 4917 dcfg->watchdog_timer, dcfg->link_speed); 4918 4919 hw->mac.ops.dmac_config(hw); 4920 } 4921 } /* ixgbe_config_dmac */ 4922 4923 /************************************************************************ 4924 * ixgbe_enable_intr 4925 ************************************************************************/ 4926 static void 4927 ixgbe_enable_intr(struct adapter *adapter) 4928 { 4929 struct ixgbe_hw *hw = &adapter->hw; 4930 struct ix_queue *que = adapter->queues; 4931 u32 mask, fwsm; 4932 4933 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 4934 4935 switch (adapter->hw.mac.type) { 4936 case ixgbe_mac_82599EB: 4937 mask |= IXGBE_EIMS_ECC; 4938 /* Temperature sensor on some adapters */ 4939 mask |= IXGBE_EIMS_GPI_SDP0; 4940 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 4941 mask |= IXGBE_EIMS_GPI_SDP1; 4942 mask |= IXGBE_EIMS_GPI_SDP2; 4943 break; 4944 case ixgbe_mac_X540: 4945 /* Detect if Thermal Sensor is enabled */ 4946 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 4947 if (fwsm & IXGBE_FWSM_TS_ENABLED) 4948 mask |= IXGBE_EIMS_TS; 4949 mask |= IXGBE_EIMS_ECC; 4950 break; 4951 case ixgbe_mac_X550: 4952 /* MAC thermal sensor is automatically enabled */ 4953 mask |= IXGBE_EIMS_TS; 4954 mask |= IXGBE_EIMS_ECC; 4955 break; 4956 case ixgbe_mac_X550EM_x: 4957 case ixgbe_mac_X550EM_a: 4958 /* Some devices use SDP0 for important information */ 4959 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 4960 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP || 4961 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N || 4962 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 4963 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 4964 if (hw->phy.type == ixgbe_phy_x550em_ext_t) 4965 mask |= IXGBE_EICR_GPI_SDP0_X540; 4966 mask |= IXGBE_EIMS_ECC; 4967 break; 4968 default: 4969 break; 4970 } 4971 4972 /* Enable Fan Failure detection */ 4973 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4974 mask |= IXGBE_EIMS_GPI_SDP1; 4975 /* Enable SR-IOV */ 4976 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4977 mask |= IXGBE_EIMS_MAILBOX; 4978 /* Enable Flow Director */ 4979 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 4980 mask |= IXGBE_EIMS_FLOW_DIR; 4981 4982 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 4983 4984 /* With MSI-X we use auto clear */ 4985 if (adapter->msix_mem) { 4986 mask = IXGBE_EIMS_ENABLE_MASK; 4987 /* Don't autoclear Link */ 4988 mask &= ~IXGBE_EIMS_OTHER; 4989 mask &= ~IXGBE_EIMS_LSC; 4990 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 4991 mask &= ~IXGBE_EIMS_MAILBOX; 4992 IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask); 4993 } 4994 4995 /* 4996 * Now enable all queues, this is done separately to 4997 * allow for handling the extended (beyond 32) MSI-X 4998 * vectors that can be used by 82599 4999 */ 5000 for (int i = 0; i < adapter->num_queues; i++, que++) 5001 ixgbe_enable_queue(adapter, que->msix); 5002 5003 IXGBE_WRITE_FLUSH(hw); 5004 5005 } /* ixgbe_enable_intr */ 5006 5007 /************************************************************************ 5008 * ixgbe_disable_intr_internal 5009 ************************************************************************/ 5010 static void 5011 ixgbe_disable_intr_internal(struct adapter *adapter, bool nestok) 5012 { 5013 struct ix_queue *que = adapter->queues; 5014 5015 /* disable interrupts other than queues */ 5016 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE); 5017 5018 if (adapter->msix_mem) 5019 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 5020 5021 for (int i = 0; i < adapter->num_queues; i++, que++) 5022 ixgbe_disable_queue_internal(adapter, que->msix, nestok); 5023 5024 IXGBE_WRITE_FLUSH(&adapter->hw); 5025 5026 } /* ixgbe_do_disable_intr_internal */ 5027 5028 /************************************************************************ 5029 * ixgbe_disable_intr 5030 ************************************************************************/ 5031 static void 5032 ixgbe_disable_intr(struct adapter *adapter) 5033 { 5034 5035 ixgbe_disable_intr_internal(adapter, true); 5036 } /* ixgbe_disable_intr */ 5037 5038 /************************************************************************ 5039 * ixgbe_ensure_disabled_intr 5040 ************************************************************************/ 5041 void 5042 ixgbe_ensure_disabled_intr(struct adapter *adapter) 5043 { 5044 5045 ixgbe_disable_intr_internal(adapter, false); 5046 } /* ixgbe_ensure_disabled_intr */ 5047 5048 /************************************************************************ 5049 * ixgbe_legacy_irq - Legacy Interrupt Service routine 5050 ************************************************************************/ 5051 static int 5052 ixgbe_legacy_irq(void *arg) 5053 { 5054 struct ix_queue *que = arg; 5055 struct adapter *adapter = que->adapter; 5056 struct ixgbe_hw *hw = &adapter->hw; 5057 struct ifnet *ifp = adapter->ifp; 5058 struct tx_ring *txr = adapter->tx_rings; 5059 bool more = false; 5060 u32 eicr, eicr_mask; 5061 5062 /* Silicon errata #26 on 82598 */ 5063 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 5064 5065 eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 5066 5067 adapter->stats.pf.legint.ev_count++; 5068 ++que->irqs.ev_count; 5069 if (eicr == 0) { 5070 adapter->stats.pf.intzero.ev_count++; 5071 if ((ifp->if_flags & IFF_UP) != 0) 5072 ixgbe_enable_intr(adapter); 5073 return 0; 5074 } 5075 5076 if ((ifp->if_flags & IFF_RUNNING) != 0) { 5077 /* 5078 * The same as ixgbe_msix_que() about "que->txrx_use_workqueue". 5079 */ 5080 que->txrx_use_workqueue = adapter->txrx_use_workqueue; 5081 5082 #ifdef __NetBSD__ 5083 /* Don't run ixgbe_rxeof in interrupt context */ 5084 more = true; 5085 #else 5086 more = ixgbe_rxeof(que); 5087 #endif 5088 5089 IXGBE_TX_LOCK(txr); 5090 ixgbe_txeof(txr); 5091 #ifdef notyet 5092 if (!ixgbe_ring_empty(ifp, txr->br)) 5093 ixgbe_start_locked(ifp, txr); 5094 #endif 5095 IXGBE_TX_UNLOCK(txr); 5096 } 5097 5098 /* Check for fan failure */ 5099 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 5100 ixgbe_check_fan_failure(adapter, eicr, true); 5101 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 5102 } 5103 5104 /* Link status change */ 5105 if (eicr & IXGBE_EICR_LSC) 5106 softint_schedule(adapter->link_si); 5107 5108 if (ixgbe_is_sfp(hw)) { 5109 /* Pluggable optics-related interrupt */ 5110 if (hw->mac.type >= ixgbe_mac_X540) 5111 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 5112 else 5113 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 5114 5115 if (eicr & eicr_mask) { 5116 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 5117 softint_schedule(adapter->mod_si); 5118 } 5119 5120 if ((hw->mac.type == ixgbe_mac_82599EB) && 5121 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 5122 IXGBE_WRITE_REG(hw, IXGBE_EICR, 5123 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 5124 ixgbe_schedule_msf_tasklet(adapter); 5125 } 5126 } 5127 5128 /* External PHY interrupt */ 5129 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 5130 (eicr & IXGBE_EICR_GPI_SDP0_X540)) 5131 softint_schedule(adapter->phy_si); 5132 5133 if (more) { 5134 que->req.ev_count++; 5135 ixgbe_sched_handle_que(adapter, que); 5136 } else 5137 ixgbe_enable_intr(adapter); 5138 5139 return 1; 5140 } /* ixgbe_legacy_irq */ 5141 5142 /************************************************************************ 5143 * ixgbe_free_pciintr_resources 5144 ************************************************************************/ 5145 static void 5146 ixgbe_free_pciintr_resources(struct adapter *adapter) 5147 { 5148 struct ix_queue *que = adapter->queues; 5149 int rid; 5150 5151 /* 5152 * Release all msix queue resources: 5153 */ 5154 for (int i = 0; i < adapter->num_queues; i++, que++) { 5155 if (que->res != NULL) { 5156 pci_intr_disestablish(adapter->osdep.pc, 5157 adapter->osdep.ihs[i]); 5158 adapter->osdep.ihs[i] = NULL; 5159 } 5160 } 5161 5162 /* Clean the Legacy or Link interrupt last */ 5163 if (adapter->vector) /* we are doing MSIX */ 5164 rid = adapter->vector; 5165 else 5166 rid = 0; 5167 5168 if (adapter->osdep.ihs[rid] != NULL) { 5169 pci_intr_disestablish(adapter->osdep.pc, 5170 adapter->osdep.ihs[rid]); 5171 adapter->osdep.ihs[rid] = NULL; 5172 } 5173 5174 if (adapter->osdep.intrs != NULL) { 5175 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 5176 adapter->osdep.nintrs); 5177 adapter->osdep.intrs = NULL; 5178 } 5179 } /* ixgbe_free_pciintr_resources */ 5180 5181 /************************************************************************ 5182 * ixgbe_free_pci_resources 5183 ************************************************************************/ 5184 static void 5185 ixgbe_free_pci_resources(struct adapter *adapter) 5186 { 5187 5188 ixgbe_free_pciintr_resources(adapter); 5189 5190 if (adapter->osdep.mem_size != 0) { 5191 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 5192 adapter->osdep.mem_bus_space_handle, 5193 adapter->osdep.mem_size); 5194 } 5195 5196 } /* ixgbe_free_pci_resources */ 5197 5198 /************************************************************************ 5199 * ixgbe_set_sysctl_value 5200 ************************************************************************/ 5201 static void 5202 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 5203 const char *description, int *limit, int value) 5204 { 5205 device_t dev = adapter->dev; 5206 struct sysctllog **log; 5207 const struct sysctlnode *rnode, *cnode; 5208 5209 /* 5210 * It's not required to check recovery mode because this function never 5211 * touches hardware. 5212 */ 5213 5214 log = &adapter->sysctllog; 5215 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 5216 aprint_error_dev(dev, "could not create sysctl root\n"); 5217 return; 5218 } 5219 if (sysctl_createv(log, 0, &rnode, &cnode, 5220 CTLFLAG_READWRITE, CTLTYPE_INT, 5221 name, SYSCTL_DESCR(description), 5222 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 5223 aprint_error_dev(dev, "could not create sysctl\n"); 5224 *limit = value; 5225 } /* ixgbe_set_sysctl_value */ 5226 5227 /************************************************************************ 5228 * ixgbe_sysctl_flowcntl 5229 * 5230 * SYSCTL wrapper around setting Flow Control 5231 ************************************************************************/ 5232 static int 5233 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 5234 { 5235 struct sysctlnode node = *rnode; 5236 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5237 int error, fc; 5238 5239 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5240 return (EPERM); 5241 5242 fc = adapter->hw.fc.current_mode; 5243 node.sysctl_data = &fc; 5244 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5245 if (error != 0 || newp == NULL) 5246 return error; 5247 5248 /* Don't bother if it's not changed */ 5249 if (fc == adapter->hw.fc.current_mode) 5250 return (0); 5251 5252 return ixgbe_set_flowcntl(adapter, fc); 5253 } /* ixgbe_sysctl_flowcntl */ 5254 5255 /************************************************************************ 5256 * ixgbe_set_flowcntl - Set flow control 5257 * 5258 * Flow control values: 5259 * 0 - off 5260 * 1 - rx pause 5261 * 2 - tx pause 5262 * 3 - full 5263 ************************************************************************/ 5264 static int 5265 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 5266 { 5267 switch (fc) { 5268 case ixgbe_fc_rx_pause: 5269 case ixgbe_fc_tx_pause: 5270 case ixgbe_fc_full: 5271 adapter->hw.fc.requested_mode = fc; 5272 if (adapter->num_queues > 1) 5273 ixgbe_disable_rx_drop(adapter); 5274 break; 5275 case ixgbe_fc_none: 5276 adapter->hw.fc.requested_mode = ixgbe_fc_none; 5277 if (adapter->num_queues > 1) 5278 ixgbe_enable_rx_drop(adapter); 5279 break; 5280 default: 5281 return (EINVAL); 5282 } 5283 5284 #if 0 /* XXX NetBSD */ 5285 /* Don't autoneg if forcing a value */ 5286 adapter->hw.fc.disable_fc_autoneg = TRUE; 5287 #endif 5288 ixgbe_fc_enable(&adapter->hw); 5289 5290 return (0); 5291 } /* ixgbe_set_flowcntl */ 5292 5293 /************************************************************************ 5294 * ixgbe_enable_rx_drop 5295 * 5296 * Enable the hardware to drop packets when the buffer is 5297 * full. This is useful with multiqueue, so that no single 5298 * queue being full stalls the entire RX engine. We only 5299 * enable this when Multiqueue is enabled AND Flow Control 5300 * is disabled. 5301 ************************************************************************/ 5302 static void 5303 ixgbe_enable_rx_drop(struct adapter *adapter) 5304 { 5305 struct ixgbe_hw *hw = &adapter->hw; 5306 struct rx_ring *rxr; 5307 u32 srrctl; 5308 5309 for (int i = 0; i < adapter->num_queues; i++) { 5310 rxr = &adapter->rx_rings[i]; 5311 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5312 srrctl |= IXGBE_SRRCTL_DROP_EN; 5313 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5314 } 5315 5316 /* enable drop for each vf */ 5317 for (int i = 0; i < adapter->num_vfs; i++) { 5318 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5319 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 5320 IXGBE_QDE_ENABLE)); 5321 } 5322 } /* ixgbe_enable_rx_drop */ 5323 5324 /************************************************************************ 5325 * ixgbe_disable_rx_drop 5326 ************************************************************************/ 5327 static void 5328 ixgbe_disable_rx_drop(struct adapter *adapter) 5329 { 5330 struct ixgbe_hw *hw = &adapter->hw; 5331 struct rx_ring *rxr; 5332 u32 srrctl; 5333 5334 for (int i = 0; i < adapter->num_queues; i++) { 5335 rxr = &adapter->rx_rings[i]; 5336 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5337 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 5338 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5339 } 5340 5341 /* disable drop for each vf */ 5342 for (int i = 0; i < adapter->num_vfs; i++) { 5343 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5344 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 5345 } 5346 } /* ixgbe_disable_rx_drop */ 5347 5348 /************************************************************************ 5349 * ixgbe_sysctl_advertise 5350 * 5351 * SYSCTL wrapper around setting advertised speed 5352 ************************************************************************/ 5353 static int 5354 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 5355 { 5356 struct sysctlnode node = *rnode; 5357 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5358 int error = 0, advertise; 5359 5360 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5361 return (EPERM); 5362 5363 advertise = adapter->advertise; 5364 node.sysctl_data = &advertise; 5365 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5366 if (error != 0 || newp == NULL) 5367 return error; 5368 5369 return ixgbe_set_advertise(adapter, advertise); 5370 } /* ixgbe_sysctl_advertise */ 5371 5372 /************************************************************************ 5373 * ixgbe_set_advertise - Control advertised link speed 5374 * 5375 * Flags: 5376 * 0x00 - Default (all capable link speed) 5377 * 0x01 - advertise 100 Mb 5378 * 0x02 - advertise 1G 5379 * 0x04 - advertise 10G 5380 * 0x08 - advertise 10 Mb 5381 * 0x10 - advertise 2.5G 5382 * 0x20 - advertise 5G 5383 ************************************************************************/ 5384 static int 5385 ixgbe_set_advertise(struct adapter *adapter, int advertise) 5386 { 5387 device_t dev; 5388 struct ixgbe_hw *hw; 5389 ixgbe_link_speed speed = 0; 5390 ixgbe_link_speed link_caps = 0; 5391 s32 err = IXGBE_NOT_IMPLEMENTED; 5392 bool negotiate = FALSE; 5393 5394 /* Checks to validate new value */ 5395 if (adapter->advertise == advertise) /* no change */ 5396 return (0); 5397 5398 dev = adapter->dev; 5399 hw = &adapter->hw; 5400 5401 /* No speed changes for backplane media */ 5402 if (hw->phy.media_type == ixgbe_media_type_backplane) 5403 return (ENODEV); 5404 5405 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5406 (hw->phy.multispeed_fiber))) { 5407 device_printf(dev, 5408 "Advertised speed can only be set on copper or " 5409 "multispeed fiber media types.\n"); 5410 return (EINVAL); 5411 } 5412 5413 if (advertise < 0x0 || advertise > 0x2f) { 5414 device_printf(dev, 5415 "Invalid advertised speed; valid modes are 0x0 through 0x7\n"); 5416 return (EINVAL); 5417 } 5418 5419 if (hw->mac.ops.get_link_capabilities) { 5420 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 5421 &negotiate); 5422 if (err != IXGBE_SUCCESS) { 5423 device_printf(dev, "Unable to determine supported advertise speeds\n"); 5424 return (ENODEV); 5425 } 5426 } 5427 5428 /* Set new value and report new advertised mode */ 5429 if (advertise & 0x1) { 5430 if (!(link_caps & IXGBE_LINK_SPEED_100_FULL)) { 5431 device_printf(dev, "Interface does not support 100Mb advertised speed\n"); 5432 return (EINVAL); 5433 } 5434 speed |= IXGBE_LINK_SPEED_100_FULL; 5435 } 5436 if (advertise & 0x2) { 5437 if (!(link_caps & IXGBE_LINK_SPEED_1GB_FULL)) { 5438 device_printf(dev, "Interface does not support 1Gb advertised speed\n"); 5439 return (EINVAL); 5440 } 5441 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5442 } 5443 if (advertise & 0x4) { 5444 if (!(link_caps & IXGBE_LINK_SPEED_10GB_FULL)) { 5445 device_printf(dev, "Interface does not support 10Gb advertised speed\n"); 5446 return (EINVAL); 5447 } 5448 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5449 } 5450 if (advertise & 0x8) { 5451 if (!(link_caps & IXGBE_LINK_SPEED_10_FULL)) { 5452 device_printf(dev, "Interface does not support 10Mb advertised speed\n"); 5453 return (EINVAL); 5454 } 5455 speed |= IXGBE_LINK_SPEED_10_FULL; 5456 } 5457 if (advertise & 0x10) { 5458 if (!(link_caps & IXGBE_LINK_SPEED_2_5GB_FULL)) { 5459 device_printf(dev, "Interface does not support 2.5Gb advertised speed\n"); 5460 return (EINVAL); 5461 } 5462 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 5463 } 5464 if (advertise & 0x20) { 5465 if (!(link_caps & IXGBE_LINK_SPEED_5GB_FULL)) { 5466 device_printf(dev, "Interface does not support 5Gb advertised speed\n"); 5467 return (EINVAL); 5468 } 5469 speed |= IXGBE_LINK_SPEED_5GB_FULL; 5470 } 5471 if (advertise == 0) 5472 speed = link_caps; /* All capable link speed */ 5473 5474 hw->mac.autotry_restart = TRUE; 5475 hw->mac.ops.setup_link(hw, speed, TRUE); 5476 adapter->advertise = advertise; 5477 5478 return (0); 5479 } /* ixgbe_set_advertise */ 5480 5481 /************************************************************************ 5482 * ixgbe_get_advertise - Get current advertised speed settings 5483 * 5484 * Formatted for sysctl usage. 5485 * Flags: 5486 * 0x01 - advertise 100 Mb 5487 * 0x02 - advertise 1G 5488 * 0x04 - advertise 10G 5489 * 0x08 - advertise 10 Mb (yes, Mb) 5490 * 0x10 - advertise 2.5G 5491 * 0x20 - advertise 5G 5492 ************************************************************************/ 5493 static int 5494 ixgbe_get_advertise(struct adapter *adapter) 5495 { 5496 struct ixgbe_hw *hw = &adapter->hw; 5497 int speed; 5498 ixgbe_link_speed link_caps = 0; 5499 s32 err; 5500 bool negotiate = FALSE; 5501 5502 /* 5503 * Advertised speed means nothing unless it's copper or 5504 * multi-speed fiber 5505 */ 5506 if (!(hw->phy.media_type == ixgbe_media_type_copper) && 5507 !(hw->phy.multispeed_fiber)) 5508 return (0); 5509 5510 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, &negotiate); 5511 if (err != IXGBE_SUCCESS) 5512 return (0); 5513 5514 speed = 5515 ((link_caps & IXGBE_LINK_SPEED_10GB_FULL) ? 0x04 : 0) | 5516 ((link_caps & IXGBE_LINK_SPEED_1GB_FULL) ? 0x02 : 0) | 5517 ((link_caps & IXGBE_LINK_SPEED_100_FULL) ? 0x01 : 0) | 5518 ((link_caps & IXGBE_LINK_SPEED_10_FULL) ? 0x08 : 0) | 5519 ((link_caps & IXGBE_LINK_SPEED_2_5GB_FULL) ? 0x10 : 0) | 5520 ((link_caps & IXGBE_LINK_SPEED_5GB_FULL) ? 0x20 : 0); 5521 5522 return speed; 5523 } /* ixgbe_get_advertise */ 5524 5525 /************************************************************************ 5526 * ixgbe_sysctl_dmac - Manage DMA Coalescing 5527 * 5528 * Control values: 5529 * 0/1 - off / on (use default value of 1000) 5530 * 5531 * Legal timer values are: 5532 * 50,100,250,500,1000,2000,5000,10000 5533 * 5534 * Turning off interrupt moderation will also turn this off. 5535 ************************************************************************/ 5536 static int 5537 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5538 { 5539 struct sysctlnode node = *rnode; 5540 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5541 struct ifnet *ifp = adapter->ifp; 5542 int error; 5543 int newval; 5544 5545 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5546 return (EPERM); 5547 5548 newval = adapter->dmac; 5549 node.sysctl_data = &newval; 5550 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5551 if ((error) || (newp == NULL)) 5552 return (error); 5553 5554 switch (newval) { 5555 case 0: 5556 /* Disabled */ 5557 adapter->dmac = 0; 5558 break; 5559 case 1: 5560 /* Enable and use default */ 5561 adapter->dmac = 1000; 5562 break; 5563 case 50: 5564 case 100: 5565 case 250: 5566 case 500: 5567 case 1000: 5568 case 2000: 5569 case 5000: 5570 case 10000: 5571 /* Legal values - allow */ 5572 adapter->dmac = newval; 5573 break; 5574 default: 5575 /* Do nothing, illegal value */ 5576 return (EINVAL); 5577 } 5578 5579 /* Re-initialize hardware if it's already running */ 5580 if (ifp->if_flags & IFF_RUNNING) 5581 ifp->if_init(ifp); 5582 5583 return (0); 5584 } 5585 5586 #ifdef IXGBE_DEBUG 5587 /************************************************************************ 5588 * ixgbe_sysctl_power_state 5589 * 5590 * Sysctl to test power states 5591 * Values: 5592 * 0 - set device to D0 5593 * 3 - set device to D3 5594 * (none) - get current device power state 5595 ************************************************************************/ 5596 static int 5597 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5598 { 5599 #ifdef notyet 5600 struct sysctlnode node = *rnode; 5601 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5602 device_t dev = adapter->dev; 5603 int curr_ps, new_ps, error = 0; 5604 5605 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5606 return (EPERM); 5607 5608 curr_ps = new_ps = pci_get_powerstate(dev); 5609 5610 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5611 if ((error) || (req->newp == NULL)) 5612 return (error); 5613 5614 if (new_ps == curr_ps) 5615 return (0); 5616 5617 if (new_ps == 3 && curr_ps == 0) 5618 error = DEVICE_SUSPEND(dev); 5619 else if (new_ps == 0 && curr_ps == 3) 5620 error = DEVICE_RESUME(dev); 5621 else 5622 return (EINVAL); 5623 5624 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5625 5626 return (error); 5627 #else 5628 return 0; 5629 #endif 5630 } /* ixgbe_sysctl_power_state */ 5631 #endif 5632 5633 /************************************************************************ 5634 * ixgbe_sysctl_wol_enable 5635 * 5636 * Sysctl to enable/disable the WoL capability, 5637 * if supported by the adapter. 5638 * 5639 * Values: 5640 * 0 - disabled 5641 * 1 - enabled 5642 ************************************************************************/ 5643 static int 5644 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5645 { 5646 struct sysctlnode node = *rnode; 5647 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5648 struct ixgbe_hw *hw = &adapter->hw; 5649 bool new_wol_enabled; 5650 int error = 0; 5651 5652 /* 5653 * It's not required to check recovery mode because this function never 5654 * touches hardware. 5655 */ 5656 new_wol_enabled = hw->wol_enabled; 5657 node.sysctl_data = &new_wol_enabled; 5658 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5659 if ((error) || (newp == NULL)) 5660 return (error); 5661 if (new_wol_enabled == hw->wol_enabled) 5662 return (0); 5663 5664 if (new_wol_enabled && !adapter->wol_support) 5665 return (ENODEV); 5666 else 5667 hw->wol_enabled = new_wol_enabled; 5668 5669 return (0); 5670 } /* ixgbe_sysctl_wol_enable */ 5671 5672 /************************************************************************ 5673 * ixgbe_sysctl_wufc - Wake Up Filter Control 5674 * 5675 * Sysctl to enable/disable the types of packets that the 5676 * adapter will wake up on upon receipt. 5677 * Flags: 5678 * 0x1 - Link Status Change 5679 * 0x2 - Magic Packet 5680 * 0x4 - Direct Exact 5681 * 0x8 - Directed Multicast 5682 * 0x10 - Broadcast 5683 * 0x20 - ARP/IPv4 Request Packet 5684 * 0x40 - Direct IPv4 Packet 5685 * 0x80 - Direct IPv6 Packet 5686 * 5687 * Settings not listed above will cause the sysctl to return an error. 5688 ************************************************************************/ 5689 static int 5690 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5691 { 5692 struct sysctlnode node = *rnode; 5693 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5694 int error = 0; 5695 u32 new_wufc; 5696 5697 /* 5698 * It's not required to check recovery mode because this function never 5699 * touches hardware. 5700 */ 5701 new_wufc = adapter->wufc; 5702 node.sysctl_data = &new_wufc; 5703 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5704 if ((error) || (newp == NULL)) 5705 return (error); 5706 if (new_wufc == adapter->wufc) 5707 return (0); 5708 5709 if (new_wufc & 0xffffff00) 5710 return (EINVAL); 5711 5712 new_wufc &= 0xff; 5713 new_wufc |= (0xffffff & adapter->wufc); 5714 adapter->wufc = new_wufc; 5715 5716 return (0); 5717 } /* ixgbe_sysctl_wufc */ 5718 5719 #ifdef IXGBE_DEBUG 5720 /************************************************************************ 5721 * ixgbe_sysctl_print_rss_config 5722 ************************************************************************/ 5723 static int 5724 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5725 { 5726 #ifdef notyet 5727 struct sysctlnode node = *rnode; 5728 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5729 struct ixgbe_hw *hw = &adapter->hw; 5730 device_t dev = adapter->dev; 5731 struct sbuf *buf; 5732 int error = 0, reta_size; 5733 u32 reg; 5734 5735 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5736 return (EPERM); 5737 5738 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5739 if (!buf) { 5740 device_printf(dev, "Could not allocate sbuf for output.\n"); 5741 return (ENOMEM); 5742 } 5743 5744 // TODO: use sbufs to make a string to print out 5745 /* Set multiplier for RETA setup and table size based on MAC */ 5746 switch (adapter->hw.mac.type) { 5747 case ixgbe_mac_X550: 5748 case ixgbe_mac_X550EM_x: 5749 case ixgbe_mac_X550EM_a: 5750 reta_size = 128; 5751 break; 5752 default: 5753 reta_size = 32; 5754 break; 5755 } 5756 5757 /* Print out the redirection table */ 5758 sbuf_cat(buf, "\n"); 5759 for (int i = 0; i < reta_size; i++) { 5760 if (i < 32) { 5761 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5762 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5763 } else { 5764 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5765 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5766 } 5767 } 5768 5769 // TODO: print more config 5770 5771 error = sbuf_finish(buf); 5772 if (error) 5773 device_printf(dev, "Error finishing sbuf: %d\n", error); 5774 5775 sbuf_delete(buf); 5776 #endif 5777 return (0); 5778 } /* ixgbe_sysctl_print_rss_config */ 5779 #endif /* IXGBE_DEBUG */ 5780 5781 /************************************************************************ 5782 * ixgbe_sysctl_phy_temp - Retrieve temperature of PHY 5783 * 5784 * For X552/X557-AT devices using an external PHY 5785 ************************************************************************/ 5786 static int 5787 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5788 { 5789 struct sysctlnode node = *rnode; 5790 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5791 struct ixgbe_hw *hw = &adapter->hw; 5792 int val; 5793 u16 reg; 5794 int error; 5795 5796 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5797 return (EPERM); 5798 5799 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5800 device_printf(adapter->dev, 5801 "Device has no supported external thermal sensor.\n"); 5802 return (ENODEV); 5803 } 5804 5805 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5806 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5807 device_printf(adapter->dev, 5808 "Error reading from PHY's current temperature register\n"); 5809 return (EAGAIN); 5810 } 5811 5812 node.sysctl_data = &val; 5813 5814 /* Shift temp for output */ 5815 val = reg >> 8; 5816 5817 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5818 if ((error) || (newp == NULL)) 5819 return (error); 5820 5821 return (0); 5822 } /* ixgbe_sysctl_phy_temp */ 5823 5824 /************************************************************************ 5825 * ixgbe_sysctl_phy_overtemp_occurred 5826 * 5827 * Reports (directly from the PHY) whether the current PHY 5828 * temperature is over the overtemp threshold. 5829 ************************************************************************/ 5830 static int 5831 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 5832 { 5833 struct sysctlnode node = *rnode; 5834 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5835 struct ixgbe_hw *hw = &adapter->hw; 5836 int val, error; 5837 u16 reg; 5838 5839 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5840 return (EPERM); 5841 5842 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5843 device_printf(adapter->dev, 5844 "Device has no supported external thermal sensor.\n"); 5845 return (ENODEV); 5846 } 5847 5848 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 5849 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5850 device_printf(adapter->dev, 5851 "Error reading from PHY's temperature status register\n"); 5852 return (EAGAIN); 5853 } 5854 5855 node.sysctl_data = &val; 5856 5857 /* Get occurrence bit */ 5858 val = !!(reg & 0x4000); 5859 5860 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5861 if ((error) || (newp == NULL)) 5862 return (error); 5863 5864 return (0); 5865 } /* ixgbe_sysctl_phy_overtemp_occurred */ 5866 5867 /************************************************************************ 5868 * ixgbe_sysctl_eee_state 5869 * 5870 * Sysctl to set EEE power saving feature 5871 * Values: 5872 * 0 - disable EEE 5873 * 1 - enable EEE 5874 * (none) - get current device EEE state 5875 ************************************************************************/ 5876 static int 5877 ixgbe_sysctl_eee_state(SYSCTLFN_ARGS) 5878 { 5879 struct sysctlnode node = *rnode; 5880 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5881 struct ifnet *ifp = adapter->ifp; 5882 device_t dev = adapter->dev; 5883 int curr_eee, new_eee, error = 0; 5884 s32 retval; 5885 5886 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5887 return (EPERM); 5888 5889 curr_eee = new_eee = !!(adapter->feat_en & IXGBE_FEATURE_EEE); 5890 node.sysctl_data = &new_eee; 5891 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5892 if ((error) || (newp == NULL)) 5893 return (error); 5894 5895 /* Nothing to do */ 5896 if (new_eee == curr_eee) 5897 return (0); 5898 5899 /* Not supported */ 5900 if (!(adapter->feat_cap & IXGBE_FEATURE_EEE)) 5901 return (EINVAL); 5902 5903 /* Bounds checking */ 5904 if ((new_eee < 0) || (new_eee > 1)) 5905 return (EINVAL); 5906 5907 retval = ixgbe_setup_eee(&adapter->hw, new_eee); 5908 if (retval) { 5909 device_printf(dev, "Error in EEE setup: 0x%08X\n", retval); 5910 return (EINVAL); 5911 } 5912 5913 /* Restart auto-neg */ 5914 ifp->if_init(ifp); 5915 5916 device_printf(dev, "New EEE state: %d\n", new_eee); 5917 5918 /* Cache new value */ 5919 if (new_eee) 5920 adapter->feat_en |= IXGBE_FEATURE_EEE; 5921 else 5922 adapter->feat_en &= ~IXGBE_FEATURE_EEE; 5923 5924 return (error); 5925 } /* ixgbe_sysctl_eee_state */ 5926 5927 #define PRINTQS(adapter, regname) \ 5928 do { \ 5929 struct ixgbe_hw *_hw = &(adapter)->hw; \ 5930 int _i; \ 5931 \ 5932 printf("%s: %s", device_xname((adapter)->dev), #regname); \ 5933 for (_i = 0; _i < (adapter)->num_queues; _i++) { \ 5934 printf((_i == 0) ? "\t" : " "); \ 5935 printf("%08x", IXGBE_READ_REG(_hw, \ 5936 IXGBE_##regname(_i))); \ 5937 } \ 5938 printf("\n"); \ 5939 } while (0) 5940 5941 /************************************************************************ 5942 * ixgbe_print_debug_info 5943 * 5944 * Called only when em_display_debug_stats is enabled. 5945 * Provides a way to take a look at important statistics 5946 * maintained by the driver and hardware. 5947 ************************************************************************/ 5948 static void 5949 ixgbe_print_debug_info(struct adapter *adapter) 5950 { 5951 device_t dev = adapter->dev; 5952 struct ixgbe_hw *hw = &adapter->hw; 5953 int table_size; 5954 int i; 5955 5956 switch (adapter->hw.mac.type) { 5957 case ixgbe_mac_X550: 5958 case ixgbe_mac_X550EM_x: 5959 case ixgbe_mac_X550EM_a: 5960 table_size = 128; 5961 break; 5962 default: 5963 table_size = 32; 5964 break; 5965 } 5966 5967 device_printf(dev, "[E]RETA:\n"); 5968 for (i = 0; i < table_size; i++) { 5969 if (i < 32) 5970 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 5971 IXGBE_RETA(i))); 5972 else 5973 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 5974 IXGBE_ERETA(i - 32))); 5975 } 5976 5977 device_printf(dev, "queue:"); 5978 for (i = 0; i < adapter->num_queues; i++) { 5979 printf((i == 0) ? "\t" : " "); 5980 printf("%8d", i); 5981 } 5982 printf("\n"); 5983 PRINTQS(adapter, RDBAL); 5984 PRINTQS(adapter, RDBAH); 5985 PRINTQS(adapter, RDLEN); 5986 PRINTQS(adapter, SRRCTL); 5987 PRINTQS(adapter, RDH); 5988 PRINTQS(adapter, RDT); 5989 PRINTQS(adapter, RXDCTL); 5990 5991 device_printf(dev, "RQSMR:"); 5992 for (i = 0; i < adapter->num_queues / 4; i++) { 5993 printf((i == 0) ? "\t" : " "); 5994 printf("%08x", IXGBE_READ_REG(hw, IXGBE_RQSMR(i))); 5995 } 5996 printf("\n"); 5997 5998 device_printf(dev, "disabled_count:"); 5999 for (i = 0; i < adapter->num_queues; i++) { 6000 printf((i == 0) ? "\t" : " "); 6001 printf("%8d", adapter->queues[i].disabled_count); 6002 } 6003 printf("\n"); 6004 6005 device_printf(dev, "EIMS:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIMS)); 6006 if (hw->mac.type != ixgbe_mac_82598EB) { 6007 device_printf(dev, "EIMS_EX(0):\t%08x\n", 6008 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(0))); 6009 device_printf(dev, "EIMS_EX(1):\t%08x\n", 6010 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(1))); 6011 } 6012 } /* ixgbe_print_debug_info */ 6013 6014 /************************************************************************ 6015 * ixgbe_sysctl_debug 6016 ************************************************************************/ 6017 static int 6018 ixgbe_sysctl_debug(SYSCTLFN_ARGS) 6019 { 6020 struct sysctlnode node = *rnode; 6021 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6022 int error, result = 0; 6023 6024 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6025 return (EPERM); 6026 6027 node.sysctl_data = &result; 6028 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6029 6030 if (error || newp == NULL) 6031 return error; 6032 6033 if (result == 1) 6034 ixgbe_print_debug_info(adapter); 6035 6036 return 0; 6037 } /* ixgbe_sysctl_debug */ 6038 6039 /************************************************************************ 6040 * ixgbe_init_device_features 6041 ************************************************************************/ 6042 static void 6043 ixgbe_init_device_features(struct adapter *adapter) 6044 { 6045 adapter->feat_cap = IXGBE_FEATURE_NETMAP 6046 | IXGBE_FEATURE_RSS 6047 | IXGBE_FEATURE_MSI 6048 | IXGBE_FEATURE_MSIX 6049 | IXGBE_FEATURE_LEGACY_IRQ 6050 | IXGBE_FEATURE_LEGACY_TX; 6051 6052 /* Set capabilities first... */ 6053 switch (adapter->hw.mac.type) { 6054 case ixgbe_mac_82598EB: 6055 if (adapter->hw.device_id == IXGBE_DEV_ID_82598AT) 6056 adapter->feat_cap |= IXGBE_FEATURE_FAN_FAIL; 6057 break; 6058 case ixgbe_mac_X540: 6059 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6060 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6061 if ((adapter->hw.device_id == IXGBE_DEV_ID_X540_BYPASS) && 6062 (adapter->hw.bus.func == 0)) 6063 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6064 break; 6065 case ixgbe_mac_X550: 6066 /* 6067 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6068 * NVM Image version. 6069 */ 6070 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6071 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6072 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6073 break; 6074 case ixgbe_mac_X550EM_x: 6075 /* 6076 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6077 * NVM Image version. 6078 */ 6079 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6080 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6081 break; 6082 case ixgbe_mac_X550EM_a: 6083 /* 6084 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6085 * NVM Image version. 6086 */ 6087 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6088 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6089 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6090 if ((adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T) || 6091 (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)) { 6092 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6093 adapter->feat_cap |= IXGBE_FEATURE_EEE; 6094 } 6095 break; 6096 case ixgbe_mac_82599EB: 6097 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6098 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6099 if ((adapter->hw.device_id == IXGBE_DEV_ID_82599_BYPASS) && 6100 (adapter->hw.bus.func == 0)) 6101 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6102 if (adapter->hw.device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) 6103 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6104 break; 6105 default: 6106 break; 6107 } 6108 6109 /* Enabled by default... */ 6110 /* Fan failure detection */ 6111 if (adapter->feat_cap & IXGBE_FEATURE_FAN_FAIL) 6112 adapter->feat_en |= IXGBE_FEATURE_FAN_FAIL; 6113 /* Netmap */ 6114 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 6115 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 6116 /* EEE */ 6117 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 6118 adapter->feat_en |= IXGBE_FEATURE_EEE; 6119 /* Thermal Sensor */ 6120 if (adapter->feat_cap & IXGBE_FEATURE_TEMP_SENSOR) 6121 adapter->feat_en |= IXGBE_FEATURE_TEMP_SENSOR; 6122 /* 6123 * Recovery mode: 6124 * NetBSD: IXGBE_FEATURE_RECOVERY_MODE will be controlled after reading 6125 * NVM Image version. 6126 */ 6127 6128 /* Enabled via global sysctl... */ 6129 /* Flow Director */ 6130 if (ixgbe_enable_fdir) { 6131 if (adapter->feat_cap & IXGBE_FEATURE_FDIR) 6132 adapter->feat_en |= IXGBE_FEATURE_FDIR; 6133 else 6134 device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled."); 6135 } 6136 /* Legacy (single queue) transmit */ 6137 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 6138 ixgbe_enable_legacy_tx) 6139 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 6140 /* 6141 * Message Signal Interrupts - Extended (MSI-X) 6142 * Normal MSI is only enabled if MSI-X calls fail. 6143 */ 6144 if (!ixgbe_enable_msix) 6145 adapter->feat_cap &= ~IXGBE_FEATURE_MSIX; 6146 /* Receive-Side Scaling (RSS) */ 6147 if ((adapter->feat_cap & IXGBE_FEATURE_RSS) && ixgbe_enable_rss) 6148 adapter->feat_en |= IXGBE_FEATURE_RSS; 6149 6150 /* Disable features with unmet dependencies... */ 6151 /* No MSI-X */ 6152 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) { 6153 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6154 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6155 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6156 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6157 } 6158 } /* ixgbe_init_device_features */ 6159 6160 /************************************************************************ 6161 * ixgbe_probe - Device identification routine 6162 * 6163 * Determines if the driver should be loaded on 6164 * adapter based on its PCI vendor/device ID. 6165 * 6166 * return BUS_PROBE_DEFAULT on success, positive on failure 6167 ************************************************************************/ 6168 static int 6169 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 6170 { 6171 const struct pci_attach_args *pa = aux; 6172 6173 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 6174 } 6175 6176 static const ixgbe_vendor_info_t * 6177 ixgbe_lookup(const struct pci_attach_args *pa) 6178 { 6179 const ixgbe_vendor_info_t *ent; 6180 pcireg_t subid; 6181 6182 INIT_DEBUGOUT("ixgbe_lookup: begin"); 6183 6184 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 6185 return NULL; 6186 6187 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 6188 6189 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 6190 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 6191 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 6192 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 6193 (ent->subvendor_id == 0)) && 6194 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 6195 (ent->subdevice_id == 0))) { 6196 return ent; 6197 } 6198 } 6199 return NULL; 6200 } 6201 6202 static int 6203 ixgbe_ifflags_cb(struct ethercom *ec) 6204 { 6205 struct ifnet *ifp = &ec->ec_if; 6206 struct adapter *adapter = ifp->if_softc; 6207 u_short change; 6208 int rv = 0; 6209 6210 IXGBE_CORE_LOCK(adapter); 6211 6212 change = ifp->if_flags ^ adapter->if_flags; 6213 if (change != 0) 6214 adapter->if_flags = ifp->if_flags; 6215 6216 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) { 6217 rv = ENETRESET; 6218 goto out; 6219 } else if ((change & IFF_PROMISC) != 0) 6220 ixgbe_set_rxfilter(adapter); 6221 6222 /* Check for ec_capenable. */ 6223 change = ec->ec_capenable ^ adapter->ec_capenable; 6224 adapter->ec_capenable = ec->ec_capenable; 6225 if ((change & ~(ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING 6226 | ETHERCAP_VLAN_HWFILTER)) != 0) { 6227 rv = ENETRESET; 6228 goto out; 6229 } 6230 6231 /* 6232 * Special handling is not required for ETHERCAP_VLAN_MTU. 6233 * MAXFRS(MHADD) does not include the 4bytes of the VLAN header. 6234 */ 6235 6236 /* Set up VLAN support and filter */ 6237 if ((change & (ETHERCAP_VLAN_HWTAGGING | ETHERCAP_VLAN_HWFILTER)) != 0) 6238 ixgbe_setup_vlan_hw_support(adapter); 6239 6240 out: 6241 IXGBE_CORE_UNLOCK(adapter); 6242 6243 return rv; 6244 } 6245 6246 /************************************************************************ 6247 * ixgbe_ioctl - Ioctl entry point 6248 * 6249 * Called when the user wants to configure the interface. 6250 * 6251 * return 0 on success, positive on failure 6252 ************************************************************************/ 6253 static int 6254 ixgbe_ioctl(struct ifnet * ifp, u_long command, void *data) 6255 { 6256 struct adapter *adapter = ifp->if_softc; 6257 struct ixgbe_hw *hw = &adapter->hw; 6258 struct ifcapreq *ifcr = data; 6259 struct ifreq *ifr = data; 6260 int error = 0; 6261 int l4csum_en; 6262 const int l4csum = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx | 6263 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx; 6264 6265 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6266 return (EPERM); 6267 6268 switch (command) { 6269 case SIOCSIFFLAGS: 6270 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 6271 break; 6272 case SIOCADDMULTI: 6273 case SIOCDELMULTI: 6274 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 6275 break; 6276 case SIOCSIFMEDIA: 6277 case SIOCGIFMEDIA: 6278 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 6279 break; 6280 case SIOCSIFCAP: 6281 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 6282 break; 6283 case SIOCSIFMTU: 6284 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 6285 break; 6286 #ifdef __NetBSD__ 6287 case SIOCINITIFADDR: 6288 IOCTL_DEBUGOUT("ioctl: SIOCINITIFADDR"); 6289 break; 6290 case SIOCGIFFLAGS: 6291 IOCTL_DEBUGOUT("ioctl: SIOCGIFFLAGS"); 6292 break; 6293 case SIOCGIFAFLAG_IN: 6294 IOCTL_DEBUGOUT("ioctl: SIOCGIFAFLAG_IN"); 6295 break; 6296 case SIOCGIFADDR: 6297 IOCTL_DEBUGOUT("ioctl: SIOCGIFADDR"); 6298 break; 6299 case SIOCGIFMTU: 6300 IOCTL_DEBUGOUT("ioctl: SIOCGIFMTU (Get Interface MTU)"); 6301 break; 6302 case SIOCGIFCAP: 6303 IOCTL_DEBUGOUT("ioctl: SIOCGIFCAP (Get IF cap)"); 6304 break; 6305 case SIOCGETHERCAP: 6306 IOCTL_DEBUGOUT("ioctl: SIOCGETHERCAP (Get ethercap)"); 6307 break; 6308 case SIOCGLIFADDR: 6309 IOCTL_DEBUGOUT("ioctl: SIOCGLIFADDR (Get Interface addr)"); 6310 break; 6311 case SIOCZIFDATA: 6312 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 6313 hw->mac.ops.clear_hw_cntrs(hw); 6314 ixgbe_clear_evcnt(adapter); 6315 break; 6316 case SIOCAIFADDR: 6317 IOCTL_DEBUGOUT("ioctl: SIOCAIFADDR (add/chg IF alias)"); 6318 break; 6319 #endif 6320 default: 6321 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 6322 break; 6323 } 6324 6325 switch (command) { 6326 case SIOCGI2C: 6327 { 6328 struct ixgbe_i2c_req i2c; 6329 6330 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 6331 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 6332 if (error != 0) 6333 break; 6334 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 6335 error = EINVAL; 6336 break; 6337 } 6338 if (i2c.len > sizeof(i2c.data)) { 6339 error = EINVAL; 6340 break; 6341 } 6342 6343 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 6344 i2c.dev_addr, i2c.data); 6345 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 6346 break; 6347 } 6348 case SIOCSIFCAP: 6349 /* Layer-4 Rx checksum offload has to be turned on and 6350 * off as a unit. 6351 */ 6352 l4csum_en = ifcr->ifcr_capenable & l4csum; 6353 if (l4csum_en != l4csum && l4csum_en != 0) 6354 return EINVAL; 6355 /*FALLTHROUGH*/ 6356 case SIOCADDMULTI: 6357 case SIOCDELMULTI: 6358 case SIOCSIFFLAGS: 6359 case SIOCSIFMTU: 6360 default: 6361 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 6362 return error; 6363 if ((ifp->if_flags & IFF_RUNNING) == 0) 6364 ; 6365 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 6366 IXGBE_CORE_LOCK(adapter); 6367 if ((ifp->if_flags & IFF_RUNNING) != 0) 6368 ixgbe_init_locked(adapter); 6369 ixgbe_recalculate_max_frame(adapter); 6370 IXGBE_CORE_UNLOCK(adapter); 6371 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 6372 /* 6373 * Multicast list has changed; set the hardware filter 6374 * accordingly. 6375 */ 6376 IXGBE_CORE_LOCK(adapter); 6377 ixgbe_disable_intr(adapter); 6378 ixgbe_set_rxfilter(adapter); 6379 ixgbe_enable_intr(adapter); 6380 IXGBE_CORE_UNLOCK(adapter); 6381 } 6382 return 0; 6383 } 6384 6385 return error; 6386 } /* ixgbe_ioctl */ 6387 6388 /************************************************************************ 6389 * ixgbe_check_fan_failure 6390 ************************************************************************/ 6391 static void 6392 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt) 6393 { 6394 u32 mask; 6395 6396 mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) : 6397 IXGBE_ESDP_SDP1; 6398 6399 if (reg & mask) 6400 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n"); 6401 } /* ixgbe_check_fan_failure */ 6402 6403 /************************************************************************ 6404 * ixgbe_handle_que 6405 ************************************************************************/ 6406 static void 6407 ixgbe_handle_que(void *context) 6408 { 6409 struct ix_queue *que = context; 6410 struct adapter *adapter = que->adapter; 6411 struct tx_ring *txr = que->txr; 6412 struct ifnet *ifp = adapter->ifp; 6413 bool more = false; 6414 6415 que->handleq.ev_count++; 6416 6417 if (ifp->if_flags & IFF_RUNNING) { 6418 more = ixgbe_rxeof(que); 6419 IXGBE_TX_LOCK(txr); 6420 more |= ixgbe_txeof(txr); 6421 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 6422 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 6423 ixgbe_mq_start_locked(ifp, txr); 6424 /* Only for queue 0 */ 6425 /* NetBSD still needs this for CBQ */ 6426 if ((&adapter->queues[0] == que) 6427 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 6428 ixgbe_legacy_start_locked(ifp, txr); 6429 IXGBE_TX_UNLOCK(txr); 6430 } 6431 6432 if (more) { 6433 que->req.ev_count++; 6434 ixgbe_sched_handle_que(adapter, que); 6435 } else if (que->res != NULL) { 6436 /* Re-enable this interrupt */ 6437 ixgbe_enable_queue(adapter, que->msix); 6438 } else 6439 ixgbe_enable_intr(adapter); 6440 6441 return; 6442 } /* ixgbe_handle_que */ 6443 6444 /************************************************************************ 6445 * ixgbe_handle_que_work 6446 ************************************************************************/ 6447 static void 6448 ixgbe_handle_que_work(struct work *wk, void *context) 6449 { 6450 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 6451 6452 /* 6453 * "enqueued flag" is not required here. 6454 * See ixgbe_msix_que(). 6455 */ 6456 ixgbe_handle_que(que); 6457 } 6458 6459 /************************************************************************ 6460 * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler 6461 ************************************************************************/ 6462 static int 6463 ixgbe_allocate_legacy(struct adapter *adapter, 6464 const struct pci_attach_args *pa) 6465 { 6466 device_t dev = adapter->dev; 6467 struct ix_queue *que = adapter->queues; 6468 struct tx_ring *txr = adapter->tx_rings; 6469 int counts[PCI_INTR_TYPE_SIZE]; 6470 pci_intr_type_t intr_type, max_type; 6471 char intrbuf[PCI_INTRSTR_LEN]; 6472 char wqname[MAXCOMLEN]; 6473 const char *intrstr = NULL; 6474 int defertx_error = 0, error; 6475 6476 /* We allocate a single interrupt resource */ 6477 max_type = PCI_INTR_TYPE_MSI; 6478 counts[PCI_INTR_TYPE_MSIX] = 0; 6479 counts[PCI_INTR_TYPE_MSI] = 6480 (adapter->feat_en & IXGBE_FEATURE_MSI) ? 1 : 0; 6481 /* Check not feat_en but feat_cap to fallback to INTx */ 6482 counts[PCI_INTR_TYPE_INTX] = 6483 (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) ? 1 : 0; 6484 6485 alloc_retry: 6486 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 6487 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 6488 return ENXIO; 6489 } 6490 adapter->osdep.nintrs = 1; 6491 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 6492 intrbuf, sizeof(intrbuf)); 6493 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 6494 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 6495 device_xname(dev)); 6496 intr_type = pci_intr_type(adapter->osdep.pc, adapter->osdep.intrs[0]); 6497 if (adapter->osdep.ihs[0] == NULL) { 6498 aprint_error_dev(dev,"unable to establish %s\n", 6499 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 6500 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6501 adapter->osdep.intrs = NULL; 6502 switch (intr_type) { 6503 case PCI_INTR_TYPE_MSI: 6504 /* The next try is for INTx: Disable MSI */ 6505 max_type = PCI_INTR_TYPE_INTX; 6506 counts[PCI_INTR_TYPE_INTX] = 1; 6507 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6508 if (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) { 6509 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6510 goto alloc_retry; 6511 } else 6512 break; 6513 case PCI_INTR_TYPE_INTX: 6514 default: 6515 /* See below */ 6516 break; 6517 } 6518 } 6519 if (intr_type == PCI_INTR_TYPE_INTX) { 6520 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6521 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6522 } 6523 if (adapter->osdep.ihs[0] == NULL) { 6524 aprint_error_dev(dev, 6525 "couldn't establish interrupt%s%s\n", 6526 intrstr ? " at " : "", intrstr ? intrstr : ""); 6527 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6528 adapter->osdep.intrs = NULL; 6529 return ENXIO; 6530 } 6531 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 6532 /* 6533 * Try allocating a fast interrupt and the associated deferred 6534 * processing contexts. 6535 */ 6536 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6537 txr->txr_si = 6538 softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6539 ixgbe_deferred_mq_start, txr); 6540 6541 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6542 defertx_error = workqueue_create(&adapter->txr_wq, wqname, 6543 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, 6544 IPL_NET, IXGBE_WORKQUEUE_FLAGS); 6545 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6546 } 6547 que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6548 ixgbe_handle_que, que); 6549 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6550 error = workqueue_create(&adapter->que_wq, wqname, 6551 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6552 IXGBE_WORKQUEUE_FLAGS); 6553 6554 if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) 6555 && ((txr->txr_si == NULL) || defertx_error != 0)) 6556 || (que->que_si == NULL) || error != 0) { 6557 aprint_error_dev(dev, 6558 "could not establish software interrupts\n"); 6559 6560 return ENXIO; 6561 } 6562 /* For simplicity in the handlers */ 6563 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 6564 6565 return (0); 6566 } /* ixgbe_allocate_legacy */ 6567 6568 /************************************************************************ 6569 * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers 6570 ************************************************************************/ 6571 static int 6572 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 6573 { 6574 device_t dev = adapter->dev; 6575 struct ix_queue *que = adapter->queues; 6576 struct tx_ring *txr = adapter->tx_rings; 6577 pci_chipset_tag_t pc; 6578 char intrbuf[PCI_INTRSTR_LEN]; 6579 char intr_xname[32]; 6580 char wqname[MAXCOMLEN]; 6581 const char *intrstr = NULL; 6582 int error, vector = 0; 6583 int cpu_id = 0; 6584 kcpuset_t *affinity; 6585 #ifdef RSS 6586 unsigned int rss_buckets = 0; 6587 kcpuset_t cpu_mask; 6588 #endif 6589 6590 pc = adapter->osdep.pc; 6591 #ifdef RSS 6592 /* 6593 * If we're doing RSS, the number of queues needs to 6594 * match the number of RSS buckets that are configured. 6595 * 6596 * + If there's more queues than RSS buckets, we'll end 6597 * up with queues that get no traffic. 6598 * 6599 * + If there's more RSS buckets than queues, we'll end 6600 * up having multiple RSS buckets map to the same queue, 6601 * so there'll be some contention. 6602 */ 6603 rss_buckets = rss_getnumbuckets(); 6604 if ((adapter->feat_en & IXGBE_FEATURE_RSS) && 6605 (adapter->num_queues != rss_buckets)) { 6606 device_printf(dev, 6607 "%s: number of queues (%d) != number of RSS buckets (%d)" 6608 "; performance will be impacted.\n", 6609 __func__, adapter->num_queues, rss_buckets); 6610 } 6611 #endif 6612 6613 adapter->osdep.nintrs = adapter->num_queues + 1; 6614 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 6615 adapter->osdep.nintrs) != 0) { 6616 aprint_error_dev(dev, 6617 "failed to allocate MSI-X interrupt\n"); 6618 return (ENXIO); 6619 } 6620 6621 kcpuset_create(&affinity, false); 6622 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 6623 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 6624 device_xname(dev), i); 6625 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 6626 sizeof(intrbuf)); 6627 #ifdef IXGBE_MPSAFE 6628 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 6629 true); 6630 #endif 6631 /* Set the handler function */ 6632 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 6633 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 6634 intr_xname); 6635 if (que->res == NULL) { 6636 aprint_error_dev(dev, 6637 "Failed to register QUE handler\n"); 6638 error = ENXIO; 6639 goto err_out; 6640 } 6641 que->msix = vector; 6642 adapter->active_queues |= 1ULL << que->msix; 6643 6644 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 6645 #ifdef RSS 6646 /* 6647 * The queue ID is used as the RSS layer bucket ID. 6648 * We look up the queue ID -> RSS CPU ID and select 6649 * that. 6650 */ 6651 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 6652 CPU_SETOF(cpu_id, &cpu_mask); 6653 #endif 6654 } else { 6655 /* 6656 * Bind the MSI-X vector, and thus the 6657 * rings to the corresponding CPU. 6658 * 6659 * This just happens to match the default RSS 6660 * round-robin bucket -> queue -> CPU allocation. 6661 */ 6662 if (adapter->num_queues > 1) 6663 cpu_id = i; 6664 } 6665 /* Round-robin affinity */ 6666 kcpuset_zero(affinity); 6667 kcpuset_set(affinity, cpu_id % ncpu); 6668 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 6669 NULL); 6670 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 6671 intrstr); 6672 if (error == 0) { 6673 #if 1 /* def IXGBE_DEBUG */ 6674 #ifdef RSS 6675 aprintf_normal(", bound RSS bucket %d to CPU %d", i, 6676 cpu_id % ncpu); 6677 #else 6678 aprint_normal(", bound queue %d to cpu %d", i, 6679 cpu_id % ncpu); 6680 #endif 6681 #endif /* IXGBE_DEBUG */ 6682 } 6683 aprint_normal("\n"); 6684 6685 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6686 txr->txr_si = softint_establish( 6687 SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6688 ixgbe_deferred_mq_start, txr); 6689 if (txr->txr_si == NULL) { 6690 aprint_error_dev(dev, 6691 "couldn't establish software interrupt\n"); 6692 error = ENXIO; 6693 goto err_out; 6694 } 6695 } 6696 que->que_si 6697 = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6698 ixgbe_handle_que, que); 6699 if (que->que_si == NULL) { 6700 aprint_error_dev(dev, 6701 "couldn't establish software interrupt\n"); 6702 error = ENXIO; 6703 goto err_out; 6704 } 6705 } 6706 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6707 error = workqueue_create(&adapter->txr_wq, wqname, 6708 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6709 IXGBE_WORKQUEUE_FLAGS); 6710 if (error) { 6711 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 6712 goto err_out; 6713 } 6714 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6715 6716 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6717 error = workqueue_create(&adapter->que_wq, wqname, 6718 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6719 IXGBE_WORKQUEUE_FLAGS); 6720 if (error) { 6721 aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n"); 6722 goto err_out; 6723 } 6724 6725 /* and Link */ 6726 cpu_id++; 6727 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 6728 adapter->vector = vector; 6729 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 6730 sizeof(intrbuf)); 6731 #ifdef IXGBE_MPSAFE 6732 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 6733 true); 6734 #endif 6735 /* Set the link handler function */ 6736 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 6737 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_link, adapter, 6738 intr_xname); 6739 if (adapter->osdep.ihs[vector] == NULL) { 6740 aprint_error_dev(dev, "Failed to register LINK handler\n"); 6741 error = ENXIO; 6742 goto err_out; 6743 } 6744 /* Round-robin affinity */ 6745 kcpuset_zero(affinity); 6746 kcpuset_set(affinity, cpu_id % ncpu); 6747 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 6748 NULL); 6749 6750 aprint_normal_dev(dev, 6751 "for link, interrupting at %s", intrstr); 6752 if (error == 0) 6753 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 6754 else 6755 aprint_normal("\n"); 6756 6757 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 6758 adapter->mbx_si = 6759 softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6760 ixgbe_handle_mbx, adapter); 6761 if (adapter->mbx_si == NULL) { 6762 aprint_error_dev(dev, 6763 "could not establish software interrupts\n"); 6764 6765 error = ENXIO; 6766 goto err_out; 6767 } 6768 } 6769 6770 kcpuset_destroy(affinity); 6771 aprint_normal_dev(dev, 6772 "Using MSI-X interrupts with %d vectors\n", vector + 1); 6773 6774 return (0); 6775 6776 err_out: 6777 kcpuset_destroy(affinity); 6778 ixgbe_free_softint(adapter); 6779 ixgbe_free_pciintr_resources(adapter); 6780 return (error); 6781 } /* ixgbe_allocate_msix */ 6782 6783 /************************************************************************ 6784 * ixgbe_configure_interrupts 6785 * 6786 * Setup MSI-X, MSI, or legacy interrupts (in that order). 6787 * This will also depend on user settings. 6788 ************************************************************************/ 6789 static int 6790 ixgbe_configure_interrupts(struct adapter *adapter) 6791 { 6792 device_t dev = adapter->dev; 6793 struct ixgbe_mac_info *mac = &adapter->hw.mac; 6794 int want, queues, msgs; 6795 6796 /* Default to 1 queue if MSI-X setup fails */ 6797 adapter->num_queues = 1; 6798 6799 /* Override by tuneable */ 6800 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) 6801 goto msi; 6802 6803 /* 6804 * NetBSD only: Use single vector MSI when number of CPU is 1 to save 6805 * interrupt slot. 6806 */ 6807 if (ncpu == 1) 6808 goto msi; 6809 6810 /* First try MSI-X */ 6811 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 6812 msgs = MIN(msgs, IXG_MAX_NINTR); 6813 if (msgs < 2) 6814 goto msi; 6815 6816 adapter->msix_mem = (void *)1; /* XXX */ 6817 6818 /* Figure out a reasonable auto config value */ 6819 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 6820 6821 #ifdef RSS 6822 /* If we're doing RSS, clamp at the number of RSS buckets */ 6823 if (adapter->feat_en & IXGBE_FEATURE_RSS) 6824 queues = uimin(queues, rss_getnumbuckets()); 6825 #endif 6826 if (ixgbe_num_queues > queues) { 6827 aprint_error_dev(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues); 6828 ixgbe_num_queues = queues; 6829 } 6830 6831 if (ixgbe_num_queues != 0) 6832 queues = ixgbe_num_queues; 6833 else 6834 queues = uimin(queues, 6835 uimin(mac->max_tx_queues, mac->max_rx_queues)); 6836 6837 /* reflect correct sysctl value */ 6838 ixgbe_num_queues = queues; 6839 6840 /* 6841 * Want one vector (RX/TX pair) per queue 6842 * plus an additional for Link. 6843 */ 6844 want = queues + 1; 6845 if (msgs >= want) 6846 msgs = want; 6847 else { 6848 aprint_error_dev(dev, "MSI-X Configuration Problem, " 6849 "%d vectors but %d queues wanted!\n", 6850 msgs, want); 6851 goto msi; 6852 } 6853 adapter->num_queues = queues; 6854 adapter->feat_en |= IXGBE_FEATURE_MSIX; 6855 return (0); 6856 6857 /* 6858 * MSI-X allocation failed or provided us with 6859 * less vectors than needed. Free MSI-X resources 6860 * and we'll try enabling MSI. 6861 */ 6862 msi: 6863 /* Without MSI-X, some features are no longer supported */ 6864 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6865 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6866 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6867 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6868 6869 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 6870 adapter->msix_mem = NULL; /* XXX */ 6871 if (msgs > 1) 6872 msgs = 1; 6873 if (msgs != 0) { 6874 msgs = 1; 6875 adapter->feat_en |= IXGBE_FEATURE_MSI; 6876 return (0); 6877 } 6878 6879 if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) { 6880 aprint_error_dev(dev, 6881 "Device does not support legacy interrupts.\n"); 6882 return 1; 6883 } 6884 6885 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6886 6887 return (0); 6888 } /* ixgbe_configure_interrupts */ 6889 6890 6891 /************************************************************************ 6892 * ixgbe_handle_link - Tasklet for MSI-X Link interrupts 6893 * 6894 * Done outside of interrupt context since the driver might sleep 6895 ************************************************************************/ 6896 static void 6897 ixgbe_handle_link(void *context) 6898 { 6899 struct adapter *adapter = context; 6900 struct ixgbe_hw *hw = &adapter->hw; 6901 6902 IXGBE_CORE_LOCK(adapter); 6903 ++adapter->link_sicount.ev_count; 6904 ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0); 6905 ixgbe_update_link_status(adapter); 6906 6907 /* Re-enable link interrupts */ 6908 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 6909 6910 IXGBE_CORE_UNLOCK(adapter); 6911 } /* ixgbe_handle_link */ 6912 6913 #if 0 6914 /************************************************************************ 6915 * ixgbe_rearm_queues 6916 ************************************************************************/ 6917 static __inline void 6918 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 6919 { 6920 u32 mask; 6921 6922 switch (adapter->hw.mac.type) { 6923 case ixgbe_mac_82598EB: 6924 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 6925 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 6926 break; 6927 case ixgbe_mac_82599EB: 6928 case ixgbe_mac_X540: 6929 case ixgbe_mac_X550: 6930 case ixgbe_mac_X550EM_x: 6931 case ixgbe_mac_X550EM_a: 6932 mask = (queues & 0xFFFFFFFF); 6933 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 6934 mask = (queues >> 32); 6935 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 6936 break; 6937 default: 6938 break; 6939 } 6940 } /* ixgbe_rearm_queues */ 6941 #endif 6942
Indexes created Sun Sep 28 16:09:52 GMT 2025