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