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