1 /*- 2 * Copyright (c) 2012-2015 Solarflare Communications Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 24 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * 26 * The views and conclusions contained in the software and documentation are 27 * those of the authors and should not be interpreted as representing official 28 * policies, either expressed or implied, of the FreeBSD Project. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include "efx.h" 35 #include "efx_impl.h" 36 37 38 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD 39 40 __checkReturn efx_rc_t 41 ef10_mac_poll( 42 __in efx_nic_t *enp, 43 __out efx_link_mode_t *link_modep) 44 { 45 efx_port_t *epp = &(enp->en_port); 46 ef10_link_state_t els; 47 efx_rc_t rc; 48 49 if ((rc = ef10_phy_get_link(enp, &els)) != 0) 50 goto fail1; 51 52 epp->ep_adv_cap_mask = els.els_adv_cap_mask; 53 epp->ep_fcntl = els.els_fcntl; 54 55 *link_modep = els.els_link_mode; 56 57 return (0); 58 59 fail1: 60 EFSYS_PROBE1(fail1, efx_rc_t, rc); 61 62 *link_modep = EFX_LINK_UNKNOWN; 63 64 return (rc); 65 } 66 67 __checkReturn efx_rc_t 68 ef10_mac_up( 69 __in efx_nic_t *enp, 70 __out boolean_t *mac_upp) 71 { 72 ef10_link_state_t els; 73 efx_rc_t rc; 74 75 /* 76 * Because EF10 doesn't *require* polling, we can't rely on 77 * ef10_mac_poll() being executed to populate epp->ep_mac_up. 78 */ 79 if ((rc = ef10_phy_get_link(enp, &els)) != 0) 80 goto fail1; 81 82 *mac_upp = els.els_mac_up; 83 84 return (0); 85 86 fail1: 87 EFSYS_PROBE1(fail1, efx_rc_t, rc); 88 89 return (rc); 90 } 91 92 /* 93 * EF10 adapters use MC_CMD_VADAPTOR_SET_MAC to set the 94 * MAC address; the address field in MC_CMD_SET_MAC has no 95 * effect. 96 * MC_CMD_VADAPTOR_SET_MAC requires mac-spoofing privilege and 97 * the port to have no filters or queues active. 98 */ 99 static __checkReturn efx_rc_t 100 efx_mcdi_vadapter_set_mac( 101 __in efx_nic_t *enp) 102 { 103 efx_port_t *epp = &(enp->en_port); 104 efx_mcdi_req_t req; 105 uint8_t payload[MAX(MC_CMD_VADAPTOR_SET_MAC_IN_LEN, 106 MC_CMD_VADAPTOR_SET_MAC_OUT_LEN)]; 107 efx_rc_t rc; 108 109 (void) memset(payload, 0, sizeof (payload)); 110 req.emr_cmd = MC_CMD_VADAPTOR_SET_MAC; 111 req.emr_in_buf = payload; 112 req.emr_in_length = MC_CMD_VADAPTOR_SET_MAC_IN_LEN; 113 req.emr_out_buf = payload; 114 req.emr_out_length = MC_CMD_VADAPTOR_SET_MAC_OUT_LEN; 115 116 MCDI_IN_SET_DWORD(req, VADAPTOR_SET_MAC_IN_UPSTREAM_PORT_ID, 117 enp->en_vport_id); 118 EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t, VADAPTOR_SET_MAC_IN_MACADDR), 119 epp->ep_mac_addr); 120 121 efx_mcdi_execute(enp, &req); 122 123 if (req.emr_rc != 0) { 124 rc = req.emr_rc; 125 goto fail1; 126 } 127 128 return (0); 129 130 fail1: 131 EFSYS_PROBE1(fail1, efx_rc_t, rc); 132 133 return (rc); 134 } 135 136 __checkReturn efx_rc_t 137 ef10_mac_addr_set( 138 __in efx_nic_t *enp) 139 { 140 efx_rc_t rc; 141 142 if ((rc = efx_mcdi_vadapter_set_mac(enp)) != 0) { 143 if (rc != ENOTSUP) 144 goto fail1; 145 146 /* 147 * Fallback for older Huntington firmware without Vadapter 148 * support. 149 */ 150 if ((rc = ef10_mac_reconfigure(enp)) != 0) 151 goto fail2; 152 } 153 154 return (0); 155 156 fail2: 157 EFSYS_PROBE(fail2); 158 159 fail1: 160 EFSYS_PROBE1(fail1, efx_rc_t, rc); 161 162 return (rc); 163 } 164 165 static __checkReturn efx_rc_t 166 efx_mcdi_mtu_set( 167 __in efx_nic_t *enp, 168 __in uint32_t mtu) 169 { 170 efx_mcdi_req_t req; 171 uint8_t payload[MAX(MC_CMD_SET_MAC_EXT_IN_LEN, 172 MC_CMD_SET_MAC_OUT_LEN)]; 173 efx_rc_t rc; 174 175 (void) memset(payload, 0, sizeof (payload)); 176 req.emr_cmd = MC_CMD_SET_MAC; 177 req.emr_in_buf = payload; 178 req.emr_in_length = MC_CMD_SET_MAC_EXT_IN_LEN; 179 req.emr_out_buf = payload; 180 req.emr_out_length = MC_CMD_SET_MAC_OUT_LEN; 181 182 /* Only configure the MTU in this call to MC_CMD_SET_MAC */ 183 MCDI_IN_SET_DWORD(req, SET_MAC_EXT_IN_MTU, mtu); 184 MCDI_IN_POPULATE_DWORD_1(req, SET_MAC_EXT_IN_CONTROL, 185 SET_MAC_EXT_IN_CFG_MTU, 1); 186 187 efx_mcdi_execute(enp, &req); 188 189 if (req.emr_rc != 0) { 190 rc = req.emr_rc; 191 goto fail1; 192 } 193 194 return (0); 195 196 fail1: 197 EFSYS_PROBE1(fail1, efx_rc_t, rc); 198 199 return (rc); 200 } 201 202 __checkReturn efx_rc_t 203 ef10_mac_pdu_set( 204 __in efx_nic_t *enp) 205 { 206 efx_port_t *epp = &(enp->en_port); 207 efx_nic_cfg_t *encp = &(enp->en_nic_cfg); 208 efx_rc_t rc; 209 210 if (encp->enc_enhanced_set_mac_supported) { 211 if ((rc = efx_mcdi_mtu_set(enp, epp->ep_mac_pdu)) != 0) 212 goto fail1; 213 } else { 214 /* 215 * Fallback for older Huntington firmware, which always 216 * configure all of the parameters to MC_CMD_SET_MAC. This isn't 217 * suitable for setting the MTU on unpriviliged functions. 218 */ 219 if ((rc = ef10_mac_reconfigure(enp)) != 0) 220 goto fail2; 221 } 222 223 return (0); 224 225 fail2: 226 EFSYS_PROBE(fail2); 227 fail1: 228 EFSYS_PROBE1(fail1, efx_rc_t, rc); 229 230 return (rc); 231 } 232 233 __checkReturn efx_rc_t 234 ef10_mac_reconfigure( 235 __in efx_nic_t *enp) 236 { 237 efx_port_t *epp = &(enp->en_port); 238 efx_mcdi_req_t req; 239 uint8_t payload[MAX(MC_CMD_SET_MAC_IN_LEN, 240 MC_CMD_SET_MAC_OUT_LEN)]; 241 efx_rc_t rc; 242 243 (void) memset(payload, 0, sizeof (payload)); 244 req.emr_cmd = MC_CMD_SET_MAC; 245 req.emr_in_buf = payload; 246 req.emr_in_length = MC_CMD_SET_MAC_IN_LEN; 247 req.emr_out_buf = payload; 248 req.emr_out_length = MC_CMD_SET_MAC_OUT_LEN; 249 250 MCDI_IN_SET_DWORD(req, SET_MAC_IN_MTU, epp->ep_mac_pdu); 251 MCDI_IN_SET_DWORD(req, SET_MAC_IN_DRAIN, epp->ep_mac_drain ? 1 : 0); 252 EFX_MAC_ADDR_COPY(MCDI_IN2(req, uint8_t, SET_MAC_IN_ADDR), 253 epp->ep_mac_addr); 254 255 /* 256 * Note: The Huntington MAC does not support REJECT_BRDCST. 257 * The REJECT_UNCST flag will also prevent multicast traffic 258 * from reaching the filters. As Huntington filters drop any 259 * traffic that does not match a filter it is ok to leave the 260 * MAC running in promiscuous mode. See bug41141. 261 * 262 * FIXME: Does REJECT_UNCST behave the same way on Medford? 263 */ 264 MCDI_IN_POPULATE_DWORD_2(req, SET_MAC_IN_REJECT, 265 SET_MAC_IN_REJECT_UNCST, 0, 266 SET_MAC_IN_REJECT_BRDCST, 0); 267 268 /* 269 * Flow control, whether it is auto-negotiated or not, 270 * is set via the PHY advertised capabilities. When set to 271 * automatic the MAC will use the PHY settings to determine 272 * the flow control settings. 273 */ 274 MCDI_IN_SET_DWORD(req, SET_MAC_IN_FCNTL, MC_CMD_FCNTL_AUTO); 275 276 /* Do not include the Ethernet frame checksum in RX packets */ 277 MCDI_IN_POPULATE_DWORD_1(req, SET_MAC_IN_FLAGS, 278 SET_MAC_IN_FLAG_INCLUDE_FCS, 0); 279 280 efx_mcdi_execute_quiet(enp, &req); 281 282 if (req.emr_rc != 0) { 283 /* 284 * Unprivileged functions cannot control link state, 285 * but still need to configure filters. 286 */ 287 if (req.emr_rc != EACCES) { 288 rc = req.emr_rc; 289 goto fail1; 290 } 291 } 292 293 /* 294 * Apply the filters for the MAC configuration. 295 * If the NIC isn't ready to accept filters this may 296 * return success without setting anything. 297 */ 298 rc = efx_filter_reconfigure(enp, epp->ep_mac_addr, 299 epp->ep_all_unicst, epp->ep_mulcst, 300 epp->ep_all_mulcst, epp->ep_brdcst, 301 epp->ep_mulcst_addr_list, 302 epp->ep_mulcst_addr_count); 303 304 return (0); 305 306 fail1: 307 EFSYS_PROBE1(fail1, efx_rc_t, rc); 308 309 return (rc); 310 } 311 312 __checkReturn efx_rc_t 313 ef10_mac_multicast_list_set( 314 __in efx_nic_t *enp) 315 { 316 efx_port_t *epp = &(enp->en_port); 317 const efx_mac_ops_t *emop = epp->ep_emop; 318 efx_rc_t rc; 319 320 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 321 enp->en_family == EFX_FAMILY_MEDFORD); 322 323 if ((rc = emop->emo_reconfigure(enp)) != 0) 324 goto fail1; 325 326 return (0); 327 328 fail1: 329 EFSYS_PROBE1(fail1, efx_rc_t, rc); 330 331 return (rc); 332 } 333 334 __checkReturn efx_rc_t 335 ef10_mac_filter_default_rxq_set( 336 __in efx_nic_t *enp, 337 __in efx_rxq_t *erp, 338 __in boolean_t using_rss) 339 { 340 efx_port_t *epp = &(enp->en_port); 341 efx_rxq_t *old_rxq; 342 boolean_t old_using_rss; 343 efx_rc_t rc; 344 345 ef10_filter_get_default_rxq(enp, &old_rxq, &old_using_rss); 346 347 ef10_filter_default_rxq_set(enp, erp, using_rss); 348 349 rc = efx_filter_reconfigure(enp, epp->ep_mac_addr, 350 epp->ep_all_unicst, epp->ep_mulcst, 351 epp->ep_all_mulcst, epp->ep_brdcst, 352 epp->ep_mulcst_addr_list, 353 epp->ep_mulcst_addr_count); 354 355 if (rc != 0) 356 goto fail1; 357 358 return (0); 359 360 fail1: 361 EFSYS_PROBE1(fail1, efx_rc_t, rc); 362 363 ef10_filter_default_rxq_set(enp, old_rxq, old_using_rss); 364 365 return (rc); 366 } 367 368 void 369 ef10_mac_filter_default_rxq_clear( 370 __in efx_nic_t *enp) 371 { 372 efx_port_t *epp = &(enp->en_port); 373 374 ef10_filter_default_rxq_clear(enp); 375 376 efx_filter_reconfigure(enp, epp->ep_mac_addr, 377 epp->ep_all_unicst, epp->ep_mulcst, 378 epp->ep_all_mulcst, epp->ep_brdcst, 379 epp->ep_mulcst_addr_list, 380 epp->ep_mulcst_addr_count); 381 } 382 383 384 #if EFSYS_OPT_LOOPBACK 385 386 __checkReturn efx_rc_t 387 ef10_mac_loopback_set( 388 __in efx_nic_t *enp, 389 __in efx_link_mode_t link_mode, 390 __in efx_loopback_type_t loopback_type) 391 { 392 efx_port_t *epp = &(enp->en_port); 393 const efx_phy_ops_t *epop = epp->ep_epop; 394 efx_loopback_type_t old_loopback_type; 395 efx_link_mode_t old_loopback_link_mode; 396 efx_rc_t rc; 397 398 /* The PHY object handles this on EF10 */ 399 old_loopback_type = epp->ep_loopback_type; 400 old_loopback_link_mode = epp->ep_loopback_link_mode; 401 epp->ep_loopback_type = loopback_type; 402 epp->ep_loopback_link_mode = link_mode; 403 404 if ((rc = epop->epo_reconfigure(enp)) != 0) 405 goto fail1; 406 407 return (0); 408 409 fail1: 410 EFSYS_PROBE1(fail1, efx_rc_t, rc); 411 412 epp->ep_loopback_type = old_loopback_type; 413 epp->ep_loopback_link_mode = old_loopback_link_mode; 414 415 return (rc); 416 } 417 418 #endif /* EFSYS_OPT_LOOPBACK */ 419 420 #if EFSYS_OPT_MAC_STATS 421 422 #define EF10_MAC_STAT_READ(_esmp, _field, _eqp) \ 423 EFSYS_MEM_READQ((_esmp), (_field) * sizeof (efx_qword_t), _eqp) 424 425 426 __checkReturn efx_rc_t 427 ef10_mac_stats_update( 428 __in efx_nic_t *enp, 429 __in efsys_mem_t *esmp, 430 __inout_ecount(EFX_MAC_NSTATS) efsys_stat_t *stat, 431 __inout_opt uint32_t *generationp) 432 { 433 efx_qword_t value; 434 efx_qword_t generation_start; 435 efx_qword_t generation_end; 436 437 _NOTE(ARGUNUSED(enp)) 438 439 /* Read END first so we don't race with the MC */ 440 EFSYS_DMA_SYNC_FOR_KERNEL(esmp, 0, EFX_MAC_STATS_SIZE); 441 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_GENERATION_END, 442 &generation_end); 443 EFSYS_MEM_READ_BARRIER(); 444 445 /* TX */ 446 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_PKTS, &value); 447 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_PKTS]), &value); 448 449 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_CONTROL_PKTS, &value); 450 EFSYS_STAT_SUBR_QWORD(&(stat[EFX_MAC_TX_PKTS]), &value); 451 452 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_PAUSE_PKTS, &value); 453 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_PAUSE_PKTS]), &value); 454 455 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_UNICAST_PKTS, &value); 456 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_UNICST_PKTS]), &value); 457 458 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_MULTICAST_PKTS, &value); 459 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_MULTICST_PKTS]), &value); 460 461 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BROADCAST_PKTS, &value); 462 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_BRDCST_PKTS]), &value); 463 464 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BYTES, &value); 465 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_OCTETS]), &value); 466 467 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_LT64_PKTS, &value); 468 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LE_64_PKTS]), &value); 469 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_64_PKTS, &value); 470 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LE_64_PKTS]), &value); 471 472 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_65_TO_127_PKTS, &value); 473 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_65_TO_127_PKTS]), &value); 474 475 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_128_TO_255_PKTS, &value); 476 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_128_TO_255_PKTS]), &value); 477 478 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_256_TO_511_PKTS, &value); 479 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_256_TO_511_PKTS]), &value); 480 481 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_512_TO_1023_PKTS, &value); 482 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_512_TO_1023_PKTS]), &value); 483 484 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_1024_TO_15XX_PKTS, &value); 485 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_1024_TO_15XX_PKTS]), &value); 486 487 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_15XX_TO_JUMBO_PKTS, &value); 488 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_GE_15XX_PKTS]), &value); 489 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_GTJUMBO_PKTS, &value); 490 EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_TX_GE_15XX_PKTS]), &value); 491 492 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_BAD_FCS_PKTS, &value); 493 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_ERRORS]), &value); 494 495 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_SINGLE_COLLISION_PKTS, &value); 496 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_SGL_COL_PKTS]), &value); 497 498 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_MULTIPLE_COLLISION_PKTS, 499 &value); 500 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_MULT_COL_PKTS]), &value); 501 502 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_EXCESSIVE_COLLISION_PKTS, 503 &value); 504 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_EX_COL_PKTS]), &value); 505 506 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_LATE_COLLISION_PKTS, &value); 507 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_LATE_COL_PKTS]), &value); 508 509 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_DEFERRED_PKTS, &value); 510 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_DEF_PKTS]), &value); 511 512 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_TX_EXCESSIVE_DEFERRED_PKTS, 513 &value); 514 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_TX_EX_DEF_PKTS]), &value); 515 516 /* RX */ 517 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BYTES, &value); 518 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_OCTETS]), &value); 519 520 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_PKTS, &value); 521 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_PKTS]), &value); 522 523 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_UNICAST_PKTS, &value); 524 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_UNICST_PKTS]), &value); 525 526 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_MULTICAST_PKTS, &value); 527 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_MULTICST_PKTS]), &value); 528 529 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BROADCAST_PKTS, &value); 530 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_BRDCST_PKTS]), &value); 531 532 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_PAUSE_PKTS, &value); 533 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_PAUSE_PKTS]), &value); 534 535 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_UNDERSIZE_PKTS, &value); 536 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_LE_64_PKTS]), &value); 537 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_64_PKTS, &value); 538 EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_RX_LE_64_PKTS]), &value); 539 540 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_65_TO_127_PKTS, &value); 541 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_65_TO_127_PKTS]), &value); 542 543 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_128_TO_255_PKTS, &value); 544 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_128_TO_255_PKTS]), &value); 545 546 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_256_TO_511_PKTS, &value); 547 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_256_TO_511_PKTS]), &value); 548 549 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_512_TO_1023_PKTS, &value); 550 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_512_TO_1023_PKTS]), &value); 551 552 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_1024_TO_15XX_PKTS, &value); 553 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_1024_TO_15XX_PKTS]), &value); 554 555 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_15XX_TO_JUMBO_PKTS, &value); 556 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_GE_15XX_PKTS]), &value); 557 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_GTJUMBO_PKTS, &value); 558 EFSYS_STAT_INCR_QWORD(&(stat[EFX_MAC_RX_GE_15XX_PKTS]), &value); 559 560 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_BAD_FCS_PKTS, &value); 561 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_FCS_ERRORS]), &value); 562 563 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_OVERFLOW_PKTS, &value); 564 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_DROP_EVENTS]), &value); 565 566 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_FALSE_CARRIER_PKTS, &value); 567 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_FALSE_CARRIER_ERRORS]), &value); 568 569 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_SYMBOL_ERROR_PKTS, &value); 570 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_SYMBOL_ERRORS]), &value); 571 572 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_ALIGN_ERROR_PKTS, &value); 573 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_ALIGN_ERRORS]), &value); 574 575 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_INTERNAL_ERROR_PKTS, &value); 576 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_INTERNAL_ERRORS]), &value); 577 578 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_JABBER_PKTS, &value); 579 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_JABBER_PKTS]), &value); 580 581 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES01_CHAR_ERR, &value); 582 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE0_CHAR_ERR]), 583 &(value.eq_dword[0])); 584 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE1_CHAR_ERR]), 585 &(value.eq_dword[1])); 586 587 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES23_CHAR_ERR, &value); 588 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE2_CHAR_ERR]), 589 &(value.eq_dword[0])); 590 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE3_CHAR_ERR]), 591 &(value.eq_dword[1])); 592 593 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES01_DISP_ERR, &value); 594 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE0_DISP_ERR]), 595 &(value.eq_dword[0])); 596 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE1_DISP_ERR]), 597 &(value.eq_dword[1])); 598 599 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_LANES23_DISP_ERR, &value); 600 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE2_DISP_ERR]), 601 &(value.eq_dword[0])); 602 EFSYS_STAT_SET_DWORD(&(stat[EFX_MAC_RX_LANE3_DISP_ERR]), 603 &(value.eq_dword[1])); 604 605 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_MATCH_FAULT, &value); 606 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_MATCH_FAULT]), &value); 607 608 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RX_NODESC_DROPS, &value); 609 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RX_NODESC_DROP_CNT]), &value); 610 611 /* Packet memory (EF10 only) */ 612 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_BB_OVERFLOW, &value); 613 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_BB_OVERFLOW]), &value); 614 615 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_BB_OVERFLOW, &value); 616 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_BB_OVERFLOW]), &value); 617 618 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_VFIFO_FULL, &value); 619 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_VFIFO_FULL]), &value); 620 621 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_VFIFO_FULL, &value); 622 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_VFIFO_FULL]), &value); 623 624 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_TRUNC_QBB, &value); 625 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_TRUNC_QBB]), &value); 626 627 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_QBB, &value); 628 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_QBB]), &value); 629 630 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_PM_DISCARD_MAPPING, &value); 631 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_PM_DISCARD_MAPPING]), &value); 632 633 /* RX datapath */ 634 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_Q_DISABLED_PKTS, &value); 635 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_Q_DISABLED_PKTS]), &value); 636 637 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_DI_DROPPED_PKTS, &value); 638 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_DI_DROPPED_PKTS]), &value); 639 640 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_STREAMING_PKTS, &value); 641 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_STREAMING_PKTS]), &value); 642 643 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_FETCH_CONDITIONS, &value); 644 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_FETCH]), &value); 645 646 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_RXDP_HLB_WAIT_CONDITIONS, &value); 647 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_RXDP_HLB_WAIT]), &value); 648 649 650 /* VADAPTER RX */ 651 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_UNICAST_PACKETS, 652 &value); 653 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_UNICAST_PACKETS]), 654 &value); 655 656 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_UNICAST_BYTES, 657 &value); 658 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_UNICAST_BYTES]), 659 &value); 660 661 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_MULTICAST_PACKETS, 662 &value); 663 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_MULTICAST_PACKETS]), 664 &value); 665 666 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_MULTICAST_BYTES, 667 &value); 668 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_MULTICAST_BYTES]), 669 &value); 670 671 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BROADCAST_PACKETS, 672 &value); 673 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BROADCAST_PACKETS]), 674 &value); 675 676 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BROADCAST_BYTES, 677 &value); 678 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BROADCAST_BYTES]), 679 &value); 680 681 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BAD_PACKETS, 682 &value); 683 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BAD_PACKETS]), 684 &value); 685 686 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_BAD_BYTES, &value); 687 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_BAD_BYTES]), &value); 688 689 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_RX_OVERFLOW, &value); 690 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_RX_OVERFLOW]), &value); 691 692 /* VADAPTER TX */ 693 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_UNICAST_PACKETS, 694 &value); 695 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_UNICAST_PACKETS]), 696 &value); 697 698 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_UNICAST_BYTES, 699 &value); 700 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_UNICAST_BYTES]), 701 &value); 702 703 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_MULTICAST_PACKETS, 704 &value); 705 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_MULTICAST_PACKETS]), 706 &value); 707 708 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_MULTICAST_BYTES, 709 &value); 710 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_MULTICAST_BYTES]), 711 &value); 712 713 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BROADCAST_PACKETS, 714 &value); 715 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BROADCAST_PACKETS]), 716 &value); 717 718 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BROADCAST_BYTES, 719 &value); 720 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BROADCAST_BYTES]), 721 &value); 722 723 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BAD_PACKETS, &value); 724 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BAD_PACKETS]), &value); 725 726 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_BAD_BYTES, &value); 727 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_BAD_BYTES]), &value); 728 729 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_VADAPTER_TX_OVERFLOW, &value); 730 EFSYS_STAT_SET_QWORD(&(stat[EFX_MAC_VADAPTER_TX_OVERFLOW]), &value); 731 732 733 EFSYS_DMA_SYNC_FOR_KERNEL(esmp, 0, EFX_MAC_STATS_SIZE); 734 EFSYS_MEM_READ_BARRIER(); 735 EF10_MAC_STAT_READ(esmp, MC_CMD_MAC_GENERATION_START, 736 &generation_start); 737 738 /* Check that we didn't read the stats in the middle of a DMA */ 739 /* Not a good enough check ? */ 740 if (memcmp(&generation_start, &generation_end, 741 sizeof (generation_start))) 742 return (EAGAIN); 743 744 if (generationp) 745 *generationp = EFX_QWORD_FIELD(generation_start, EFX_DWORD_0); 746 747 return (0); 748 } 749 750 #endif /* EFSYS_OPT_MAC_STATS */ 751 752 #endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */ 753