drivers/net/sfc/base/ef10_phy.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright (c) 2012-2018 Solarflare Communications Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include "efx.h"
   8 #include "efx_impl.h"
   9
  10 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD
  11
  12 static                  void
  13 mcdi_phy_decode_cap(
  14         __in            uint32_t mcdi_cap,
  15         __out           uint32_t *maskp)
  16 {
  17         uint32_t mask;
  18
  19         mask = 0;
  20         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_10HDX_LBN))
  21                 mask |= (1 << EFX_PHY_CAP_10HDX);
  22         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_10FDX_LBN))
  23                 mask |= (1 << EFX_PHY_CAP_10FDX);
  24         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_100HDX_LBN))
  25                 mask |= (1 << EFX_PHY_CAP_100HDX);
  26         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_100FDX_LBN))
  27                 mask |= (1 << EFX_PHY_CAP_100FDX);
  28         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_1000HDX_LBN))
  29                 mask |= (1 << EFX_PHY_CAP_1000HDX);
  30         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_1000FDX_LBN))
  31                 mask |= (1 << EFX_PHY_CAP_1000FDX);
  32         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_10000FDX_LBN))
  33                 mask |= (1 << EFX_PHY_CAP_10000FDX);
  34         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_40000FDX_LBN))
  35                 mask |= (1 << EFX_PHY_CAP_40000FDX);
  36         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_PAUSE_LBN))
  37                 mask |= (1 << EFX_PHY_CAP_PAUSE);
  38         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_ASYM_LBN))
  39                 mask |= (1 << EFX_PHY_CAP_ASYM);
  40         if (mcdi_cap & (1 << MC_CMD_PHY_CAP_AN_LBN))
  41                 mask |= (1 << EFX_PHY_CAP_AN);
  42
  43         *maskp = mask;
  44 }
  45
  46 static                  void
  47 mcdi_phy_decode_link_mode(
  48         __in            efx_nic_t *enp,
  49         __in            uint32_t link_flags,
  50         __in            unsigned int speed,
  51         __in            unsigned int fcntl,
  52         __out           efx_link_mode_t *link_modep,
  53         __out           unsigned int *fcntlp)
  54 {
  55         boolean_t fd = !!(link_flags &
  56                     (1 << MC_CMD_GET_LINK_OUT_FULL_DUPLEX_LBN));
  57         boolean_t up = !!(link_flags &
  58                     (1 << MC_CMD_GET_LINK_OUT_LINK_UP_LBN));
  59
  60         _NOTE(ARGUNUSED(enp))
  61
  62         if (!up)
  63                 *link_modep = EFX_LINK_DOWN;
  64         else if (speed == 40000 && fd)
  65                 *link_modep = EFX_LINK_40000FDX;
  66         else if (speed == 10000 && fd)
  67                 *link_modep = EFX_LINK_10000FDX;
  68         else if (speed == 1000)
  69                 *link_modep = fd ? EFX_LINK_1000FDX : EFX_LINK_1000HDX;
  70         else if (speed == 100)
  71                 *link_modep = fd ? EFX_LINK_100FDX : EFX_LINK_100HDX;
  72         else if (speed == 10)
  73                 *link_modep = fd ? EFX_LINK_10FDX : EFX_LINK_10HDX;
  74         else
  75                 *link_modep = EFX_LINK_UNKNOWN;
  76
  77         if (fcntl == MC_CMD_FCNTL_OFF)
  78                 *fcntlp = 0;
  79         else if (fcntl == MC_CMD_FCNTL_RESPOND)
  80                 *fcntlp = EFX_FCNTL_RESPOND;
  81         else if (fcntl == MC_CMD_FCNTL_GENERATE)
  82                 *fcntlp = EFX_FCNTL_GENERATE;
  83         else if (fcntl == MC_CMD_FCNTL_BIDIR)
  84                 *fcntlp = EFX_FCNTL_RESPOND | EFX_FCNTL_GENERATE;
  85         else {
  86                 EFSYS_PROBE1(mc_pcol_error, int, fcntl);
  87                 *fcntlp = 0;
  88         }
  89 }
  90
  91
  92                         void
  93 ef10_phy_link_ev(
  94         __in            efx_nic_t *enp,
  95         __in            efx_qword_t *eqp,
  96         __out           efx_link_mode_t *link_modep)
  97 {
  98         efx_port_t *epp = &(enp->en_port);
  99         unsigned int link_flags;
 100         unsigned int speed;
 101         unsigned int fcntl;
 102         efx_link_mode_t link_mode;
 103         uint32_t lp_cap_mask;
 104
 105         /*
 106          * Convert the LINKCHANGE speed enumeration into mbit/s, in the
 107          * same way as GET_LINK encodes the speed
 108          */
 109         switch (MCDI_EV_FIELD(eqp, LINKCHANGE_SPEED)) {
 110         case MCDI_EVENT_LINKCHANGE_SPEED_100M:
 111                 speed = 100;
 112                 break;
 113         case MCDI_EVENT_LINKCHANGE_SPEED_1G:
 114                 speed = 1000;
 115                 break;
 116         case MCDI_EVENT_LINKCHANGE_SPEED_10G:
 117                 speed = 10000;
 118                 break;
 119         case MCDI_EVENT_LINKCHANGE_SPEED_40G:
 120                 speed = 40000;
 121                 break;
 122         default:
 123                 speed = 0;
 124                 break;
 125         }
 126
 127         link_flags = MCDI_EV_FIELD(eqp, LINKCHANGE_LINK_FLAGS);
 128         mcdi_phy_decode_link_mode(enp, link_flags, speed,
 129                                     MCDI_EV_FIELD(eqp, LINKCHANGE_FCNTL),
 130                                     &link_mode, &fcntl);
 131         mcdi_phy_decode_cap(MCDI_EV_FIELD(eqp, LINKCHANGE_LP_CAP),
 132                             &lp_cap_mask);
 133
 134         /*
 135          * It's safe to update ep_lp_cap_mask without the driver's port lock
 136          * because presumably any concurrently running efx_port_poll() is
 137          * only going to arrive at the same value.
 138          *
 139          * ep_fcntl has two meanings. It's either the link common fcntl
 140          * (if the PHY supports AN), or it's the forced link state. If
 141          * the former, it's safe to update the value for the same reason as
 142          * for ep_lp_cap_mask. If the latter, then just ignore the value,
 143          * because we can race with efx_mac_fcntl_set().
 144          */
 145         epp->ep_lp_cap_mask = lp_cap_mask;
 146         epp->ep_fcntl = fcntl;
 147
 148         *link_modep = link_mode;
 149 }
 150
 151         __checkReturn   efx_rc_t
 152 ef10_phy_power(
 153         __in            efx_nic_t *enp,
 154         __in            boolean_t power)
 155 {
 156         efx_rc_t rc;
 157
 158         if (!power)
 159                 return (0);
 160
 161         /* Check if the PHY is a zombie */
 162         if ((rc = ef10_phy_verify(enp)) != 0)
 163                 goto fail1;
 164
 165         enp->en_reset_flags |= EFX_RESET_PHY;
 166
 167         return (0);
 168
 169 fail1:
 170         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 171
 172         return (rc);
 173 }
 174
 175         __checkReturn   efx_rc_t
 176 ef10_phy_get_link(
 177         __in            efx_nic_t *enp,
 178         __out           ef10_link_state_t *elsp)
 179 {
 180         efx_mcdi_req_t req;
 181         uint8_t payload[MAX(MC_CMD_GET_LINK_IN_LEN,
 182                             MC_CMD_GET_LINK_OUT_LEN)];
 183         efx_rc_t rc;
 184
 185         (void) memset(payload, 0, sizeof (payload));
 186         req.emr_cmd = MC_CMD_GET_LINK;
 187         req.emr_in_buf = payload;
 188         req.emr_in_length = MC_CMD_GET_LINK_IN_LEN;
 189         req.emr_out_buf = payload;
 190         req.emr_out_length = MC_CMD_GET_LINK_OUT_LEN;
 191
 192         efx_mcdi_execute(enp, &req);
 193
 194         if (req.emr_rc != 0) {
 195                 rc = req.emr_rc;
 196                 goto fail1;
 197         }
 198
 199         if (req.emr_out_length_used < MC_CMD_GET_LINK_OUT_LEN) {
 200                 rc = EMSGSIZE;
 201                 goto fail2;
 202         }
 203
 204         mcdi_phy_decode_cap(MCDI_OUT_DWORD(req, GET_LINK_OUT_CAP),
 205                             &elsp->els_adv_cap_mask);
 206         mcdi_phy_decode_cap(MCDI_OUT_DWORD(req, GET_LINK_OUT_LP_CAP),
 207                             &elsp->els_lp_cap_mask);
 208
 209         mcdi_phy_decode_link_mode(enp, MCDI_OUT_DWORD(req, GET_LINK_OUT_FLAGS),
 210                             MCDI_OUT_DWORD(req, GET_LINK_OUT_LINK_SPEED),
 211                             MCDI_OUT_DWORD(req, GET_LINK_OUT_FCNTL),
 212                             &elsp->els_link_mode, &elsp->els_fcntl);
 213
 214 #if EFSYS_OPT_LOOPBACK
 215         /* Assert the MC_CMD_LOOPBACK and EFX_LOOPBACK namespace agree */
 216         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_NONE == EFX_LOOPBACK_OFF);
 217         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_DATA == EFX_LOOPBACK_DATA);
 218         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_GMAC == EFX_LOOPBACK_GMAC);
 219         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_XGMII == EFX_LOOPBACK_XGMII);
 220         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_XGXS == EFX_LOOPBACK_XGXS);
 221         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_XAUI == EFX_LOOPBACK_XAUI);
 222         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_GMII == EFX_LOOPBACK_GMII);
 223         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_SGMII == EFX_LOOPBACK_SGMII);
 224         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_XGBR == EFX_LOOPBACK_XGBR);
 225         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_XFI == EFX_LOOPBACK_XFI);
 226         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_XAUI_FAR == EFX_LOOPBACK_XAUI_FAR);
 227         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_GMII_FAR == EFX_LOOPBACK_GMII_FAR);
 228         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_SGMII_FAR == EFX_LOOPBACK_SGMII_FAR);
 229         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_XFI_FAR == EFX_LOOPBACK_XFI_FAR);
 230         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_GPHY == EFX_LOOPBACK_GPHY);
 231         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_PHYXS == EFX_LOOPBACK_PHY_XS);
 232         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_PCS == EFX_LOOPBACK_PCS);
 233         EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_PMAPMD == EFX_LOOPBACK_PMA_PMD);
 234
 235         elsp->els_loopback = MCDI_OUT_DWORD(req, GET_LINK_OUT_LOOPBACK_MODE);
 236 #endif  /* EFSYS_OPT_LOOPBACK */
 237
 238         elsp->els_mac_up = MCDI_OUT_DWORD(req, GET_LINK_OUT_MAC_FAULT) == 0;
 239
 240         return (0);
 241
 242 fail2:
 243         EFSYS_PROBE(fail2);
 244 fail1:
 245         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 246
 247         return (rc);
 248 }
 249
 250         __checkReturn   efx_rc_t
 251 ef10_phy_reconfigure(
 252         __in            efx_nic_t *enp)
 253 {
 254         efx_port_t *epp = &(enp->en_port);
 255         efx_mcdi_req_t req;
 256         uint8_t payload[MAX(MC_CMD_SET_LINK_IN_LEN,
 257                             MC_CMD_SET_LINK_OUT_LEN)];
 258         uint32_t cap_mask;
 259 #if EFSYS_OPT_PHY_LED_CONTROL
 260         unsigned int led_mode;
 261 #endif
 262         unsigned int speed;
 263         boolean_t supported;
 264         efx_rc_t rc;
 265
 266         if ((rc = efx_mcdi_link_control_supported(enp, &supported)) != 0)
 267                 goto fail1;
 268         if (supported == B_FALSE)
 269                 goto out;
 270
 271         (void) memset(payload, 0, sizeof (payload));
 272         req.emr_cmd = MC_CMD_SET_LINK;
 273         req.emr_in_buf = payload;
 274         req.emr_in_length = MC_CMD_SET_LINK_IN_LEN;
 275         req.emr_out_buf = payload;
 276         req.emr_out_length = MC_CMD_SET_LINK_OUT_LEN;
 277
 278         cap_mask = epp->ep_adv_cap_mask;
 279         MCDI_IN_POPULATE_DWORD_10(req, SET_LINK_IN_CAP,
 280                 PHY_CAP_10HDX, (cap_mask >> EFX_PHY_CAP_10HDX) & 0x1,
 281                 PHY_CAP_10FDX, (cap_mask >> EFX_PHY_CAP_10FDX) & 0x1,
 282                 PHY_CAP_100HDX, (cap_mask >> EFX_PHY_CAP_100HDX) & 0x1,
 283                 PHY_CAP_100FDX, (cap_mask >> EFX_PHY_CAP_100FDX) & 0x1,
 284                 PHY_CAP_1000HDX, (cap_mask >> EFX_PHY_CAP_1000HDX) & 0x1,
 285                 PHY_CAP_1000FDX, (cap_mask >> EFX_PHY_CAP_1000FDX) & 0x1,
 286                 PHY_CAP_10000FDX, (cap_mask >> EFX_PHY_CAP_10000FDX) & 0x1,
 287                 PHY_CAP_PAUSE, (cap_mask >> EFX_PHY_CAP_PAUSE) & 0x1,
 288                 PHY_CAP_ASYM, (cap_mask >> EFX_PHY_CAP_ASYM) & 0x1,
 289                 PHY_CAP_AN, (cap_mask >> EFX_PHY_CAP_AN) & 0x1);
 290         /* Too many fields for for POPULATE macros, so insert this afterwards */
 291         MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP,
 292             PHY_CAP_40000FDX, (cap_mask >> EFX_PHY_CAP_40000FDX) & 0x1);
 293
 294 #if EFSYS_OPT_LOOPBACK
 295         MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_MODE,
 296                     epp->ep_loopback_type);
 297         switch (epp->ep_loopback_link_mode) {
 298         case EFX_LINK_100FDX:
 299                 speed = 100;
 300                 break;
 301         case EFX_LINK_1000FDX:
 302                 speed = 1000;
 303                 break;
 304         case EFX_LINK_10000FDX:
 305                 speed = 10000;
 306                 break;
 307         case EFX_LINK_40000FDX:
 308                 speed = 40000;
 309                 break;
 310         default:
 311                 speed = 0;
 312         }
 313 #else
 314         MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_MODE, MC_CMD_LOOPBACK_NONE);
 315         speed = 0;
 316 #endif  /* EFSYS_OPT_LOOPBACK */
 317         MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_SPEED, speed);
 318
 319 #if EFSYS_OPT_PHY_FLAGS
 320         MCDI_IN_SET_DWORD(req, SET_LINK_IN_FLAGS, epp->ep_phy_flags);
 321 #else
 322         MCDI_IN_SET_DWORD(req, SET_LINK_IN_FLAGS, 0);
 323 #endif  /* EFSYS_OPT_PHY_FLAGS */
 324
 325         efx_mcdi_execute(enp, &req);
 326
 327         if (req.emr_rc != 0) {
 328                 rc = req.emr_rc;
 329                 goto fail2;
 330         }
 331
 332         /* And set the blink mode */
 333         (void) memset(payload, 0, sizeof (payload));
 334         req.emr_cmd = MC_CMD_SET_ID_LED;
 335         req.emr_in_buf = payload;
 336         req.emr_in_length = MC_CMD_SET_ID_LED_IN_LEN;
 337         req.emr_out_buf = payload;
 338         req.emr_out_length = MC_CMD_SET_ID_LED_OUT_LEN;
 339
 340 #if EFSYS_OPT_PHY_LED_CONTROL
 341         switch (epp->ep_phy_led_mode) {
 342         case EFX_PHY_LED_DEFAULT:
 343                 led_mode = MC_CMD_LED_DEFAULT;
 344                 break;
 345         case EFX_PHY_LED_OFF:
 346                 led_mode = MC_CMD_LED_OFF;
 347                 break;
 348         case EFX_PHY_LED_ON:
 349                 led_mode = MC_CMD_LED_ON;
 350                 break;
 351         default:
 352                 EFSYS_ASSERT(0);
 353                 led_mode = MC_CMD_LED_DEFAULT;
 354         }
 355
 356         MCDI_IN_SET_DWORD(req, SET_ID_LED_IN_STATE, led_mode);
 357 #else
 358         MCDI_IN_SET_DWORD(req, SET_ID_LED_IN_STATE, MC_CMD_LED_DEFAULT);
 359 #endif  /* EFSYS_OPT_PHY_LED_CONTROL */
 360
 361         efx_mcdi_execute(enp, &req);
 362
 363         if (req.emr_rc != 0) {
 364                 rc = req.emr_rc;
 365                 goto fail3;
 366         }
 367 out:
 368         return (0);
 369
 370 fail3:
 371         EFSYS_PROBE(fail3);
 372 fail2:
 373         EFSYS_PROBE(fail2);
 374 fail1:
 375         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 376
 377         return (rc);
 378 }
 379
 380         __checkReturn   efx_rc_t
 381 ef10_phy_verify(
 382         __in            efx_nic_t *enp)
 383 {
 384         efx_mcdi_req_t req;
 385         uint8_t payload[MAX(MC_CMD_GET_PHY_STATE_IN_LEN,
 386                             MC_CMD_GET_PHY_STATE_OUT_LEN)];
 387         uint32_t state;
 388         efx_rc_t rc;
 389
 390         (void) memset(payload, 0, sizeof (payload));
 391         req.emr_cmd = MC_CMD_GET_PHY_STATE;
 392         req.emr_in_buf = payload;
 393         req.emr_in_length = MC_CMD_GET_PHY_STATE_IN_LEN;
 394         req.emr_out_buf = payload;
 395         req.emr_out_length = MC_CMD_GET_PHY_STATE_OUT_LEN;
 396
 397         efx_mcdi_execute(enp, &req);
 398
 399         if (req.emr_rc != 0) {
 400                 rc = req.emr_rc;
 401                 goto fail1;
 402         }
 403
 404         if (req.emr_out_length_used < MC_CMD_GET_PHY_STATE_OUT_LEN) {
 405                 rc = EMSGSIZE;
 406                 goto fail2;
 407         }
 408
 409         state = MCDI_OUT_DWORD(req, GET_PHY_STATE_OUT_STATE);
 410         if (state != MC_CMD_PHY_STATE_OK) {
 411                 if (state != MC_CMD_PHY_STATE_ZOMBIE)
 412                         EFSYS_PROBE1(mc_pcol_error, int, state);
 413                 rc = ENOTACTIVE;
 414                 goto fail3;
 415         }
 416
 417         return (0);
 418
 419 fail3:
 420         EFSYS_PROBE(fail3);
 421 fail2:
 422         EFSYS_PROBE(fail2);
 423 fail1:
 424         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 425
 426         return (rc);
 427 }
 428
 429         __checkReturn   efx_rc_t
 430 ef10_phy_oui_get(
 431         __in            efx_nic_t *enp,
 432         __out           uint32_t *ouip)
 433 {
 434         _NOTE(ARGUNUSED(enp, ouip))
 435
 436         return (ENOTSUP);
 437 }
 438
 439 #if EFSYS_OPT_PHY_STATS
 440
 441         __checkReturn                           efx_rc_t
 442 ef10_phy_stats_update(
 443         __in                                    efx_nic_t *enp,
 444         __in                                    efsys_mem_t *esmp,
 445         __inout_ecount(EFX_PHY_NSTATS)          uint32_t *stat)
 446 {
 447         /* TBD: no stats support in firmware yet */
 448         _NOTE(ARGUNUSED(enp, esmp))
 449         memset(stat, 0, EFX_PHY_NSTATS * sizeof (*stat));
 450
 451         return (0);
 452 }
 453
 454 #endif  /* EFSYS_OPT_PHY_STATS */
 455
 456 #if EFSYS_OPT_BIST
 457
 458         __checkReturn           efx_rc_t
 459 ef10_bist_enable_offline(
 460         __in                    efx_nic_t *enp)
 461 {
 462         efx_rc_t rc;
 463
 464         if ((rc = efx_mcdi_bist_enable_offline(enp)) != 0)
 465                 goto fail1;
 466
 467         return (0);
 468
 469 fail1:
 470         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 471
 472         return (rc);
 473 }
 474
 475         __checkReturn           efx_rc_t
 476 ef10_bist_start(
 477         __in                    efx_nic_t *enp,
 478         __in                    efx_bist_type_t type)
 479 {
 480         efx_rc_t rc;
 481
 482         if ((rc = efx_mcdi_bist_start(enp, type)) != 0)
 483                 goto fail1;
 484
 485         return (0);
 486
 487 fail1:
 488         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 489
 490         return (rc);
 491 }
 492
 493         __checkReturn           efx_rc_t
 494 ef10_bist_poll(
 495         __in                    efx_nic_t *enp,
 496         __in                    efx_bist_type_t type,
 497         __out                   efx_bist_result_t *resultp,
 498         __out_opt __drv_when(count > 0, __notnull)
 499         uint32_t *value_maskp,
 500         __out_ecount_opt(count) __drv_when(count > 0, __notnull)
 501         unsigned long *valuesp,
 502         __in                    size_t count)
 503 {
 504         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 505         efx_mcdi_req_t req;
 506         uint8_t payload[MAX(MC_CMD_POLL_BIST_IN_LEN,
 507                             MCDI_CTL_SDU_LEN_MAX)];
 508         uint32_t value_mask = 0;
 509         uint32_t result;
 510         efx_rc_t rc;
 511
 512         _NOTE(ARGUNUSED(type))
 513
 514         (void) memset(payload, 0, sizeof (payload));
 515         req.emr_cmd = MC_CMD_POLL_BIST;
 516         req.emr_in_buf = payload;
 517         req.emr_in_length = MC_CMD_POLL_BIST_IN_LEN;
 518         req.emr_out_buf = payload;
 519         req.emr_out_length = MCDI_CTL_SDU_LEN_MAX;
 520
 521         efx_mcdi_execute(enp, &req);
 522
 523         if (req.emr_rc != 0) {
 524                 rc = req.emr_rc;
 525                 goto fail1;
 526         }
 527
 528         if (req.emr_out_length_used < MC_CMD_POLL_BIST_OUT_RESULT_OFST + 4) {
 529                 rc = EMSGSIZE;
 530                 goto fail2;
 531         }
 532
 533         if (count > 0)
 534                 (void) memset(valuesp, '\0', count * sizeof (unsigned long));
 535
 536         result = MCDI_OUT_DWORD(req, POLL_BIST_OUT_RESULT);
 537
 538         if (result == MC_CMD_POLL_BIST_FAILED &&
 539             req.emr_out_length >= MC_CMD_POLL_BIST_OUT_MEM_LEN &&
 540             count > EFX_BIST_MEM_ECC_FATAL) {
 541                 if (valuesp != NULL) {
 542                         valuesp[EFX_BIST_MEM_TEST] =
 543                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_TEST);
 544                         valuesp[EFX_BIST_MEM_ADDR] =
 545                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ADDR);
 546                         valuesp[EFX_BIST_MEM_BUS] =
 547                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_BUS);
 548                         valuesp[EFX_BIST_MEM_EXPECT] =
 549                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_EXPECT);
 550                         valuesp[EFX_BIST_MEM_ACTUAL] =
 551                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ACTUAL);
 552                         valuesp[EFX_BIST_MEM_ECC] =
 553                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC);
 554                         valuesp[EFX_BIST_MEM_ECC_PARITY] =
 555                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC_PARITY);
 556                         valuesp[EFX_BIST_MEM_ECC_FATAL] =
 557                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC_FATAL);
 558                 }
 559                 value_mask |= (1 << EFX_BIST_MEM_TEST) |
 560                     (1 << EFX_BIST_MEM_ADDR) |
 561                     (1 << EFX_BIST_MEM_BUS) |
 562                     (1 << EFX_BIST_MEM_EXPECT) |
 563                     (1 << EFX_BIST_MEM_ACTUAL) |
 564                     (1 << EFX_BIST_MEM_ECC) |
 565                     (1 << EFX_BIST_MEM_ECC_PARITY) |
 566                     (1 << EFX_BIST_MEM_ECC_FATAL);
 567         } else if (result == MC_CMD_POLL_BIST_FAILED &&
 568             encp->enc_phy_type == EFX_PHY_XFI_FARMI &&
 569             req.emr_out_length >= MC_CMD_POLL_BIST_OUT_MRSFP_LEN &&
 570             count > EFX_BIST_FAULT_CODE) {
 571                 if (valuesp != NULL)
 572                         valuesp[EFX_BIST_FAULT_CODE] =
 573                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MRSFP_TEST);
 574                 value_mask |= 1 << EFX_BIST_FAULT_CODE;
 575         }
 576
 577         if (value_maskp != NULL)
 578                 *value_maskp = value_mask;
 579
 580         EFSYS_ASSERT(resultp != NULL);
 581         if (result == MC_CMD_POLL_BIST_RUNNING)
 582                 *resultp = EFX_BIST_RESULT_RUNNING;
 583         else if (result == MC_CMD_POLL_BIST_PASSED)
 584                 *resultp = EFX_BIST_RESULT_PASSED;
 585         else
 586                 *resultp = EFX_BIST_RESULT_FAILED;
 587
 588         return (0);
 589
 590 fail2:
 591         EFSYS_PROBE(fail2);
 592 fail1:
 593         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 594
 595         return (rc);
 596 }
 597
 598                         void
 599 ef10_bist_stop(
 600         __in            efx_nic_t *enp,
 601         __in            efx_bist_type_t type)
 602 {
 603         /* There is no way to stop BIST on EF10. */
 604         _NOTE(ARGUNUSED(enp, type))
 605 }
 606
 607 #endif  /* EFSYS_OPT_BIST */
 608
 609 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */