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