ixgbe.c revision 1.132
1 /* $NetBSD: ixgbe.c,v 1.132 2018/03/08 02:39:42 knakahara 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 que = adapter->queues; 4233 for (int i = 0; i < adapter->num_queues; i++, que++) { 4234 mutex_enter(&que->im_mtx); 4235 if (que->im_nest == 0) 4236 ixgbe_rearm_queues(adapter, 4237 queues & ((u64)1 << i)); 4238 mutex_exit(&que->im_mtx); 4239 } 4240 } 4241 4242 out: 4243 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4244 return; 4245 4246 watchdog: 4247 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 4248 adapter->ifp->if_flags &= ~IFF_RUNNING; 4249 adapter->watchdog_events.ev_count++; 4250 ixgbe_init_locked(adapter); 4251 } /* ixgbe_local_timer */ 4252 4253 /************************************************************************ 4254 * ixgbe_sfp_probe 4255 * 4256 * Determine if a port had optics inserted. 4257 ************************************************************************/ 4258 static bool 4259 ixgbe_sfp_probe(struct adapter *adapter) 4260 { 4261 struct ixgbe_hw *hw = &adapter->hw; 4262 device_t dev = adapter->dev; 4263 bool result = FALSE; 4264 4265 if ((hw->phy.type == ixgbe_phy_nl) && 4266 (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) { 4267 s32 ret = hw->phy.ops.identify_sfp(hw); 4268 if (ret) 4269 goto out; 4270 ret = hw->phy.ops.reset(hw); 4271 adapter->sfp_probe = FALSE; 4272 if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4273 device_printf(dev,"Unsupported SFP+ module detected!"); 4274 device_printf(dev, 4275 "Reload driver with supported module.\n"); 4276 goto out; 4277 } else 4278 device_printf(dev, "SFP+ module detected!\n"); 4279 /* We now have supported optics */ 4280 result = TRUE; 4281 } 4282 out: 4283 4284 return (result); 4285 } /* ixgbe_sfp_probe */ 4286 4287 /************************************************************************ 4288 * ixgbe_handle_mod - Tasklet for SFP module interrupts 4289 ************************************************************************/ 4290 static void 4291 ixgbe_handle_mod(void *context) 4292 { 4293 struct adapter *adapter = context; 4294 struct ixgbe_hw *hw = &adapter->hw; 4295 device_t dev = adapter->dev; 4296 u32 err, cage_full = 0; 4297 4298 if (adapter->hw.need_crosstalk_fix) { 4299 switch (hw->mac.type) { 4300 case ixgbe_mac_82599EB: 4301 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4302 IXGBE_ESDP_SDP2; 4303 break; 4304 case ixgbe_mac_X550EM_x: 4305 case ixgbe_mac_X550EM_a: 4306 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4307 IXGBE_ESDP_SDP0; 4308 break; 4309 default: 4310 break; 4311 } 4312 4313 if (!cage_full) 4314 return; 4315 } 4316 4317 err = hw->phy.ops.identify_sfp(hw); 4318 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4319 device_printf(dev, 4320 "Unsupported SFP+ module type was detected.\n"); 4321 return; 4322 } 4323 4324 err = hw->mac.ops.setup_sfp(hw); 4325 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4326 device_printf(dev, 4327 "Setup failure - unsupported SFP+ module type.\n"); 4328 return; 4329 } 4330 softint_schedule(adapter->msf_si); 4331 } /* ixgbe_handle_mod */ 4332 4333 4334 /************************************************************************ 4335 * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts 4336 ************************************************************************/ 4337 static void 4338 ixgbe_handle_msf(void *context) 4339 { 4340 struct adapter *adapter = context; 4341 struct ixgbe_hw *hw = &adapter->hw; 4342 u32 autoneg; 4343 bool negotiate; 4344 4345 /* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */ 4346 adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 4347 4348 autoneg = hw->phy.autoneg_advertised; 4349 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 4350 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 4351 else 4352 negotiate = 0; 4353 if (hw->mac.ops.setup_link) 4354 hw->mac.ops.setup_link(hw, autoneg, TRUE); 4355 4356 /* Adjust media types shown in ifconfig */ 4357 ifmedia_removeall(&adapter->media); 4358 ixgbe_add_media_types(adapter); 4359 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 4360 } /* ixgbe_handle_msf */ 4361 4362 /************************************************************************ 4363 * ixgbe_handle_phy - Tasklet for external PHY interrupts 4364 ************************************************************************/ 4365 static void 4366 ixgbe_handle_phy(void *context) 4367 { 4368 struct adapter *adapter = context; 4369 struct ixgbe_hw *hw = &adapter->hw; 4370 int error; 4371 4372 error = hw->phy.ops.handle_lasi(hw); 4373 if (error == IXGBE_ERR_OVERTEMP) 4374 device_printf(adapter->dev, 4375 "CRITICAL: EXTERNAL PHY OVER TEMP!! " 4376 " PHY will downshift to lower power state!\n"); 4377 else if (error) 4378 device_printf(adapter->dev, 4379 "Error handling LASI interrupt: %d\n", error); 4380 } /* ixgbe_handle_phy */ 4381 4382 static void 4383 ixgbe_ifstop(struct ifnet *ifp, int disable) 4384 { 4385 struct adapter *adapter = ifp->if_softc; 4386 4387 IXGBE_CORE_LOCK(adapter); 4388 ixgbe_stop(adapter); 4389 IXGBE_CORE_UNLOCK(adapter); 4390 } 4391 4392 /************************************************************************ 4393 * ixgbe_stop - Stop the hardware 4394 * 4395 * Disables all traffic on the adapter by issuing a 4396 * global reset on the MAC and deallocates TX/RX buffers. 4397 ************************************************************************/ 4398 static void 4399 ixgbe_stop(void *arg) 4400 { 4401 struct ifnet *ifp; 4402 struct adapter *adapter = arg; 4403 struct ixgbe_hw *hw = &adapter->hw; 4404 4405 ifp = adapter->ifp; 4406 4407 KASSERT(mutex_owned(&adapter->core_mtx)); 4408 4409 INIT_DEBUGOUT("ixgbe_stop: begin\n"); 4410 ixgbe_disable_intr(adapter); 4411 callout_stop(&adapter->timer); 4412 4413 /* Let the stack know...*/ 4414 ifp->if_flags &= ~IFF_RUNNING; 4415 4416 ixgbe_reset_hw(hw); 4417 hw->adapter_stopped = FALSE; 4418 ixgbe_stop_adapter(hw); 4419 if (hw->mac.type == ixgbe_mac_82599EB) 4420 ixgbe_stop_mac_link_on_d3_82599(hw); 4421 /* Turn off the laser - noop with no optics */ 4422 ixgbe_disable_tx_laser(hw); 4423 4424 /* Update the stack */ 4425 adapter->link_up = FALSE; 4426 ixgbe_update_link_status(adapter); 4427 4428 /* reprogram the RAR[0] in case user changed it. */ 4429 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 4430 4431 return; 4432 } /* ixgbe_stop */ 4433 4434 /************************************************************************ 4435 * ixgbe_update_link_status - Update OS on link state 4436 * 4437 * Note: Only updates the OS on the cached link state. 4438 * The real check of the hardware only happens with 4439 * a link interrupt. 4440 ************************************************************************/ 4441 static void 4442 ixgbe_update_link_status(struct adapter *adapter) 4443 { 4444 struct ifnet *ifp = adapter->ifp; 4445 device_t dev = adapter->dev; 4446 struct ixgbe_hw *hw = &adapter->hw; 4447 4448 if (adapter->link_up) { 4449 if (adapter->link_active == FALSE) { 4450 if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){ 4451 /* 4452 * Discard count for both MAC Local Fault and 4453 * Remote Fault because those registers are 4454 * valid only when the link speed is up and 4455 * 10Gbps. 4456 */ 4457 IXGBE_READ_REG(hw, IXGBE_MLFC); 4458 IXGBE_READ_REG(hw, IXGBE_MRFC); 4459 } 4460 4461 if (bootverbose) { 4462 const char *bpsmsg; 4463 4464 switch (adapter->link_speed) { 4465 case IXGBE_LINK_SPEED_10GB_FULL: 4466 bpsmsg = "10 Gbps"; 4467 break; 4468 case IXGBE_LINK_SPEED_5GB_FULL: 4469 bpsmsg = "5 Gbps"; 4470 break; 4471 case IXGBE_LINK_SPEED_2_5GB_FULL: 4472 bpsmsg = "2.5 Gbps"; 4473 break; 4474 case IXGBE_LINK_SPEED_1GB_FULL: 4475 bpsmsg = "1 Gbps"; 4476 break; 4477 case IXGBE_LINK_SPEED_100_FULL: 4478 bpsmsg = "100 Mbps"; 4479 break; 4480 case IXGBE_LINK_SPEED_10_FULL: 4481 bpsmsg = "10 Mbps"; 4482 break; 4483 default: 4484 bpsmsg = "unknown speed"; 4485 break; 4486 } 4487 device_printf(dev, "Link is up %s %s \n", 4488 bpsmsg, "Full Duplex"); 4489 } 4490 adapter->link_active = TRUE; 4491 /* Update any Flow Control changes */ 4492 ixgbe_fc_enable(&adapter->hw); 4493 /* Update DMA coalescing config */ 4494 ixgbe_config_dmac(adapter); 4495 if_link_state_change(ifp, LINK_STATE_UP); 4496 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4497 ixgbe_ping_all_vfs(adapter); 4498 } 4499 } else { /* Link down */ 4500 if (adapter->link_active == TRUE) { 4501 if (bootverbose) 4502 device_printf(dev, "Link is Down\n"); 4503 if_link_state_change(ifp, LINK_STATE_DOWN); 4504 adapter->link_active = FALSE; 4505 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4506 ixgbe_ping_all_vfs(adapter); 4507 } 4508 } 4509 4510 return; 4511 } /* ixgbe_update_link_status */ 4512 4513 /************************************************************************ 4514 * ixgbe_config_dmac - Configure DMA Coalescing 4515 ************************************************************************/ 4516 static void 4517 ixgbe_config_dmac(struct adapter *adapter) 4518 { 4519 struct ixgbe_hw *hw = &adapter->hw; 4520 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 4521 4522 if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config) 4523 return; 4524 4525 if (dcfg->watchdog_timer ^ adapter->dmac || 4526 dcfg->link_speed ^ adapter->link_speed) { 4527 dcfg->watchdog_timer = adapter->dmac; 4528 dcfg->fcoe_en = false; 4529 dcfg->link_speed = adapter->link_speed; 4530 dcfg->num_tcs = 1; 4531 4532 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 4533 dcfg->watchdog_timer, dcfg->link_speed); 4534 4535 hw->mac.ops.dmac_config(hw); 4536 } 4537 } /* ixgbe_config_dmac */ 4538 4539 /************************************************************************ 4540 * ixgbe_enable_intr 4541 ************************************************************************/ 4542 static void 4543 ixgbe_enable_intr(struct adapter *adapter) 4544 { 4545 struct ixgbe_hw *hw = &adapter->hw; 4546 struct ix_queue *que = adapter->queues; 4547 u32 mask, fwsm; 4548 4549 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 4550 4551 switch (adapter->hw.mac.type) { 4552 case ixgbe_mac_82599EB: 4553 mask |= IXGBE_EIMS_ECC; 4554 /* Temperature sensor on some adapters */ 4555 mask |= IXGBE_EIMS_GPI_SDP0; 4556 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 4557 mask |= IXGBE_EIMS_GPI_SDP1; 4558 mask |= IXGBE_EIMS_GPI_SDP2; 4559 break; 4560 case ixgbe_mac_X540: 4561 /* Detect if Thermal Sensor is enabled */ 4562 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 4563 if (fwsm & IXGBE_FWSM_TS_ENABLED) 4564 mask |= IXGBE_EIMS_TS; 4565 mask |= IXGBE_EIMS_ECC; 4566 break; 4567 case ixgbe_mac_X550: 4568 /* MAC thermal sensor is automatically enabled */ 4569 mask |= IXGBE_EIMS_TS; 4570 mask |= IXGBE_EIMS_ECC; 4571 break; 4572 case ixgbe_mac_X550EM_x: 4573 case ixgbe_mac_X550EM_a: 4574 /* Some devices use SDP0 for important information */ 4575 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 4576 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP || 4577 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N || 4578 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 4579 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 4580 if (hw->phy.type == ixgbe_phy_x550em_ext_t) 4581 mask |= IXGBE_EICR_GPI_SDP0_X540; 4582 mask |= IXGBE_EIMS_ECC; 4583 break; 4584 default: 4585 break; 4586 } 4587 4588 /* Enable Fan Failure detection */ 4589 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4590 mask |= IXGBE_EIMS_GPI_SDP1; 4591 /* Enable SR-IOV */ 4592 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4593 mask |= IXGBE_EIMS_MAILBOX; 4594 /* Enable Flow Director */ 4595 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 4596 mask |= IXGBE_EIMS_FLOW_DIR; 4597 4598 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 4599 4600 /* With MSI-X we use auto clear */ 4601 if (adapter->msix_mem) { 4602 mask = IXGBE_EIMS_ENABLE_MASK; 4603 /* Don't autoclear Link */ 4604 mask &= ~IXGBE_EIMS_OTHER; 4605 mask &= ~IXGBE_EIMS_LSC; 4606 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 4607 mask &= ~IXGBE_EIMS_MAILBOX; 4608 IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask); 4609 } 4610 4611 /* 4612 * Now enable all queues, this is done separately to 4613 * allow for handling the extended (beyond 32) MSI-X 4614 * vectors that can be used by 82599 4615 */ 4616 for (int i = 0; i < adapter->num_queues; i++, que++) 4617 ixgbe_enable_queue(adapter, que->msix); 4618 4619 IXGBE_WRITE_FLUSH(hw); 4620 4621 return; 4622 } /* ixgbe_enable_intr */ 4623 4624 /************************************************************************ 4625 * ixgbe_disable_intr 4626 ************************************************************************/ 4627 static void 4628 ixgbe_disable_intr(struct adapter *adapter) 4629 { 4630 struct ix_queue *que = adapter->queues; 4631 4632 /* disable interrupts other than queues */ 4633 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE); 4634 4635 if (adapter->msix_mem) 4636 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 4637 4638 for (int i = 0; i < adapter->num_queues; i++, que++) 4639 ixgbe_disable_queue(adapter, que->msix); 4640 4641 IXGBE_WRITE_FLUSH(&adapter->hw); 4642 4643 return; 4644 } /* ixgbe_disable_intr */ 4645 4646 /************************************************************************ 4647 * ixgbe_legacy_irq - Legacy Interrupt Service routine 4648 ************************************************************************/ 4649 static int 4650 ixgbe_legacy_irq(void *arg) 4651 { 4652 struct ix_queue *que = arg; 4653 struct adapter *adapter = que->adapter; 4654 struct ixgbe_hw *hw = &adapter->hw; 4655 struct ifnet *ifp = adapter->ifp; 4656 struct tx_ring *txr = adapter->tx_rings; 4657 bool more = false; 4658 u32 eicr, eicr_mask; 4659 4660 /* Silicon errata #26 on 82598 */ 4661 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 4662 4663 eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 4664 4665 adapter->stats.pf.legint.ev_count++; 4666 ++que->irqs.ev_count; 4667 if (eicr == 0) { 4668 adapter->stats.pf.intzero.ev_count++; 4669 if ((ifp->if_flags & IFF_UP) != 0) 4670 ixgbe_enable_intr(adapter); 4671 return 0; 4672 } 4673 4674 if ((ifp->if_flags & IFF_RUNNING) != 0) { 4675 #ifdef __NetBSD__ 4676 /* Don't run ixgbe_rxeof in interrupt context */ 4677 more = true; 4678 #else 4679 more = ixgbe_rxeof(que); 4680 #endif 4681 4682 IXGBE_TX_LOCK(txr); 4683 ixgbe_txeof(txr); 4684 #ifdef notyet 4685 if (!ixgbe_ring_empty(ifp, txr->br)) 4686 ixgbe_start_locked(ifp, txr); 4687 #endif 4688 IXGBE_TX_UNLOCK(txr); 4689 } 4690 4691 /* Check for fan failure */ 4692 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 4693 ixgbe_check_fan_failure(adapter, eicr, true); 4694 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 4695 } 4696 4697 /* Link status change */ 4698 if (eicr & IXGBE_EICR_LSC) 4699 softint_schedule(adapter->link_si); 4700 4701 if (ixgbe_is_sfp(hw)) { 4702 /* Pluggable optics-related interrupt */ 4703 if (hw->mac.type >= ixgbe_mac_X540) 4704 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 4705 else 4706 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 4707 4708 if (eicr & eicr_mask) { 4709 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 4710 softint_schedule(adapter->mod_si); 4711 } 4712 4713 if ((hw->mac.type == ixgbe_mac_82599EB) && 4714 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 4715 IXGBE_WRITE_REG(hw, IXGBE_EICR, 4716 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 4717 softint_schedule(adapter->msf_si); 4718 } 4719 } 4720 4721 /* External PHY interrupt */ 4722 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 4723 (eicr & IXGBE_EICR_GPI_SDP0_X540)) 4724 softint_schedule(adapter->phy_si); 4725 4726 if (more) { 4727 que->req.ev_count++; 4728 if (adapter->txrx_use_workqueue) { 4729 /* 4730 * "enqueued flag" is not required here. 4731 * See ixgbe_msix_que(). 4732 */ 4733 workqueue_enqueue(adapter->que_wq, &que->wq_cookie, 4734 curcpu()); 4735 } else { 4736 softint_schedule(que->que_si); 4737 } 4738 } else 4739 ixgbe_enable_intr(adapter); 4740 4741 return 1; 4742 } /* ixgbe_legacy_irq */ 4743 4744 /************************************************************************ 4745 * ixgbe_free_pciintr_resources 4746 ************************************************************************/ 4747 static void 4748 ixgbe_free_pciintr_resources(struct adapter *adapter) 4749 { 4750 struct ix_queue *que = adapter->queues; 4751 int rid; 4752 4753 /* 4754 * Release all msix queue resources: 4755 */ 4756 for (int i = 0; i < adapter->num_queues; i++, que++) { 4757 if (que->res != NULL) { 4758 pci_intr_disestablish(adapter->osdep.pc, 4759 adapter->osdep.ihs[i]); 4760 adapter->osdep.ihs[i] = NULL; 4761 } 4762 } 4763 4764 /* Clean the Legacy or Link interrupt last */ 4765 if (adapter->vector) /* we are doing MSIX */ 4766 rid = adapter->vector; 4767 else 4768 rid = 0; 4769 4770 if (adapter->osdep.ihs[rid] != NULL) { 4771 pci_intr_disestablish(adapter->osdep.pc, 4772 adapter->osdep.ihs[rid]); 4773 adapter->osdep.ihs[rid] = NULL; 4774 } 4775 4776 if (adapter->osdep.intrs != NULL) { 4777 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 4778 adapter->osdep.nintrs); 4779 adapter->osdep.intrs = NULL; 4780 } 4781 4782 return; 4783 } /* ixgbe_free_pciintr_resources */ 4784 4785 /************************************************************************ 4786 * ixgbe_free_pci_resources 4787 ************************************************************************/ 4788 static void 4789 ixgbe_free_pci_resources(struct adapter *adapter) 4790 { 4791 4792 ixgbe_free_pciintr_resources(adapter); 4793 4794 if (adapter->osdep.mem_size != 0) { 4795 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 4796 adapter->osdep.mem_bus_space_handle, 4797 adapter->osdep.mem_size); 4798 } 4799 4800 return; 4801 } /* ixgbe_free_pci_resources */ 4802 4803 /************************************************************************ 4804 * ixgbe_set_sysctl_value 4805 ************************************************************************/ 4806 static void 4807 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 4808 const char *description, int *limit, int value) 4809 { 4810 device_t dev = adapter->dev; 4811 struct sysctllog **log; 4812 const struct sysctlnode *rnode, *cnode; 4813 4814 log = &adapter->sysctllog; 4815 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 4816 aprint_error_dev(dev, "could not create sysctl root\n"); 4817 return; 4818 } 4819 if (sysctl_createv(log, 0, &rnode, &cnode, 4820 CTLFLAG_READWRITE, CTLTYPE_INT, 4821 name, SYSCTL_DESCR(description), 4822 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 4823 aprint_error_dev(dev, "could not create sysctl\n"); 4824 *limit = value; 4825 } /* ixgbe_set_sysctl_value */ 4826 4827 /************************************************************************ 4828 * ixgbe_sysctl_flowcntl 4829 * 4830 * SYSCTL wrapper around setting Flow Control 4831 ************************************************************************/ 4832 static int 4833 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 4834 { 4835 struct sysctlnode node = *rnode; 4836 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4837 int error, fc; 4838 4839 fc = adapter->hw.fc.current_mode; 4840 node.sysctl_data = &fc; 4841 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4842 if (error != 0 || newp == NULL) 4843 return error; 4844 4845 /* Don't bother if it's not changed */ 4846 if (fc == adapter->hw.fc.current_mode) 4847 return (0); 4848 4849 return ixgbe_set_flowcntl(adapter, fc); 4850 } /* ixgbe_sysctl_flowcntl */ 4851 4852 /************************************************************************ 4853 * ixgbe_set_flowcntl - Set flow control 4854 * 4855 * Flow control values: 4856 * 0 - off 4857 * 1 - rx pause 4858 * 2 - tx pause 4859 * 3 - full 4860 ************************************************************************/ 4861 static int 4862 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 4863 { 4864 switch (fc) { 4865 case ixgbe_fc_rx_pause: 4866 case ixgbe_fc_tx_pause: 4867 case ixgbe_fc_full: 4868 adapter->hw.fc.requested_mode = fc; 4869 if (adapter->num_queues > 1) 4870 ixgbe_disable_rx_drop(adapter); 4871 break; 4872 case ixgbe_fc_none: 4873 adapter->hw.fc.requested_mode = ixgbe_fc_none; 4874 if (adapter->num_queues > 1) 4875 ixgbe_enable_rx_drop(adapter); 4876 break; 4877 default: 4878 return (EINVAL); 4879 } 4880 4881 #if 0 /* XXX NetBSD */ 4882 /* Don't autoneg if forcing a value */ 4883 adapter->hw.fc.disable_fc_autoneg = TRUE; 4884 #endif 4885 ixgbe_fc_enable(&adapter->hw); 4886 4887 return (0); 4888 } /* ixgbe_set_flowcntl */ 4889 4890 /************************************************************************ 4891 * ixgbe_enable_rx_drop 4892 * 4893 * Enable the hardware to drop packets when the buffer is 4894 * full. This is useful with multiqueue, so that no single 4895 * queue being full stalls the entire RX engine. We only 4896 * enable this when Multiqueue is enabled AND Flow Control 4897 * is disabled. 4898 ************************************************************************/ 4899 static void 4900 ixgbe_enable_rx_drop(struct adapter *adapter) 4901 { 4902 struct ixgbe_hw *hw = &adapter->hw; 4903 struct rx_ring *rxr; 4904 u32 srrctl; 4905 4906 for (int i = 0; i < adapter->num_queues; i++) { 4907 rxr = &adapter->rx_rings[i]; 4908 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 4909 srrctl |= IXGBE_SRRCTL_DROP_EN; 4910 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 4911 } 4912 4913 /* enable drop for each vf */ 4914 for (int i = 0; i < adapter->num_vfs; i++) { 4915 IXGBE_WRITE_REG(hw, IXGBE_QDE, 4916 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 4917 IXGBE_QDE_ENABLE)); 4918 } 4919 } /* ixgbe_enable_rx_drop */ 4920 4921 /************************************************************************ 4922 * ixgbe_disable_rx_drop 4923 ************************************************************************/ 4924 static void 4925 ixgbe_disable_rx_drop(struct adapter *adapter) 4926 { 4927 struct ixgbe_hw *hw = &adapter->hw; 4928 struct rx_ring *rxr; 4929 u32 srrctl; 4930 4931 for (int i = 0; i < adapter->num_queues; i++) { 4932 rxr = &adapter->rx_rings[i]; 4933 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 4934 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 4935 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 4936 } 4937 4938 /* disable drop for each vf */ 4939 for (int i = 0; i < adapter->num_vfs; i++) { 4940 IXGBE_WRITE_REG(hw, IXGBE_QDE, 4941 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 4942 } 4943 } /* ixgbe_disable_rx_drop */ 4944 4945 /************************************************************************ 4946 * ixgbe_sysctl_advertise 4947 * 4948 * SYSCTL wrapper around setting advertised speed 4949 ************************************************************************/ 4950 static int 4951 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 4952 { 4953 struct sysctlnode node = *rnode; 4954 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4955 int error = 0, advertise; 4956 4957 advertise = adapter->advertise; 4958 node.sysctl_data = &advertise; 4959 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4960 if (error != 0 || newp == NULL) 4961 return error; 4962 4963 return ixgbe_set_advertise(adapter, advertise); 4964 } /* ixgbe_sysctl_advertise */ 4965 4966 /************************************************************************ 4967 * ixgbe_set_advertise - Control advertised link speed 4968 * 4969 * Flags: 4970 * 0x00 - Default (all capable link speed) 4971 * 0x01 - advertise 100 Mb 4972 * 0x02 - advertise 1G 4973 * 0x04 - advertise 10G 4974 * 0x08 - advertise 10 Mb 4975 * 0x10 - advertise 2.5G 4976 * 0x20 - advertise 5G 4977 ************************************************************************/ 4978 static int 4979 ixgbe_set_advertise(struct adapter *adapter, int advertise) 4980 { 4981 device_t dev; 4982 struct ixgbe_hw *hw; 4983 ixgbe_link_speed speed = 0; 4984 ixgbe_link_speed link_caps = 0; 4985 s32 err = IXGBE_NOT_IMPLEMENTED; 4986 bool negotiate = FALSE; 4987 4988 /* Checks to validate new value */ 4989 if (adapter->advertise == advertise) /* no change */ 4990 return (0); 4991 4992 dev = adapter->dev; 4993 hw = &adapter->hw; 4994 4995 /* No speed changes for backplane media */ 4996 if (hw->phy.media_type == ixgbe_media_type_backplane) 4997 return (ENODEV); 4998 4999 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5000 (hw->phy.multispeed_fiber))) { 5001 device_printf(dev, 5002 "Advertised speed can only be set on copper or " 5003 "multispeed fiber media types.\n"); 5004 return (EINVAL); 5005 } 5006 5007 if (advertise < 0x0 || advertise > 0x2f) { 5008 device_printf(dev, 5009 "Invalid advertised speed; valid modes are 0x0 through 0x7\n"); 5010 return (EINVAL); 5011 } 5012 5013 if (hw->mac.ops.get_link_capabilities) { 5014 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 5015 &negotiate); 5016 if (err != IXGBE_SUCCESS) { 5017 device_printf(dev, "Unable to determine supported advertise speeds\n"); 5018 return (ENODEV); 5019 } 5020 } 5021 5022 /* Set new value and report new advertised mode */ 5023 if (advertise & 0x1) { 5024 if (!(link_caps & IXGBE_LINK_SPEED_100_FULL)) { 5025 device_printf(dev, "Interface does not support 100Mb advertised speed\n"); 5026 return (EINVAL); 5027 } 5028 speed |= IXGBE_LINK_SPEED_100_FULL; 5029 } 5030 if (advertise & 0x2) { 5031 if (!(link_caps & IXGBE_LINK_SPEED_1GB_FULL)) { 5032 device_printf(dev, "Interface does not support 1Gb advertised speed\n"); 5033 return (EINVAL); 5034 } 5035 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5036 } 5037 if (advertise & 0x4) { 5038 if (!(link_caps & IXGBE_LINK_SPEED_10GB_FULL)) { 5039 device_printf(dev, "Interface does not support 10Gb advertised speed\n"); 5040 return (EINVAL); 5041 } 5042 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5043 } 5044 if (advertise & 0x8) { 5045 if (!(link_caps & IXGBE_LINK_SPEED_10_FULL)) { 5046 device_printf(dev, "Interface does not support 10Mb advertised speed\n"); 5047 return (EINVAL); 5048 } 5049 speed |= IXGBE_LINK_SPEED_10_FULL; 5050 } 5051 if (advertise & 0x10) { 5052 if (!(link_caps & IXGBE_LINK_SPEED_2_5GB_FULL)) { 5053 device_printf(dev, "Interface does not support 2.5Gb advertised speed\n"); 5054 return (EINVAL); 5055 } 5056 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 5057 } 5058 if (advertise & 0x20) { 5059 if (!(link_caps & IXGBE_LINK_SPEED_5GB_FULL)) { 5060 device_printf(dev, "Interface does not support 5Gb advertised speed\n"); 5061 return (EINVAL); 5062 } 5063 speed |= IXGBE_LINK_SPEED_5GB_FULL; 5064 } 5065 if (advertise == 0) 5066 speed = link_caps; /* All capable link speed */ 5067 5068 hw->mac.autotry_restart = TRUE; 5069 hw->mac.ops.setup_link(hw, speed, TRUE); 5070 adapter->advertise = advertise; 5071 5072 return (0); 5073 } /* ixgbe_set_advertise */ 5074 5075 /************************************************************************ 5076 * ixgbe_get_advertise - Get current advertised speed settings 5077 * 5078 * Formatted for sysctl usage. 5079 * Flags: 5080 * 0x01 - advertise 100 Mb 5081 * 0x02 - advertise 1G 5082 * 0x04 - advertise 10G 5083 * 0x08 - advertise 10 Mb (yes, Mb) 5084 * 0x10 - advertise 2.5G 5085 * 0x20 - advertise 5G 5086 ************************************************************************/ 5087 static int 5088 ixgbe_get_advertise(struct adapter *adapter) 5089 { 5090 struct ixgbe_hw *hw = &adapter->hw; 5091 int speed; 5092 ixgbe_link_speed link_caps = 0; 5093 s32 err; 5094 bool negotiate = FALSE; 5095 5096 /* 5097 * Advertised speed means nothing unless it's copper or 5098 * multi-speed fiber 5099 */ 5100 if (!(hw->phy.media_type == ixgbe_media_type_copper) && 5101 !(hw->phy.multispeed_fiber)) 5102 return (0); 5103 5104 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, &negotiate); 5105 if (err != IXGBE_SUCCESS) 5106 return (0); 5107 5108 speed = 5109 ((link_caps & IXGBE_LINK_SPEED_10GB_FULL) ? 0x04 : 0) | 5110 ((link_caps & IXGBE_LINK_SPEED_1GB_FULL) ? 0x02 : 0) | 5111 ((link_caps & IXGBE_LINK_SPEED_100_FULL) ? 0x01 : 0) | 5112 ((link_caps & IXGBE_LINK_SPEED_10_FULL) ? 0x08 : 0) | 5113 ((link_caps & IXGBE_LINK_SPEED_2_5GB_FULL) ? 0x10 : 0) | 5114 ((link_caps & IXGBE_LINK_SPEED_5GB_FULL) ? 0x20 : 0); 5115 5116 return speed; 5117 } /* ixgbe_get_advertise */ 5118 5119 /************************************************************************ 5120 * ixgbe_sysctl_dmac - Manage DMA Coalescing 5121 * 5122 * Control values: 5123 * 0/1 - off / on (use default value of 1000) 5124 * 5125 * Legal timer values are: 5126 * 50,100,250,500,1000,2000,5000,10000 5127 * 5128 * Turning off interrupt moderation will also turn this off. 5129 ************************************************************************/ 5130 static int 5131 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5132 { 5133 struct sysctlnode node = *rnode; 5134 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5135 struct ifnet *ifp = adapter->ifp; 5136 int error; 5137 int newval; 5138 5139 newval = adapter->dmac; 5140 node.sysctl_data = &newval; 5141 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5142 if ((error) || (newp == NULL)) 5143 return (error); 5144 5145 switch (newval) { 5146 case 0: 5147 /* Disabled */ 5148 adapter->dmac = 0; 5149 break; 5150 case 1: 5151 /* Enable and use default */ 5152 adapter->dmac = 1000; 5153 break; 5154 case 50: 5155 case 100: 5156 case 250: 5157 case 500: 5158 case 1000: 5159 case 2000: 5160 case 5000: 5161 case 10000: 5162 /* Legal values - allow */ 5163 adapter->dmac = newval; 5164 break; 5165 default: 5166 /* Do nothing, illegal value */ 5167 return (EINVAL); 5168 } 5169 5170 /* Re-initialize hardware if it's already running */ 5171 if (ifp->if_flags & IFF_RUNNING) 5172 ixgbe_init(ifp); 5173 5174 return (0); 5175 } 5176 5177 #ifdef IXGBE_DEBUG 5178 /************************************************************************ 5179 * ixgbe_sysctl_power_state 5180 * 5181 * Sysctl to test power states 5182 * Values: 5183 * 0 - set device to D0 5184 * 3 - set device to D3 5185 * (none) - get current device power state 5186 ************************************************************************/ 5187 static int 5188 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5189 { 5190 #ifdef notyet 5191 struct sysctlnode node = *rnode; 5192 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5193 device_t dev = adapter->dev; 5194 int curr_ps, new_ps, error = 0; 5195 5196 curr_ps = new_ps = pci_get_powerstate(dev); 5197 5198 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5199 if ((error) || (req->newp == NULL)) 5200 return (error); 5201 5202 if (new_ps == curr_ps) 5203 return (0); 5204 5205 if (new_ps == 3 && curr_ps == 0) 5206 error = DEVICE_SUSPEND(dev); 5207 else if (new_ps == 0 && curr_ps == 3) 5208 error = DEVICE_RESUME(dev); 5209 else 5210 return (EINVAL); 5211 5212 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5213 5214 return (error); 5215 #else 5216 return 0; 5217 #endif 5218 } /* ixgbe_sysctl_power_state */ 5219 #endif 5220 5221 /************************************************************************ 5222 * ixgbe_sysctl_wol_enable 5223 * 5224 * Sysctl to enable/disable the WoL capability, 5225 * if supported by the adapter. 5226 * 5227 * Values: 5228 * 0 - disabled 5229 * 1 - enabled 5230 ************************************************************************/ 5231 static int 5232 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5233 { 5234 struct sysctlnode node = *rnode; 5235 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5236 struct ixgbe_hw *hw = &adapter->hw; 5237 bool new_wol_enabled; 5238 int error = 0; 5239 5240 new_wol_enabled = hw->wol_enabled; 5241 node.sysctl_data = &new_wol_enabled; 5242 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5243 if ((error) || (newp == NULL)) 5244 return (error); 5245 if (new_wol_enabled == hw->wol_enabled) 5246 return (0); 5247 5248 if (new_wol_enabled && !adapter->wol_support) 5249 return (ENODEV); 5250 else 5251 hw->wol_enabled = new_wol_enabled; 5252 5253 return (0); 5254 } /* ixgbe_sysctl_wol_enable */ 5255 5256 /************************************************************************ 5257 * ixgbe_sysctl_wufc - Wake Up Filter Control 5258 * 5259 * Sysctl to enable/disable the types of packets that the 5260 * adapter will wake up on upon receipt. 5261 * Flags: 5262 * 0x1 - Link Status Change 5263 * 0x2 - Magic Packet 5264 * 0x4 - Direct Exact 5265 * 0x8 - Directed Multicast 5266 * 0x10 - Broadcast 5267 * 0x20 - ARP/IPv4 Request Packet 5268 * 0x40 - Direct IPv4 Packet 5269 * 0x80 - Direct IPv6 Packet 5270 * 5271 * Settings not listed above will cause the sysctl to return an error. 5272 ************************************************************************/ 5273 static int 5274 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5275 { 5276 struct sysctlnode node = *rnode; 5277 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5278 int error = 0; 5279 u32 new_wufc; 5280 5281 new_wufc = adapter->wufc; 5282 node.sysctl_data = &new_wufc; 5283 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5284 if ((error) || (newp == NULL)) 5285 return (error); 5286 if (new_wufc == adapter->wufc) 5287 return (0); 5288 5289 if (new_wufc & 0xffffff00) 5290 return (EINVAL); 5291 5292 new_wufc &= 0xff; 5293 new_wufc |= (0xffffff & adapter->wufc); 5294 adapter->wufc = new_wufc; 5295 5296 return (0); 5297 } /* ixgbe_sysctl_wufc */ 5298 5299 #ifdef IXGBE_DEBUG 5300 /************************************************************************ 5301 * ixgbe_sysctl_print_rss_config 5302 ************************************************************************/ 5303 static int 5304 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5305 { 5306 #ifdef notyet 5307 struct sysctlnode node = *rnode; 5308 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5309 struct ixgbe_hw *hw = &adapter->hw; 5310 device_t dev = adapter->dev; 5311 struct sbuf *buf; 5312 int error = 0, reta_size; 5313 u32 reg; 5314 5315 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5316 if (!buf) { 5317 device_printf(dev, "Could not allocate sbuf for output.\n"); 5318 return (ENOMEM); 5319 } 5320 5321 // TODO: use sbufs to make a string to print out 5322 /* Set multiplier for RETA setup and table size based on MAC */ 5323 switch (adapter->hw.mac.type) { 5324 case ixgbe_mac_X550: 5325 case ixgbe_mac_X550EM_x: 5326 case ixgbe_mac_X550EM_a: 5327 reta_size = 128; 5328 break; 5329 default: 5330 reta_size = 32; 5331 break; 5332 } 5333 5334 /* Print out the redirection table */ 5335 sbuf_cat(buf, "\n"); 5336 for (int i = 0; i < reta_size; i++) { 5337 if (i < 32) { 5338 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5339 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5340 } else { 5341 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5342 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5343 } 5344 } 5345 5346 // TODO: print more config 5347 5348 error = sbuf_finish(buf); 5349 if (error) 5350 device_printf(dev, "Error finishing sbuf: %d\n", error); 5351 5352 sbuf_delete(buf); 5353 #endif 5354 return (0); 5355 } /* ixgbe_sysctl_print_rss_config */ 5356 #endif /* IXGBE_DEBUG */ 5357 5358 /************************************************************************ 5359 * ixgbe_sysctl_phy_temp - Retrieve temperature of PHY 5360 * 5361 * For X552/X557-AT devices using an external PHY 5362 ************************************************************************/ 5363 static int 5364 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5365 { 5366 struct sysctlnode node = *rnode; 5367 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5368 struct ixgbe_hw *hw = &adapter->hw; 5369 int val; 5370 u16 reg; 5371 int error; 5372 5373 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5374 device_printf(adapter->dev, 5375 "Device has no supported external thermal sensor.\n"); 5376 return (ENODEV); 5377 } 5378 5379 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5380 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5381 device_printf(adapter->dev, 5382 "Error reading from PHY's current temperature register\n"); 5383 return (EAGAIN); 5384 } 5385 5386 node.sysctl_data = &val; 5387 5388 /* Shift temp for output */ 5389 val = reg >> 8; 5390 5391 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5392 if ((error) || (newp == NULL)) 5393 return (error); 5394 5395 return (0); 5396 } /* ixgbe_sysctl_phy_temp */ 5397 5398 /************************************************************************ 5399 * ixgbe_sysctl_phy_overtemp_occurred 5400 * 5401 * Reports (directly from the PHY) whether the current PHY 5402 * temperature is over the overtemp threshold. 5403 ************************************************************************/ 5404 static int 5405 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 5406 { 5407 struct sysctlnode node = *rnode; 5408 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5409 struct ixgbe_hw *hw = &adapter->hw; 5410 int val, error; 5411 u16 reg; 5412 5413 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5414 device_printf(adapter->dev, 5415 "Device has no supported external thermal sensor.\n"); 5416 return (ENODEV); 5417 } 5418 5419 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 5420 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5421 device_printf(adapter->dev, 5422 "Error reading from PHY's temperature status register\n"); 5423 return (EAGAIN); 5424 } 5425 5426 node.sysctl_data = &val; 5427 5428 /* Get occurrence bit */ 5429 val = !!(reg & 0x4000); 5430 5431 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5432 if ((error) || (newp == NULL)) 5433 return (error); 5434 5435 return (0); 5436 } /* ixgbe_sysctl_phy_overtemp_occurred */ 5437 5438 /************************************************************************ 5439 * ixgbe_sysctl_eee_state 5440 * 5441 * Sysctl to set EEE power saving feature 5442 * Values: 5443 * 0 - disable EEE 5444 * 1 - enable EEE 5445 * (none) - get current device EEE state 5446 ************************************************************************/ 5447 static int 5448 ixgbe_sysctl_eee_state(SYSCTLFN_ARGS) 5449 { 5450 struct sysctlnode node = *rnode; 5451 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5452 struct ifnet *ifp = adapter->ifp; 5453 device_t dev = adapter->dev; 5454 int curr_eee, new_eee, error = 0; 5455 s32 retval; 5456 5457 curr_eee = new_eee = !!(adapter->feat_en & IXGBE_FEATURE_EEE); 5458 node.sysctl_data = &new_eee; 5459 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5460 if ((error) || (newp == NULL)) 5461 return (error); 5462 5463 /* Nothing to do */ 5464 if (new_eee == curr_eee) 5465 return (0); 5466 5467 /* Not supported */ 5468 if (!(adapter->feat_cap & IXGBE_FEATURE_EEE)) 5469 return (EINVAL); 5470 5471 /* Bounds checking */ 5472 if ((new_eee < 0) || (new_eee > 1)) 5473 return (EINVAL); 5474 5475 retval = adapter->hw.mac.ops.setup_eee(&adapter->hw, new_eee); 5476 if (retval) { 5477 device_printf(dev, "Error in EEE setup: 0x%08X\n", retval); 5478 return (EINVAL); 5479 } 5480 5481 /* Restart auto-neg */ 5482 ixgbe_init(ifp); 5483 5484 device_printf(dev, "New EEE state: %d\n", new_eee); 5485 5486 /* Cache new value */ 5487 if (new_eee) 5488 adapter->feat_en |= IXGBE_FEATURE_EEE; 5489 else 5490 adapter->feat_en &= ~IXGBE_FEATURE_EEE; 5491 5492 return (error); 5493 } /* ixgbe_sysctl_eee_state */ 5494 5495 /************************************************************************ 5496 * ixgbe_init_device_features 5497 ************************************************************************/ 5498 static void 5499 ixgbe_init_device_features(struct adapter *adapter) 5500 { 5501 adapter->feat_cap = IXGBE_FEATURE_NETMAP 5502 | IXGBE_FEATURE_RSS 5503 | IXGBE_FEATURE_MSI 5504 | IXGBE_FEATURE_MSIX 5505 | IXGBE_FEATURE_LEGACY_IRQ 5506 | IXGBE_FEATURE_LEGACY_TX; 5507 5508 /* Set capabilities first... */ 5509 switch (adapter->hw.mac.type) { 5510 case ixgbe_mac_82598EB: 5511 if (adapter->hw.device_id == IXGBE_DEV_ID_82598AT) 5512 adapter->feat_cap |= IXGBE_FEATURE_FAN_FAIL; 5513 break; 5514 case ixgbe_mac_X540: 5515 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5516 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5517 if ((adapter->hw.device_id == IXGBE_DEV_ID_X540_BYPASS) && 5518 (adapter->hw.bus.func == 0)) 5519 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 5520 break; 5521 case ixgbe_mac_X550: 5522 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 5523 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5524 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5525 break; 5526 case ixgbe_mac_X550EM_x: 5527 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5528 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5529 if (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_X_KR) 5530 adapter->feat_cap |= IXGBE_FEATURE_EEE; 5531 break; 5532 case ixgbe_mac_X550EM_a: 5533 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5534 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5535 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 5536 if ((adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T) || 5537 (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)) { 5538 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 5539 adapter->feat_cap |= IXGBE_FEATURE_EEE; 5540 } 5541 break; 5542 case ixgbe_mac_82599EB: 5543 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5544 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5545 if ((adapter->hw.device_id == IXGBE_DEV_ID_82599_BYPASS) && 5546 (adapter->hw.bus.func == 0)) 5547 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 5548 if (adapter->hw.device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) 5549 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 5550 break; 5551 default: 5552 break; 5553 } 5554 5555 /* Enabled by default... */ 5556 /* Fan failure detection */ 5557 if (adapter->feat_cap & IXGBE_FEATURE_FAN_FAIL) 5558 adapter->feat_en |= IXGBE_FEATURE_FAN_FAIL; 5559 /* Netmap */ 5560 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 5561 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 5562 /* EEE */ 5563 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 5564 adapter->feat_en |= IXGBE_FEATURE_EEE; 5565 /* Thermal Sensor */ 5566 if (adapter->feat_cap & IXGBE_FEATURE_TEMP_SENSOR) 5567 adapter->feat_en |= IXGBE_FEATURE_TEMP_SENSOR; 5568 5569 /* Enabled via global sysctl... */ 5570 /* Flow Director */ 5571 if (ixgbe_enable_fdir) { 5572 if (adapter->feat_cap & IXGBE_FEATURE_FDIR) 5573 adapter->feat_en |= IXGBE_FEATURE_FDIR; 5574 else 5575 device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled."); 5576 } 5577 /* Legacy (single queue) transmit */ 5578 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 5579 ixgbe_enable_legacy_tx) 5580 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 5581 /* 5582 * Message Signal Interrupts - Extended (MSI-X) 5583 * Normal MSI is only enabled if MSI-X calls fail. 5584 */ 5585 if (!ixgbe_enable_msix) 5586 adapter->feat_cap &= ~IXGBE_FEATURE_MSIX; 5587 /* Receive-Side Scaling (RSS) */ 5588 if ((adapter->feat_cap & IXGBE_FEATURE_RSS) && ixgbe_enable_rss) 5589 adapter->feat_en |= IXGBE_FEATURE_RSS; 5590 5591 /* Disable features with unmet dependencies... */ 5592 /* No MSI-X */ 5593 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) { 5594 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 5595 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 5596 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 5597 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 5598 } 5599 } /* ixgbe_init_device_features */ 5600 5601 /************************************************************************ 5602 * ixgbe_probe - Device identification routine 5603 * 5604 * Determines if the driver should be loaded on 5605 * adapter based on its PCI vendor/device ID. 5606 * 5607 * return BUS_PROBE_DEFAULT on success, positive on failure 5608 ************************************************************************/ 5609 static int 5610 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 5611 { 5612 const struct pci_attach_args *pa = aux; 5613 5614 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 5615 } 5616 5617 static ixgbe_vendor_info_t * 5618 ixgbe_lookup(const struct pci_attach_args *pa) 5619 { 5620 ixgbe_vendor_info_t *ent; 5621 pcireg_t subid; 5622 5623 INIT_DEBUGOUT("ixgbe_lookup: begin"); 5624 5625 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 5626 return NULL; 5627 5628 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 5629 5630 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 5631 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 5632 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 5633 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 5634 (ent->subvendor_id == 0)) && 5635 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 5636 (ent->subdevice_id == 0))) { 5637 ++ixgbe_total_ports; 5638 return ent; 5639 } 5640 } 5641 return NULL; 5642 } 5643 5644 static int 5645 ixgbe_ifflags_cb(struct ethercom *ec) 5646 { 5647 struct ifnet *ifp = &ec->ec_if; 5648 struct adapter *adapter = ifp->if_softc; 5649 int change = ifp->if_flags ^ adapter->if_flags, rc = 0; 5650 5651 IXGBE_CORE_LOCK(adapter); 5652 5653 if (change != 0) 5654 adapter->if_flags = ifp->if_flags; 5655 5656 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) 5657 rc = ENETRESET; 5658 else if ((change & (IFF_PROMISC | IFF_ALLMULTI)) != 0) 5659 ixgbe_set_promisc(adapter); 5660 5661 /* Set up VLAN support and filter */ 5662 ixgbe_setup_vlan_hw_support(adapter); 5663 5664 IXGBE_CORE_UNLOCK(adapter); 5665 5666 return rc; 5667 } 5668 5669 /************************************************************************ 5670 * ixgbe_ioctl - Ioctl entry point 5671 * 5672 * Called when the user wants to configure the interface. 5673 * 5674 * return 0 on success, positive on failure 5675 ************************************************************************/ 5676 static int 5677 ixgbe_ioctl(struct ifnet * ifp, u_long command, void *data) 5678 { 5679 struct adapter *adapter = ifp->if_softc; 5680 struct ixgbe_hw *hw = &adapter->hw; 5681 struct ifcapreq *ifcr = data; 5682 struct ifreq *ifr = data; 5683 int error = 0; 5684 int l4csum_en; 5685 const int l4csum = IFCAP_CSUM_TCPv4_Rx|IFCAP_CSUM_UDPv4_Rx| 5686 IFCAP_CSUM_TCPv6_Rx|IFCAP_CSUM_UDPv6_Rx; 5687 5688 switch (command) { 5689 case SIOCSIFFLAGS: 5690 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 5691 break; 5692 case SIOCADDMULTI: 5693 case SIOCDELMULTI: 5694 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 5695 break; 5696 case SIOCSIFMEDIA: 5697 case SIOCGIFMEDIA: 5698 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 5699 break; 5700 case SIOCSIFCAP: 5701 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 5702 break; 5703 case SIOCSIFMTU: 5704 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 5705 break; 5706 #ifdef __NetBSD__ 5707 case SIOCINITIFADDR: 5708 IOCTL_DEBUGOUT("ioctl: SIOCINITIFADDR"); 5709 break; 5710 case SIOCGIFFLAGS: 5711 IOCTL_DEBUGOUT("ioctl: SIOCGIFFLAGS"); 5712 break; 5713 case SIOCGIFAFLAG_IN: 5714 IOCTL_DEBUGOUT("ioctl: SIOCGIFAFLAG_IN"); 5715 break; 5716 case SIOCGIFADDR: 5717 IOCTL_DEBUGOUT("ioctl: SIOCGIFADDR"); 5718 break; 5719 case SIOCGIFMTU: 5720 IOCTL_DEBUGOUT("ioctl: SIOCGIFMTU (Get Interface MTU)"); 5721 break; 5722 case SIOCGIFCAP: 5723 IOCTL_DEBUGOUT("ioctl: SIOCGIFCAP (Get IF cap)"); 5724 break; 5725 case SIOCGETHERCAP: 5726 IOCTL_DEBUGOUT("ioctl: SIOCGETHERCAP (Get ethercap)"); 5727 break; 5728 case SIOCGLIFADDR: 5729 IOCTL_DEBUGOUT("ioctl: SIOCGLIFADDR (Get Interface addr)"); 5730 break; 5731 case SIOCZIFDATA: 5732 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 5733 hw->mac.ops.clear_hw_cntrs(hw); 5734 ixgbe_clear_evcnt(adapter); 5735 break; 5736 case SIOCAIFADDR: 5737 IOCTL_DEBUGOUT("ioctl: SIOCAIFADDR (add/chg IF alias)"); 5738 break; 5739 #endif 5740 default: 5741 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 5742 break; 5743 } 5744 5745 switch (command) { 5746 case SIOCSIFMEDIA: 5747 case SIOCGIFMEDIA: 5748 return ifmedia_ioctl(ifp, ifr, &adapter->media, command); 5749 case SIOCGI2C: 5750 { 5751 struct ixgbe_i2c_req i2c; 5752 5753 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 5754 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 5755 if (error != 0) 5756 break; 5757 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 5758 error = EINVAL; 5759 break; 5760 } 5761 if (i2c.len > sizeof(i2c.data)) { 5762 error = EINVAL; 5763 break; 5764 } 5765 5766 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 5767 i2c.dev_addr, i2c.data); 5768 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 5769 break; 5770 } 5771 case SIOCSIFCAP: 5772 /* Layer-4 Rx checksum offload has to be turned on and 5773 * off as a unit. 5774 */ 5775 l4csum_en = ifcr->ifcr_capenable & l4csum; 5776 if (l4csum_en != l4csum && l4csum_en != 0) 5777 return EINVAL; 5778 /*FALLTHROUGH*/ 5779 case SIOCADDMULTI: 5780 case SIOCDELMULTI: 5781 case SIOCSIFFLAGS: 5782 case SIOCSIFMTU: 5783 default: 5784 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 5785 return error; 5786 if ((ifp->if_flags & IFF_RUNNING) == 0) 5787 ; 5788 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 5789 IXGBE_CORE_LOCK(adapter); 5790 ixgbe_init_locked(adapter); 5791 ixgbe_recalculate_max_frame(adapter); 5792 IXGBE_CORE_UNLOCK(adapter); 5793 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 5794 /* 5795 * Multicast list has changed; set the hardware filter 5796 * accordingly. 5797 */ 5798 IXGBE_CORE_LOCK(adapter); 5799 ixgbe_disable_intr(adapter); 5800 ixgbe_set_multi(adapter); 5801 ixgbe_enable_intr(adapter); 5802 IXGBE_CORE_UNLOCK(adapter); 5803 } 5804 return 0; 5805 } 5806 5807 return error; 5808 } /* ixgbe_ioctl */ 5809 5810 /************************************************************************ 5811 * ixgbe_check_fan_failure 5812 ************************************************************************/ 5813 static void 5814 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt) 5815 { 5816 u32 mask; 5817 5818 mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) : 5819 IXGBE_ESDP_SDP1; 5820 5821 if (reg & mask) 5822 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n"); 5823 } /* ixgbe_check_fan_failure */ 5824 5825 /************************************************************************ 5826 * ixgbe_handle_que 5827 ************************************************************************/ 5828 static void 5829 ixgbe_handle_que(void *context) 5830 { 5831 struct ix_queue *que = context; 5832 struct adapter *adapter = que->adapter; 5833 struct tx_ring *txr = que->txr; 5834 struct ifnet *ifp = adapter->ifp; 5835 bool more = false; 5836 5837 que->handleq.ev_count++; 5838 5839 if (ifp->if_flags & IFF_RUNNING) { 5840 more = ixgbe_rxeof(que); 5841 IXGBE_TX_LOCK(txr); 5842 more |= ixgbe_txeof(txr); 5843 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 5844 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 5845 ixgbe_mq_start_locked(ifp, txr); 5846 /* Only for queue 0 */ 5847 /* NetBSD still needs this for CBQ */ 5848 if ((&adapter->queues[0] == que) 5849 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 5850 ixgbe_legacy_start_locked(ifp, txr); 5851 IXGBE_TX_UNLOCK(txr); 5852 } 5853 5854 if (more) { 5855 que->req.ev_count++; 5856 if (adapter->txrx_use_workqueue) { 5857 /* 5858 * "enqueued flag" is not required here. 5859 * See ixgbe_msix_que(). 5860 */ 5861 workqueue_enqueue(adapter->que_wq, &que->wq_cookie, 5862 curcpu()); 5863 } else { 5864 softint_schedule(que->que_si); 5865 } 5866 } else if (que->res != NULL) { 5867 /* Re-enable this interrupt */ 5868 ixgbe_enable_queue(adapter, que->msix); 5869 } else 5870 ixgbe_enable_intr(adapter); 5871 5872 return; 5873 } /* ixgbe_handle_que */ 5874 5875 /************************************************************************ 5876 * ixgbe_handle_que_work 5877 ************************************************************************/ 5878 static void 5879 ixgbe_handle_que_work(struct work *wk, void *context) 5880 { 5881 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 5882 5883 /* 5884 * "enqueued flag" is not required here. 5885 * See ixgbe_msix_que(). 5886 */ 5887 ixgbe_handle_que(que); 5888 } 5889 5890 /************************************************************************ 5891 * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler 5892 ************************************************************************/ 5893 static int 5894 ixgbe_allocate_legacy(struct adapter *adapter, 5895 const struct pci_attach_args *pa) 5896 { 5897 device_t dev = adapter->dev; 5898 struct ix_queue *que = adapter->queues; 5899 struct tx_ring *txr = adapter->tx_rings; 5900 int counts[PCI_INTR_TYPE_SIZE]; 5901 pci_intr_type_t intr_type, max_type; 5902 char intrbuf[PCI_INTRSTR_LEN]; 5903 const char *intrstr = NULL; 5904 5905 /* We allocate a single interrupt resource */ 5906 max_type = PCI_INTR_TYPE_MSI; 5907 counts[PCI_INTR_TYPE_MSIX] = 0; 5908 counts[PCI_INTR_TYPE_MSI] = 5909 (adapter->feat_en & IXGBE_FEATURE_MSI) ? 1 : 0; 5910 /* Check not feat_en but feat_cap to fallback to INTx */ 5911 counts[PCI_INTR_TYPE_INTX] = 5912 (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) ? 1 : 0; 5913 5914 alloc_retry: 5915 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 5916 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 5917 return ENXIO; 5918 } 5919 adapter->osdep.nintrs = 1; 5920 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 5921 intrbuf, sizeof(intrbuf)); 5922 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 5923 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 5924 device_xname(dev)); 5925 intr_type = pci_intr_type(adapter->osdep.pc, adapter->osdep.intrs[0]); 5926 if (adapter->osdep.ihs[0] == NULL) { 5927 aprint_error_dev(dev,"unable to establish %s\n", 5928 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 5929 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 5930 adapter->osdep.intrs = NULL; 5931 switch (intr_type) { 5932 case PCI_INTR_TYPE_MSI: 5933 /* The next try is for INTx: Disable MSI */ 5934 max_type = PCI_INTR_TYPE_INTX; 5935 counts[PCI_INTR_TYPE_INTX] = 1; 5936 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 5937 if (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) { 5938 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 5939 goto alloc_retry; 5940 } else 5941 break; 5942 case PCI_INTR_TYPE_INTX: 5943 default: 5944 /* See below */ 5945 break; 5946 } 5947 } 5948 if (intr_type == PCI_INTR_TYPE_INTX) { 5949 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 5950 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 5951 } 5952 if (adapter->osdep.ihs[0] == NULL) { 5953 aprint_error_dev(dev, 5954 "couldn't establish interrupt%s%s\n", 5955 intrstr ? " at " : "", intrstr ? intrstr : ""); 5956 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 5957 adapter->osdep.intrs = NULL; 5958 return ENXIO; 5959 } 5960 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 5961 /* 5962 * Try allocating a fast interrupt and the associated deferred 5963 * processing contexts. 5964 */ 5965 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 5966 txr->txr_si = 5967 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 5968 ixgbe_deferred_mq_start, txr); 5969 que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 5970 ixgbe_handle_que, que); 5971 5972 if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) 5973 & (txr->txr_si == NULL)) || (que->que_si == NULL)) { 5974 aprint_error_dev(dev, 5975 "could not establish software interrupts\n"); 5976 5977 return ENXIO; 5978 } 5979 /* For simplicity in the handlers */ 5980 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 5981 5982 return (0); 5983 } /* ixgbe_allocate_legacy */ 5984 5985 /************************************************************************ 5986 * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers 5987 ************************************************************************/ 5988 static int 5989 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 5990 { 5991 device_t dev = adapter->dev; 5992 struct ix_queue *que = adapter->queues; 5993 struct tx_ring *txr = adapter->tx_rings; 5994 pci_chipset_tag_t pc; 5995 char intrbuf[PCI_INTRSTR_LEN]; 5996 char intr_xname[32]; 5997 char wqname[MAXCOMLEN]; 5998 const char *intrstr = NULL; 5999 int error, vector = 0; 6000 int cpu_id = 0; 6001 kcpuset_t *affinity; 6002 #ifdef RSS 6003 unsigned int rss_buckets = 0; 6004 kcpuset_t cpu_mask; 6005 #endif 6006 6007 pc = adapter->osdep.pc; 6008 #ifdef RSS 6009 /* 6010 * If we're doing RSS, the number of queues needs to 6011 * match the number of RSS buckets that are configured. 6012 * 6013 * + If there's more queues than RSS buckets, we'll end 6014 * up with queues that get no traffic. 6015 * 6016 * + If there's more RSS buckets than queues, we'll end 6017 * up having multiple RSS buckets map to the same queue, 6018 * so there'll be some contention. 6019 */ 6020 rss_buckets = rss_getnumbuckets(); 6021 if ((adapter->feat_en & IXGBE_FEATURE_RSS) && 6022 (adapter->num_queues != rss_buckets)) { 6023 device_printf(dev, 6024 "%s: number of queues (%d) != number of RSS buckets (%d)" 6025 "; performance will be impacted.\n", 6026 __func__, adapter->num_queues, rss_buckets); 6027 } 6028 #endif 6029 6030 adapter->osdep.nintrs = adapter->num_queues + 1; 6031 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 6032 adapter->osdep.nintrs) != 0) { 6033 aprint_error_dev(dev, 6034 "failed to allocate MSI-X interrupt\n"); 6035 return (ENXIO); 6036 } 6037 6038 kcpuset_create(&affinity, false); 6039 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 6040 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 6041 device_xname(dev), i); 6042 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 6043 sizeof(intrbuf)); 6044 #ifdef IXGBE_MPSAFE 6045 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 6046 true); 6047 #endif 6048 /* Set the handler function */ 6049 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 6050 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 6051 intr_xname); 6052 if (que->res == NULL) { 6053 aprint_error_dev(dev, 6054 "Failed to register QUE handler\n"); 6055 error = ENXIO; 6056 goto err_out; 6057 } 6058 que->msix = vector; 6059 adapter->active_queues |= (u64)(1 << que->msix); 6060 6061 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 6062 #ifdef RSS 6063 /* 6064 * The queue ID is used as the RSS layer bucket ID. 6065 * We look up the queue ID -> RSS CPU ID and select 6066 * that. 6067 */ 6068 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 6069 CPU_SETOF(cpu_id, &cpu_mask); 6070 #endif 6071 } else { 6072 /* 6073 * Bind the MSI-X vector, and thus the 6074 * rings to the corresponding CPU. 6075 * 6076 * This just happens to match the default RSS 6077 * round-robin bucket -> queue -> CPU allocation. 6078 */ 6079 if (adapter->num_queues > 1) 6080 cpu_id = i; 6081 } 6082 /* Round-robin affinity */ 6083 kcpuset_zero(affinity); 6084 kcpuset_set(affinity, cpu_id % ncpu); 6085 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 6086 NULL); 6087 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 6088 intrstr); 6089 if (error == 0) { 6090 #if 1 /* def IXGBE_DEBUG */ 6091 #ifdef RSS 6092 aprintf_normal(", bound RSS bucket %d to CPU %d", i, 6093 cpu_id % ncpu); 6094 #else 6095 aprint_normal(", bound queue %d to cpu %d", i, 6096 cpu_id % ncpu); 6097 #endif 6098 #endif /* IXGBE_DEBUG */ 6099 } 6100 aprint_normal("\n"); 6101 6102 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6103 txr->txr_si = softint_establish( 6104 SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6105 ixgbe_deferred_mq_start, txr); 6106 if (txr->txr_si == NULL) { 6107 aprint_error_dev(dev, 6108 "couldn't establish software interrupt\n"); 6109 error = ENXIO; 6110 goto err_out; 6111 } 6112 } 6113 que->que_si 6114 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6115 ixgbe_handle_que, que); 6116 if (que->que_si == NULL) { 6117 aprint_error_dev(dev, 6118 "couldn't establish software interrupt\n"); 6119 error = ENXIO; 6120 goto err_out; 6121 } 6122 } 6123 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6124 error = workqueue_create(&adapter->txr_wq, wqname, 6125 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6126 IXGBE_WORKQUEUE_FLAGS); 6127 if (error) { 6128 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 6129 goto err_out; 6130 } 6131 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6132 6133 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6134 error = workqueue_create(&adapter->que_wq, wqname, 6135 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6136 IXGBE_WORKQUEUE_FLAGS); 6137 if (error) { 6138 aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n"); 6139 goto err_out; 6140 } 6141 6142 /* and Link */ 6143 cpu_id++; 6144 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 6145 adapter->vector = vector; 6146 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 6147 sizeof(intrbuf)); 6148 #ifdef IXGBE_MPSAFE 6149 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 6150 true); 6151 #endif 6152 /* Set the link handler function */ 6153 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 6154 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_link, adapter, 6155 intr_xname); 6156 if (adapter->osdep.ihs[vector] == NULL) { 6157 adapter->res = NULL; 6158 aprint_error_dev(dev, "Failed to register LINK handler\n"); 6159 error = ENXIO; 6160 goto err_out; 6161 } 6162 /* Round-robin affinity */ 6163 kcpuset_zero(affinity); 6164 kcpuset_set(affinity, cpu_id % ncpu); 6165 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 6166 NULL); 6167 6168 aprint_normal_dev(dev, 6169 "for link, interrupting at %s", intrstr); 6170 if (error == 0) 6171 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 6172 else 6173 aprint_normal("\n"); 6174 6175 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 6176 adapter->mbx_si = 6177 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6178 ixgbe_handle_mbx, adapter); 6179 if (adapter->mbx_si == NULL) { 6180 aprint_error_dev(dev, 6181 "could not establish software interrupts\n"); 6182 6183 error = ENXIO; 6184 goto err_out; 6185 } 6186 } 6187 6188 kcpuset_destroy(affinity); 6189 aprint_normal_dev(dev, 6190 "Using MSI-X interrupts with %d vectors\n", vector + 1); 6191 6192 return (0); 6193 6194 err_out: 6195 kcpuset_destroy(affinity); 6196 ixgbe_free_softint(adapter); 6197 ixgbe_free_pciintr_resources(adapter); 6198 return (error); 6199 } /* ixgbe_allocate_msix */ 6200 6201 /************************************************************************ 6202 * ixgbe_configure_interrupts 6203 * 6204 * Setup MSI-X, MSI, or legacy interrupts (in that order). 6205 * This will also depend on user settings. 6206 ************************************************************************/ 6207 static int 6208 ixgbe_configure_interrupts(struct adapter *adapter) 6209 { 6210 device_t dev = adapter->dev; 6211 struct ixgbe_mac_info *mac = &adapter->hw.mac; 6212 int want, queues, msgs; 6213 6214 /* Default to 1 queue if MSI-X setup fails */ 6215 adapter->num_queues = 1; 6216 6217 /* Override by tuneable */ 6218 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) 6219 goto msi; 6220 6221 /* 6222 * NetBSD only: Use single vector MSI when number of CPU is 1 to save 6223 * interrupt slot. 6224 */ 6225 if (ncpu == 1) 6226 goto msi; 6227 6228 /* First try MSI-X */ 6229 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 6230 msgs = MIN(msgs, IXG_MAX_NINTR); 6231 if (msgs < 2) 6232 goto msi; 6233 6234 adapter->msix_mem = (void *)1; /* XXX */ 6235 6236 /* Figure out a reasonable auto config value */ 6237 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 6238 6239 #ifdef RSS 6240 /* If we're doing RSS, clamp at the number of RSS buckets */ 6241 if (adapter->feat_en & IXGBE_FEATURE_RSS) 6242 queues = min(queues, rss_getnumbuckets()); 6243 #endif 6244 if (ixgbe_num_queues > queues) { 6245 aprint_error_dev(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues); 6246 ixgbe_num_queues = queues; 6247 } 6248 6249 if (ixgbe_num_queues != 0) 6250 queues = ixgbe_num_queues; 6251 else 6252 queues = min(queues, 6253 min(mac->max_tx_queues, mac->max_rx_queues)); 6254 6255 /* reflect correct sysctl value */ 6256 ixgbe_num_queues = queues; 6257 6258 /* 6259 * Want one vector (RX/TX pair) per queue 6260 * plus an additional for Link. 6261 */ 6262 want = queues + 1; 6263 if (msgs >= want) 6264 msgs = want; 6265 else { 6266 aprint_error_dev(dev, "MSI-X Configuration Problem, " 6267 "%d vectors but %d queues wanted!\n", 6268 msgs, want); 6269 goto msi; 6270 } 6271 adapter->num_queues = queues; 6272 adapter->feat_en |= IXGBE_FEATURE_MSIX; 6273 return (0); 6274 6275 /* 6276 * MSI-X allocation failed or provided us with 6277 * less vectors than needed. Free MSI-X resources 6278 * and we'll try enabling MSI. 6279 */ 6280 msi: 6281 /* Without MSI-X, some features are no longer supported */ 6282 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6283 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6284 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6285 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6286 6287 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 6288 adapter->msix_mem = NULL; /* XXX */ 6289 if (msgs > 1) 6290 msgs = 1; 6291 if (msgs != 0) { 6292 msgs = 1; 6293 adapter->feat_en |= IXGBE_FEATURE_MSI; 6294 return (0); 6295 } 6296 6297 if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) { 6298 aprint_error_dev(dev, 6299 "Device does not support legacy interrupts.\n"); 6300 return 1; 6301 } 6302 6303 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6304 6305 return (0); 6306 } /* ixgbe_configure_interrupts */ 6307 6308 6309 /************************************************************************ 6310 * ixgbe_handle_link - Tasklet for MSI-X Link interrupts 6311 * 6312 * Done outside of interrupt context since the driver might sleep 6313 ************************************************************************/ 6314 static void 6315 ixgbe_handle_link(void *context) 6316 { 6317 struct adapter *adapter = context; 6318 struct ixgbe_hw *hw = &adapter->hw; 6319 6320 ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0); 6321 ixgbe_update_link_status(adapter); 6322 6323 /* Re-enable link interrupts */ 6324 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 6325 } /* ixgbe_handle_link */ 6326 6327 /************************************************************************ 6328 * ixgbe_rearm_queues 6329 ************************************************************************/ 6330 static void 6331 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 6332 { 6333 u32 mask; 6334 6335 switch (adapter->hw.mac.type) { 6336 case ixgbe_mac_82598EB: 6337 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 6338 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 6339 break; 6340 case ixgbe_mac_82599EB: 6341 case ixgbe_mac_X540: 6342 case ixgbe_mac_X550: 6343 case ixgbe_mac_X550EM_x: 6344 case ixgbe_mac_X550EM_a: 6345 mask = (queues & 0xFFFFFFFF); 6346 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 6347 mask = (queues >> 32); 6348 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 6349 break; 6350 default: 6351 break; 6352 } 6353 } /* ixgbe_rearm_queues */ 6354
Indexes created Thu Oct 23 22:10:10 GMT 2025