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