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