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 || EFSYS_OPT_MEDFORD2
  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         /*
 216          * MC_CMD_LOOPBACK and EFX_LOOPBACK names are equivalent, so use the
 217          * MCDI value directly. Agreement is checked in efx_loopback_mask().
 218          */
 219         elsp->els_loopback = MCDI_OUT_DWORD(req, GET_LINK_OUT_LOOPBACK_MODE);
 220 #endif  /* EFSYS_OPT_LOOPBACK */
 221
 222         elsp->els_mac_up = MCDI_OUT_DWORD(req, GET_LINK_OUT_MAC_FAULT) == 0;
 223
 224         return (0);
 225
 226 fail2:
 227         EFSYS_PROBE(fail2);
 228 fail1:
 229         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 230
 231         return (rc);
 232 }
 233
 234         __checkReturn   efx_rc_t
 235 ef10_phy_reconfigure(
 236         __in            efx_nic_t *enp)
 237 {
 238         efx_port_t *epp = &(enp->en_port);
 239         efx_mcdi_req_t req;
 240         uint8_t payload[MAX(MC_CMD_SET_LINK_IN_LEN,
 241                             MC_CMD_SET_LINK_OUT_LEN)];
 242         uint32_t cap_mask;
 243 #if EFSYS_OPT_PHY_LED_CONTROL
 244         unsigned int led_mode;
 245 #endif
 246         unsigned int speed;
 247         boolean_t supported;
 248         efx_rc_t rc;
 249
 250         if ((rc = efx_mcdi_link_control_supported(enp, &supported)) != 0)
 251                 goto fail1;
 252         if (supported == B_FALSE)
 253                 goto out;
 254
 255         (void) memset(payload, 0, sizeof (payload));
 256         req.emr_cmd = MC_CMD_SET_LINK;
 257         req.emr_in_buf = payload;
 258         req.emr_in_length = MC_CMD_SET_LINK_IN_LEN;
 259         req.emr_out_buf = payload;
 260         req.emr_out_length = MC_CMD_SET_LINK_OUT_LEN;
 261
 262         cap_mask = epp->ep_adv_cap_mask;
 263         MCDI_IN_POPULATE_DWORD_10(req, SET_LINK_IN_CAP,
 264                 PHY_CAP_10HDX, (cap_mask >> EFX_PHY_CAP_10HDX) & 0x1,
 265                 PHY_CAP_10FDX, (cap_mask >> EFX_PHY_CAP_10FDX) & 0x1,
 266                 PHY_CAP_100HDX, (cap_mask >> EFX_PHY_CAP_100HDX) & 0x1,
 267                 PHY_CAP_100FDX, (cap_mask >> EFX_PHY_CAP_100FDX) & 0x1,
 268                 PHY_CAP_1000HDX, (cap_mask >> EFX_PHY_CAP_1000HDX) & 0x1,
 269                 PHY_CAP_1000FDX, (cap_mask >> EFX_PHY_CAP_1000FDX) & 0x1,
 270                 PHY_CAP_10000FDX, (cap_mask >> EFX_PHY_CAP_10000FDX) & 0x1,
 271                 PHY_CAP_PAUSE, (cap_mask >> EFX_PHY_CAP_PAUSE) & 0x1,
 272                 PHY_CAP_ASYM, (cap_mask >> EFX_PHY_CAP_ASYM) & 0x1,
 273                 PHY_CAP_AN, (cap_mask >> EFX_PHY_CAP_AN) & 0x1);
 274         /* Too many fields for for POPULATE macros, so insert this afterwards */
 275         MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP,
 276             PHY_CAP_40000FDX, (cap_mask >> EFX_PHY_CAP_40000FDX) & 0x1);
 277
 278 #if EFSYS_OPT_LOOPBACK
 279         MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_MODE,
 280                     epp->ep_loopback_type);
 281         switch (epp->ep_loopback_link_mode) {
 282         case EFX_LINK_100FDX:
 283                 speed = 100;
 284                 break;
 285         case EFX_LINK_1000FDX:
 286                 speed = 1000;
 287                 break;
 288         case EFX_LINK_10000FDX:
 289                 speed = 10000;
 290                 break;
 291         case EFX_LINK_40000FDX:
 292                 speed = 40000;
 293                 break;
 294         default:
 295                 speed = 0;
 296         }
 297 #else
 298         MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_MODE, MC_CMD_LOOPBACK_NONE);
 299         speed = 0;
 300 #endif  /* EFSYS_OPT_LOOPBACK */
 301         MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_SPEED, speed);
 302
 303 #if EFSYS_OPT_PHY_FLAGS
 304         MCDI_IN_SET_DWORD(req, SET_LINK_IN_FLAGS, epp->ep_phy_flags);
 305 #else
 306         MCDI_IN_SET_DWORD(req, SET_LINK_IN_FLAGS, 0);
 307 #endif  /* EFSYS_OPT_PHY_FLAGS */
 308
 309         efx_mcdi_execute(enp, &req);
 310
 311         if (req.emr_rc != 0) {
 312                 rc = req.emr_rc;
 313                 goto fail2;
 314         }
 315
 316         /* And set the blink mode */
 317         (void) memset(payload, 0, sizeof (payload));
 318         req.emr_cmd = MC_CMD_SET_ID_LED;
 319         req.emr_in_buf = payload;
 320         req.emr_in_length = MC_CMD_SET_ID_LED_IN_LEN;
 321         req.emr_out_buf = payload;
 322         req.emr_out_length = MC_CMD_SET_ID_LED_OUT_LEN;
 323
 324 #if EFSYS_OPT_PHY_LED_CONTROL
 325         switch (epp->ep_phy_led_mode) {
 326         case EFX_PHY_LED_DEFAULT:
 327                 led_mode = MC_CMD_LED_DEFAULT;
 328                 break;
 329         case EFX_PHY_LED_OFF:
 330                 led_mode = MC_CMD_LED_OFF;
 331                 break;
 332         case EFX_PHY_LED_ON:
 333                 led_mode = MC_CMD_LED_ON;
 334                 break;
 335         default:
 336                 EFSYS_ASSERT(0);
 337                 led_mode = MC_CMD_LED_DEFAULT;
 338         }
 339
 340         MCDI_IN_SET_DWORD(req, SET_ID_LED_IN_STATE, led_mode);
 341 #else
 342         MCDI_IN_SET_DWORD(req, SET_ID_LED_IN_STATE, MC_CMD_LED_DEFAULT);
 343 #endif  /* EFSYS_OPT_PHY_LED_CONTROL */
 344
 345         efx_mcdi_execute(enp, &req);
 346
 347         if (req.emr_rc != 0) {
 348                 rc = req.emr_rc;
 349                 goto fail3;
 350         }
 351 out:
 352         return (0);
 353
 354 fail3:
 355         EFSYS_PROBE(fail3);
 356 fail2:
 357         EFSYS_PROBE(fail2);
 358 fail1:
 359         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 360
 361         return (rc);
 362 }
 363
 364         __checkReturn   efx_rc_t
 365 ef10_phy_verify(
 366         __in            efx_nic_t *enp)
 367 {
 368         efx_mcdi_req_t req;
 369         uint8_t payload[MAX(MC_CMD_GET_PHY_STATE_IN_LEN,
 370                             MC_CMD_GET_PHY_STATE_OUT_LEN)];
 371         uint32_t state;
 372         efx_rc_t rc;
 373
 374         (void) memset(payload, 0, sizeof (payload));
 375         req.emr_cmd = MC_CMD_GET_PHY_STATE;
 376         req.emr_in_buf = payload;
 377         req.emr_in_length = MC_CMD_GET_PHY_STATE_IN_LEN;
 378         req.emr_out_buf = payload;
 379         req.emr_out_length = MC_CMD_GET_PHY_STATE_OUT_LEN;
 380
 381         efx_mcdi_execute(enp, &req);
 382
 383         if (req.emr_rc != 0) {
 384                 rc = req.emr_rc;
 385                 goto fail1;
 386         }
 387
 388         if (req.emr_out_length_used < MC_CMD_GET_PHY_STATE_OUT_LEN) {
 389                 rc = EMSGSIZE;
 390                 goto fail2;
 391         }
 392
 393         state = MCDI_OUT_DWORD(req, GET_PHY_STATE_OUT_STATE);
 394         if (state != MC_CMD_PHY_STATE_OK) {
 395                 if (state != MC_CMD_PHY_STATE_ZOMBIE)
 396                         EFSYS_PROBE1(mc_pcol_error, int, state);
 397                 rc = ENOTACTIVE;
 398                 goto fail3;
 399         }
 400
 401         return (0);
 402
 403 fail3:
 404         EFSYS_PROBE(fail3);
 405 fail2:
 406         EFSYS_PROBE(fail2);
 407 fail1:
 408         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 409
 410         return (rc);
 411 }
 412
 413         __checkReturn   efx_rc_t
 414 ef10_phy_oui_get(
 415         __in            efx_nic_t *enp,
 416         __out           uint32_t *ouip)
 417 {
 418         _NOTE(ARGUNUSED(enp, ouip))
 419
 420         return (ENOTSUP);
 421 }
 422
 423 #if EFSYS_OPT_PHY_STATS
 424
 425         __checkReturn                           efx_rc_t
 426 ef10_phy_stats_update(
 427         __in                                    efx_nic_t *enp,
 428         __in                                    efsys_mem_t *esmp,
 429         __inout_ecount(EFX_PHY_NSTATS)          uint32_t *stat)
 430 {
 431         /* TBD: no stats support in firmware yet */
 432         _NOTE(ARGUNUSED(enp, esmp))
 433         memset(stat, 0, EFX_PHY_NSTATS * sizeof (*stat));
 434
 435         return (0);
 436 }
 437
 438 #endif  /* EFSYS_OPT_PHY_STATS */
 439
 440 #if EFSYS_OPT_BIST
 441
 442         __checkReturn           efx_rc_t
 443 ef10_bist_enable_offline(
 444         __in                    efx_nic_t *enp)
 445 {
 446         efx_rc_t rc;
 447
 448         if ((rc = efx_mcdi_bist_enable_offline(enp)) != 0)
 449                 goto fail1;
 450
 451         return (0);
 452
 453 fail1:
 454         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 455
 456         return (rc);
 457 }
 458
 459         __checkReturn           efx_rc_t
 460 ef10_bist_start(
 461         __in                    efx_nic_t *enp,
 462         __in                    efx_bist_type_t type)
 463 {
 464         efx_rc_t rc;
 465
 466         if ((rc = efx_mcdi_bist_start(enp, type)) != 0)
 467                 goto fail1;
 468
 469         return (0);
 470
 471 fail1:
 472         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 473
 474         return (rc);
 475 }
 476
 477         __checkReturn           efx_rc_t
 478 ef10_bist_poll(
 479         __in                    efx_nic_t *enp,
 480         __in                    efx_bist_type_t type,
 481         __out                   efx_bist_result_t *resultp,
 482         __out_opt __drv_when(count > 0, __notnull)
 483         uint32_t *value_maskp,
 484         __out_ecount_opt(count) __drv_when(count > 0, __notnull)
 485         unsigned long *valuesp,
 486         __in                    size_t count)
 487 {
 488         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 489         efx_mcdi_req_t req;
 490         uint8_t payload[MAX(MC_CMD_POLL_BIST_IN_LEN,
 491                             MCDI_CTL_SDU_LEN_MAX)];
 492         uint32_t value_mask = 0;
 493         uint32_t result;
 494         efx_rc_t rc;
 495
 496         _NOTE(ARGUNUSED(type))
 497
 498         (void) memset(payload, 0, sizeof (payload));
 499         req.emr_cmd = MC_CMD_POLL_BIST;
 500         req.emr_in_buf = payload;
 501         req.emr_in_length = MC_CMD_POLL_BIST_IN_LEN;
 502         req.emr_out_buf = payload;
 503         req.emr_out_length = MCDI_CTL_SDU_LEN_MAX;
 504
 505         efx_mcdi_execute(enp, &req);
 506
 507         if (req.emr_rc != 0) {
 508                 rc = req.emr_rc;
 509                 goto fail1;
 510         }
 511
 512         if (req.emr_out_length_used < MC_CMD_POLL_BIST_OUT_RESULT_OFST + 4) {
 513                 rc = EMSGSIZE;
 514                 goto fail2;
 515         }
 516
 517         if (count > 0)
 518                 (void) memset(valuesp, '\0', count * sizeof (unsigned long));
 519
 520         result = MCDI_OUT_DWORD(req, POLL_BIST_OUT_RESULT);
 521
 522         if (result == MC_CMD_POLL_BIST_FAILED &&
 523             req.emr_out_length >= MC_CMD_POLL_BIST_OUT_MEM_LEN &&
 524             count > EFX_BIST_MEM_ECC_FATAL) {
 525                 if (valuesp != NULL) {
 526                         valuesp[EFX_BIST_MEM_TEST] =
 527                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_TEST);
 528                         valuesp[EFX_BIST_MEM_ADDR] =
 529                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ADDR);
 530                         valuesp[EFX_BIST_MEM_BUS] =
 531                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_BUS);
 532                         valuesp[EFX_BIST_MEM_EXPECT] =
 533                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_EXPECT);
 534                         valuesp[EFX_BIST_MEM_ACTUAL] =
 535                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ACTUAL);
 536                         valuesp[EFX_BIST_MEM_ECC] =
 537                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC);
 538                         valuesp[EFX_BIST_MEM_ECC_PARITY] =
 539                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC_PARITY);
 540                         valuesp[EFX_BIST_MEM_ECC_FATAL] =
 541                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC_FATAL);
 542                 }
 543                 value_mask |= (1 << EFX_BIST_MEM_TEST) |
 544                     (1 << EFX_BIST_MEM_ADDR) |
 545                     (1 << EFX_BIST_MEM_BUS) |
 546                     (1 << EFX_BIST_MEM_EXPECT) |
 547                     (1 << EFX_BIST_MEM_ACTUAL) |
 548                     (1 << EFX_BIST_MEM_ECC) |
 549                     (1 << EFX_BIST_MEM_ECC_PARITY) |
 550                     (1 << EFX_BIST_MEM_ECC_FATAL);
 551         } else if (result == MC_CMD_POLL_BIST_FAILED &&
 552             encp->enc_phy_type == EFX_PHY_XFI_FARMI &&
 553             req.emr_out_length >= MC_CMD_POLL_BIST_OUT_MRSFP_LEN &&
 554             count > EFX_BIST_FAULT_CODE) {
 555                 if (valuesp != NULL)
 556                         valuesp[EFX_BIST_FAULT_CODE] =
 557                             MCDI_OUT_DWORD(req, POLL_BIST_OUT_MRSFP_TEST);
 558                 value_mask |= 1 << EFX_BIST_FAULT_CODE;
 559         }
 560
 561         if (value_maskp != NULL)
 562                 *value_maskp = value_mask;
 563
 564         EFSYS_ASSERT(resultp != NULL);
 565         if (result == MC_CMD_POLL_BIST_RUNNING)
 566                 *resultp = EFX_BIST_RESULT_RUNNING;
 567         else if (result == MC_CMD_POLL_BIST_PASSED)
 568                 *resultp = EFX_BIST_RESULT_PASSED;
 569         else
 570                 *resultp = EFX_BIST_RESULT_FAILED;
 571
 572         return (0);
 573
 574 fail2:
 575         EFSYS_PROBE(fail2);
 576 fail1:
 577         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 578
 579         return (rc);
 580 }
 581
 582                         void
 583 ef10_bist_stop(
 584         __in            efx_nic_t *enp,
 585         __in            efx_bist_type_t type)
 586 {
 587         /* There is no way to stop BIST on EF10. */
 588         _NOTE(ARGUNUSED(enp, type))
 589 }
 590
 591 #endif  /* EFSYS_OPT_BIST */
 592
 593 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */