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