drivers/net/sfc/base/efx_mcdi.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright (c) 2008-2018 Solarflare Communications Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include "efx.h"
   8 #include "efx_impl.h"
   9
  10 #if EFSYS_OPT_MCDI
  11
  12 /*
  13  * There are three versions of the MCDI interface:
  14  *  - MCDIv0: Siena BootROM. Transport uses MCDIv1 headers.
  15  *  - MCDIv1: Siena firmware and Huntington BootROM.
  16  *  - MCDIv2: EF10 firmware (Huntington/Medford) and Medford BootROM.
  17  *            Transport uses MCDIv2 headers.
  18  *
  19  * MCDIv2 Header NOT_EPOCH flag
  20  * ----------------------------
  21  * A new epoch begins at initial startup or after an MC reboot, and defines when
  22  * the MC should reject stale MCDI requests.
  23  *
  24  * The first MCDI request sent by the host should contain NOT_EPOCH=0, and all
  25  * subsequent requests (until the next MC reboot) should contain NOT_EPOCH=1.
  26  *
  27  * After rebooting the MC will fail all requests with NOT_EPOCH=1 by writing a
  28  * response with ERROR=1 and DATALEN=0 until a request is seen with NOT_EPOCH=0.
  29  */
  30
  31
  32
  33 #if EFSYS_OPT_SIENA
  34
  35 static const efx_mcdi_ops_t     __efx_mcdi_siena_ops = {
  36         siena_mcdi_init,                /* emco_init */
  37         siena_mcdi_send_request,        /* emco_send_request */
  38         siena_mcdi_poll_reboot,         /* emco_poll_reboot */
  39         siena_mcdi_poll_response,       /* emco_poll_response */
  40         siena_mcdi_read_response,       /* emco_read_response */
  41         siena_mcdi_fini,                /* emco_fini */
  42         siena_mcdi_feature_supported,   /* emco_feature_supported */
  43         siena_mcdi_get_timeout,         /* emco_get_timeout */
  44 };
  45
  46 #endif  /* EFSYS_OPT_SIENA */
  47
  48 #if EFX_OPTS_EF10()
  49
  50 static const efx_mcdi_ops_t     __efx_mcdi_ef10_ops = {
  51         ef10_mcdi_init,                 /* emco_init */
  52         ef10_mcdi_send_request,         /* emco_send_request */
  53         ef10_mcdi_poll_reboot,          /* emco_poll_reboot */
  54         ef10_mcdi_poll_response,        /* emco_poll_response */
  55         ef10_mcdi_read_response,        /* emco_read_response */
  56         ef10_mcdi_fini,                 /* emco_fini */
  57         ef10_mcdi_feature_supported,    /* emco_feature_supported */
  58         ef10_mcdi_get_timeout,          /* emco_get_timeout */
  59 };
  60
  61 #endif  /* EFX_OPTS_EF10() */
  62
  63
  64
  65         __checkReturn   efx_rc_t
  66 efx_mcdi_init(
  67         __in            efx_nic_t *enp,
  68         __in            const efx_mcdi_transport_t *emtp)
  69 {
  70         const efx_mcdi_ops_t *emcop;
  71         efx_rc_t rc;
  72
  73         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
  74         EFSYS_ASSERT3U(enp->en_mod_flags, ==, 0);
  75
  76         switch (enp->en_family) {
  77 #if EFSYS_OPT_SIENA
  78         case EFX_FAMILY_SIENA:
  79                 emcop = &__efx_mcdi_siena_ops;
  80                 break;
  81 #endif  /* EFSYS_OPT_SIENA */
  82
  83 #if EFSYS_OPT_HUNTINGTON
  84         case EFX_FAMILY_HUNTINGTON:
  85                 emcop = &__efx_mcdi_ef10_ops;
  86                 break;
  87 #endif  /* EFSYS_OPT_HUNTINGTON */
  88
  89 #if EFSYS_OPT_MEDFORD
  90         case EFX_FAMILY_MEDFORD:
  91                 emcop = &__efx_mcdi_ef10_ops;
  92                 break;
  93 #endif  /* EFSYS_OPT_MEDFORD */
  94
  95 #if EFSYS_OPT_MEDFORD2
  96         case EFX_FAMILY_MEDFORD2:
  97                 emcop = &__efx_mcdi_ef10_ops;
  98                 break;
  99 #endif  /* EFSYS_OPT_MEDFORD2 */
 100
 101         default:
 102                 EFSYS_ASSERT(0);
 103                 rc = ENOTSUP;
 104                 goto fail1;
 105         }
 106
 107         if (enp->en_features & EFX_FEATURE_MCDI_DMA) {
 108                 /* MCDI requires a DMA buffer in host memory */
 109                 if ((emtp == NULL) || (emtp->emt_dma_mem) == NULL) {
 110                         rc = EINVAL;
 111                         goto fail2;
 112                 }
 113         }
 114         enp->en_mcdi.em_emtp = emtp;
 115
 116         if (emcop != NULL && emcop->emco_init != NULL) {
 117                 if ((rc = emcop->emco_init(enp, emtp)) != 0)
 118                         goto fail3;
 119         }
 120
 121         enp->en_mcdi.em_emcop = emcop;
 122         enp->en_mod_flags |= EFX_MOD_MCDI;
 123
 124         return (0);
 125
 126 fail3:
 127         EFSYS_PROBE(fail3);
 128 fail2:
 129         EFSYS_PROBE(fail2);
 130 fail1:
 131         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 132
 133         enp->en_mcdi.em_emcop = NULL;
 134         enp->en_mcdi.em_emtp = NULL;
 135         enp->en_mod_flags &= ~EFX_MOD_MCDI;
 136
 137         return (rc);
 138 }
 139
 140                         void
 141 efx_mcdi_fini(
 142         __in            efx_nic_t *enp)
 143 {
 144         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 145         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
 146
 147         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 148         EFSYS_ASSERT3U(enp->en_mod_flags, ==, EFX_MOD_MCDI);
 149
 150         if (emcop != NULL && emcop->emco_fini != NULL)
 151                 emcop->emco_fini(enp);
 152
 153         emip->emi_port = 0;
 154         emip->emi_aborted = 0;
 155
 156         enp->en_mcdi.em_emcop = NULL;
 157         enp->en_mod_flags &= ~EFX_MOD_MCDI;
 158 }
 159
 160                         void
 161 efx_mcdi_new_epoch(
 162         __in            efx_nic_t *enp)
 163 {
 164         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 165         efsys_lock_state_t state;
 166
 167         /* Start a new epoch (allow fresh MCDI requests to succeed) */
 168         EFSYS_LOCK(enp->en_eslp, state);
 169         emip->emi_new_epoch = B_TRUE;
 170         EFSYS_UNLOCK(enp->en_eslp, state);
 171 }
 172
 173 static                  void
 174 efx_mcdi_send_request(
 175         __in            efx_nic_t *enp,
 176         __in            void *hdrp,
 177         __in            size_t hdr_len,
 178         __in            void *sdup,
 179         __in            size_t sdu_len)
 180 {
 181         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
 182
 183         emcop->emco_send_request(enp, hdrp, hdr_len, sdup, sdu_len);
 184 }
 185
 186 static                  efx_rc_t
 187 efx_mcdi_poll_reboot(
 188         __in            efx_nic_t *enp)
 189 {
 190         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
 191         efx_rc_t rc;
 192
 193         rc = emcop->emco_poll_reboot(enp);
 194         return (rc);
 195 }
 196
 197 static                  boolean_t
 198 efx_mcdi_poll_response(
 199         __in            efx_nic_t *enp)
 200 {
 201         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
 202         boolean_t available;
 203
 204         available = emcop->emco_poll_response(enp);
 205         return (available);
 206 }
 207
 208 static                  void
 209 efx_mcdi_read_response(
 210         __in            efx_nic_t *enp,
 211         __out           void *bufferp,
 212         __in            size_t offset,
 213         __in            size_t length)
 214 {
 215         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
 216
 217         emcop->emco_read_response(enp, bufferp, offset, length);
 218 }
 219
 220                         void
 221 efx_mcdi_request_start(
 222         __in            efx_nic_t *enp,
 223         __in            efx_mcdi_req_t *emrp,
 224         __in            boolean_t ev_cpl)
 225 {
 226 #if EFSYS_OPT_MCDI_LOGGING
 227         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 228 #endif
 229         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 230         efx_dword_t hdr[2];
 231         size_t hdr_len;
 232         unsigned int max_version;
 233         unsigned int seq;
 234         unsigned int xflags;
 235         boolean_t new_epoch;
 236         efsys_lock_state_t state;
 237
 238         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 239         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
 240         EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
 241
 242         /*
 243          * efx_mcdi_request_start() is naturally serialised against both
 244          * efx_mcdi_request_poll() and efx_mcdi_ev_cpl()/efx_mcdi_ev_death(),
 245          * by virtue of there only being one outstanding MCDI request.
 246          * Unfortunately, upper layers may also call efx_mcdi_request_abort()
 247          * at any time, to timeout a pending mcdi request, That request may
 248          * then subsequently complete, meaning efx_mcdi_ev_cpl() or
 249          * efx_mcdi_ev_death() may end up running in parallel with
 250          * efx_mcdi_request_start(). This race is handled by ensuring that
 251          * %emi_pending_req, %emi_ev_cpl and %emi_seq are protected by the
 252          * en_eslp lock.
 253          */
 254         EFSYS_LOCK(enp->en_eslp, state);
 255         EFSYS_ASSERT(emip->emi_pending_req == NULL);
 256         emip->emi_pending_req = emrp;
 257         emip->emi_ev_cpl = ev_cpl;
 258         emip->emi_poll_cnt = 0;
 259         seq = emip->emi_seq++ & EFX_MASK32(MCDI_HEADER_SEQ);
 260         new_epoch = emip->emi_new_epoch;
 261         max_version = emip->emi_max_version;
 262         EFSYS_UNLOCK(enp->en_eslp, state);
 263
 264         xflags = 0;
 265         if (ev_cpl)
 266                 xflags |= MCDI_HEADER_XFLAGS_EVREQ;
 267
 268         /*
 269          * Huntington firmware supports MCDIv2, but the Huntington BootROM only
 270          * supports MCDIv1. Use MCDIv1 headers for MCDIv1 commands where
 271          * possible to support this.
 272          */
 273         if ((max_version >= 2) &&
 274             ((emrp->emr_cmd > MC_CMD_CMD_SPACE_ESCAPE_7) ||
 275             (emrp->emr_in_length > MCDI_CTL_SDU_LEN_MAX_V1) ||
 276             (emrp->emr_out_length > MCDI_CTL_SDU_LEN_MAX_V1))) {
 277                 /* Construct MCDI v2 header */
 278                 hdr_len = sizeof (hdr);
 279                 EFX_POPULATE_DWORD_8(hdr[0],
 280                     MCDI_HEADER_CODE, MC_CMD_V2_EXTN,
 281                     MCDI_HEADER_RESYNC, 1,
 282                     MCDI_HEADER_DATALEN, 0,
 283                     MCDI_HEADER_SEQ, seq,
 284                     MCDI_HEADER_NOT_EPOCH, new_epoch ? 0 : 1,
 285                     MCDI_HEADER_ERROR, 0,
 286                     MCDI_HEADER_RESPONSE, 0,
 287                     MCDI_HEADER_XFLAGS, xflags);
 288
 289                 EFX_POPULATE_DWORD_2(hdr[1],
 290                     MC_CMD_V2_EXTN_IN_EXTENDED_CMD, emrp->emr_cmd,
 291                     MC_CMD_V2_EXTN_IN_ACTUAL_LEN, emrp->emr_in_length);
 292         } else {
 293                 /* Construct MCDI v1 header */
 294                 hdr_len = sizeof (hdr[0]);
 295                 EFX_POPULATE_DWORD_8(hdr[0],
 296                     MCDI_HEADER_CODE, emrp->emr_cmd,
 297                     MCDI_HEADER_RESYNC, 1,
 298                     MCDI_HEADER_DATALEN, emrp->emr_in_length,
 299                     MCDI_HEADER_SEQ, seq,
 300                     MCDI_HEADER_NOT_EPOCH, new_epoch ? 0 : 1,
 301                     MCDI_HEADER_ERROR, 0,
 302                     MCDI_HEADER_RESPONSE, 0,
 303                     MCDI_HEADER_XFLAGS, xflags);
 304         }
 305
 306 #if EFSYS_OPT_MCDI_LOGGING
 307         if (emtp->emt_logger != NULL) {
 308                 emtp->emt_logger(emtp->emt_context, EFX_LOG_MCDI_REQUEST,
 309                     &hdr[0], hdr_len,
 310                     emrp->emr_in_buf, emrp->emr_in_length);
 311         }
 312 #endif /* EFSYS_OPT_MCDI_LOGGING */
 313
 314         efx_mcdi_send_request(enp, &hdr[0], hdr_len,
 315             emrp->emr_in_buf, emrp->emr_in_length);
 316 }
 317
 318
 319 static                  void
 320 efx_mcdi_read_response_header(
 321         __in            efx_nic_t *enp,
 322         __inout         efx_mcdi_req_t *emrp)
 323 {
 324 #if EFSYS_OPT_MCDI_LOGGING
 325         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 326 #endif /* EFSYS_OPT_MCDI_LOGGING */
 327         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 328         efx_dword_t hdr[2];
 329         unsigned int hdr_len;
 330         unsigned int data_len;
 331         unsigned int seq;
 332         unsigned int cmd;
 333         unsigned int error;
 334         efx_rc_t rc;
 335
 336         EFSYS_ASSERT(emrp != NULL);
 337
 338         efx_mcdi_read_response(enp, &hdr[0], 0, sizeof (hdr[0]));
 339         hdr_len = sizeof (hdr[0]);
 340
 341         cmd = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE);
 342         seq = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_SEQ);
 343         error = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_ERROR);
 344
 345         if (cmd != MC_CMD_V2_EXTN) {
 346                 data_len = EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_DATALEN);
 347         } else {
 348                 efx_mcdi_read_response(enp, &hdr[1], hdr_len, sizeof (hdr[1]));
 349                 hdr_len += sizeof (hdr[1]);
 350
 351                 cmd = EFX_DWORD_FIELD(hdr[1], MC_CMD_V2_EXTN_IN_EXTENDED_CMD);
 352                 data_len =
 353                     EFX_DWORD_FIELD(hdr[1], MC_CMD_V2_EXTN_IN_ACTUAL_LEN);
 354         }
 355
 356         if (error && (data_len == 0)) {
 357                 /* The MC has rebooted since the request was sent. */
 358                 EFSYS_SPIN(EFX_MCDI_STATUS_SLEEP_US);
 359                 efx_mcdi_poll_reboot(enp);
 360                 rc = EIO;
 361                 goto fail1;
 362         }
 363         if ((cmd != emrp->emr_cmd) ||
 364             (seq != ((emip->emi_seq - 1) & EFX_MASK32(MCDI_HEADER_SEQ)))) {
 365                 /* Response is for a different request */
 366                 rc = EIO;
 367                 goto fail2;
 368         }
 369         if (error) {
 370                 efx_dword_t err[2];
 371                 unsigned int err_len = MIN(data_len, sizeof (err));
 372                 int err_code = MC_CMD_ERR_EPROTO;
 373                 int err_arg = 0;
 374
 375                 /* Read error code (and arg num for MCDI v2 commands) */
 376                 efx_mcdi_read_response(enp, &err, hdr_len, err_len);
 377
 378                 if (err_len >= (MC_CMD_ERR_CODE_OFST + sizeof (efx_dword_t)))
 379                         err_code = EFX_DWORD_FIELD(err[0], EFX_DWORD_0);
 380 #ifdef WITH_MCDI_V2
 381                 if (err_len >= (MC_CMD_ERR_ARG_OFST + sizeof (efx_dword_t)))
 382                         err_arg = EFX_DWORD_FIELD(err[1], EFX_DWORD_0);
 383 #endif
 384                 emrp->emr_err_code = err_code;
 385                 emrp->emr_err_arg = err_arg;
 386
 387 #if EFSYS_OPT_MCDI_PROXY_AUTH
 388                 if ((err_code == MC_CMD_ERR_PROXY_PENDING) &&
 389                     (err_len == sizeof (err))) {
 390                         /*
 391                          * The MCDI request would normally fail with EPERM, but
 392                          * firmware has forwarded it to an authorization agent
 393                          * attached to a privileged PF.
 394                          *
 395                          * Save the authorization request handle. The client
 396                          * must wait for a PROXY_RESPONSE event, or timeout.
 397                          */
 398                         emrp->emr_proxy_handle = err_arg;
 399                 }
 400 #endif /* EFSYS_OPT_MCDI_PROXY_AUTH */
 401
 402 #if EFSYS_OPT_MCDI_LOGGING
 403                 if (emtp->emt_logger != NULL) {
 404                         emtp->emt_logger(emtp->emt_context,
 405                             EFX_LOG_MCDI_RESPONSE,
 406                             &hdr[0], hdr_len,
 407                             &err[0], err_len);
 408                 }
 409 #endif /* EFSYS_OPT_MCDI_LOGGING */
 410
 411                 if (!emrp->emr_quiet) {
 412                         EFSYS_PROBE3(mcdi_err_arg, int, emrp->emr_cmd,
 413                             int, err_code, int, err_arg);
 414                 }
 415
 416                 rc = efx_mcdi_request_errcode(err_code);
 417                 goto fail3;
 418         }
 419
 420         emrp->emr_rc = 0;
 421         emrp->emr_out_length_used = data_len;
 422 #if EFSYS_OPT_MCDI_PROXY_AUTH
 423         emrp->emr_proxy_handle = 0;
 424 #endif /* EFSYS_OPT_MCDI_PROXY_AUTH */
 425         return;
 426
 427 fail3:
 428 fail2:
 429 fail1:
 430         emrp->emr_rc = rc;
 431         emrp->emr_out_length_used = 0;
 432 }
 433
 434 static                  void
 435 efx_mcdi_finish_response(
 436         __in            efx_nic_t *enp,
 437         __in            efx_mcdi_req_t *emrp)
 438 {
 439 #if EFSYS_OPT_MCDI_LOGGING
 440         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 441 #endif /* EFSYS_OPT_MCDI_LOGGING */
 442         efx_dword_t hdr[2];
 443         unsigned int hdr_len;
 444         size_t bytes;
 445
 446         if (emrp->emr_out_buf == NULL)
 447                 return;
 448
 449         /* Read the command header to detect MCDI response format */
 450         hdr_len = sizeof (hdr[0]);
 451         efx_mcdi_read_response(enp, &hdr[0], 0, hdr_len);
 452         if (EFX_DWORD_FIELD(hdr[0], MCDI_HEADER_CODE) == MC_CMD_V2_EXTN) {
 453                 /*
 454                  * Read the actual payload length. The length given in the event
 455                  * is only correct for responses with the V1 format.
 456                  */
 457                 efx_mcdi_read_response(enp, &hdr[1], hdr_len, sizeof (hdr[1]));
 458                 hdr_len += sizeof (hdr[1]);
 459
 460                 emrp->emr_out_length_used = EFX_DWORD_FIELD(hdr[1],
 461                                             MC_CMD_V2_EXTN_IN_ACTUAL_LEN);
 462         }
 463
 464         /* Copy payload out into caller supplied buffer */
 465         bytes = MIN(emrp->emr_out_length_used, emrp->emr_out_length);
 466         efx_mcdi_read_response(enp, emrp->emr_out_buf, hdr_len, bytes);
 467
 468 #if EFSYS_OPT_MCDI_LOGGING
 469         if (emtp->emt_logger != NULL) {
 470                 emtp->emt_logger(emtp->emt_context,
 471                     EFX_LOG_MCDI_RESPONSE,
 472                     &hdr[0], hdr_len,
 473                     emrp->emr_out_buf, bytes);
 474         }
 475 #endif /* EFSYS_OPT_MCDI_LOGGING */
 476 }
 477
 478
 479         __checkReturn   boolean_t
 480 efx_mcdi_request_poll(
 481         __in            efx_nic_t *enp)
 482 {
 483         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 484         efx_mcdi_req_t *emrp;
 485         efsys_lock_state_t state;
 486         efx_rc_t rc;
 487
 488         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 489         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
 490         EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
 491
 492         /* Serialise against post-watchdog efx_mcdi_ev* */
 493         EFSYS_LOCK(enp->en_eslp, state);
 494
 495         EFSYS_ASSERT(emip->emi_pending_req != NULL);
 496         EFSYS_ASSERT(!emip->emi_ev_cpl);
 497         emrp = emip->emi_pending_req;
 498
 499         /* Check if hardware is unavailable */
 500         if (efx_nic_hw_unavailable(enp)) {
 501                 EFSYS_UNLOCK(enp->en_eslp, state);
 502                 return (B_FALSE);
 503         }
 504
 505         /* Check for reboot atomically w.r.t efx_mcdi_request_start */
 506         if (emip->emi_poll_cnt++ == 0) {
 507                 if ((rc = efx_mcdi_poll_reboot(enp)) != 0) {
 508                         emip->emi_pending_req = NULL;
 509                         EFSYS_UNLOCK(enp->en_eslp, state);
 510
 511                         /* Reboot/Assertion */
 512                         if (rc == EIO || rc == EINTR)
 513                                 efx_mcdi_raise_exception(enp, emrp, rc);
 514
 515                         goto fail1;
 516                 }
 517         }
 518
 519         /* Check if a response is available */
 520         if (efx_mcdi_poll_response(enp) == B_FALSE) {
 521                 EFSYS_UNLOCK(enp->en_eslp, state);
 522                 return (B_FALSE);
 523         }
 524
 525         /* Read the response header */
 526         efx_mcdi_read_response_header(enp, emrp);
 527
 528         /* Request complete */
 529         emip->emi_pending_req = NULL;
 530
 531         /* Ensure stale MCDI requests fail after an MC reboot. */
 532         emip->emi_new_epoch = B_FALSE;
 533
 534         EFSYS_UNLOCK(enp->en_eslp, state);
 535
 536         if ((rc = emrp->emr_rc) != 0)
 537                 goto fail2;
 538
 539         efx_mcdi_finish_response(enp, emrp);
 540         return (B_TRUE);
 541
 542 fail2:
 543         if (!emrp->emr_quiet)
 544                 EFSYS_PROBE(fail2);
 545 fail1:
 546         if (!emrp->emr_quiet)
 547                 EFSYS_PROBE1(fail1, efx_rc_t, rc);
 548
 549         return (B_TRUE);
 550 }
 551
 552         __checkReturn   boolean_t
 553 efx_mcdi_request_abort(
 554         __in            efx_nic_t *enp)
 555 {
 556         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 557         efx_mcdi_req_t *emrp;
 558         boolean_t aborted;
 559         efsys_lock_state_t state;
 560
 561         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 562         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
 563         EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
 564
 565         /*
 566          * efx_mcdi_ev_* may have already completed this event, and be
 567          * spinning/blocked on the upper layer lock. So it *is* legitimate
 568          * to for emi_pending_req to be NULL. If there is a pending event
 569          * completed request, then provide a "credit" to allow
 570          * efx_mcdi_ev_cpl() to accept a single spurious completion.
 571          */
 572         EFSYS_LOCK(enp->en_eslp, state);
 573         emrp = emip->emi_pending_req;
 574         aborted = (emrp != NULL);
 575         if (aborted) {
 576                 emip->emi_pending_req = NULL;
 577
 578                 /* Error the request */
 579                 emrp->emr_out_length_used = 0;
 580                 emrp->emr_rc = ETIMEDOUT;
 581
 582                 /* Provide a credit for seqno/emr_pending_req mismatches */
 583                 if (emip->emi_ev_cpl)
 584                         ++emip->emi_aborted;
 585
 586                 /*
 587                  * The upper layer has called us, so we don't
 588                  * need to complete the request.
 589                  */
 590         }
 591         EFSYS_UNLOCK(enp->en_eslp, state);
 592
 593         return (aborted);
 594 }
 595
 596                         void
 597 efx_mcdi_get_timeout(
 598         __in            efx_nic_t *enp,
 599         __in            efx_mcdi_req_t *emrp,
 600         __out           uint32_t *timeoutp)
 601 {
 602         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
 603
 604         emcop->emco_get_timeout(enp, emrp, timeoutp);
 605 }
 606
 607         __checkReturn   efx_rc_t
 608 efx_mcdi_request_errcode(
 609         __in            unsigned int err)
 610 {
 611
 612         switch (err) {
 613                 /* MCDI v1 */
 614         case MC_CMD_ERR_EPERM:
 615                 return (EACCES);
 616         case MC_CMD_ERR_ENOENT:
 617                 return (ENOENT);
 618         case MC_CMD_ERR_EINTR:
 619                 return (EINTR);
 620         case MC_CMD_ERR_EACCES:
 621                 return (EACCES);
 622         case MC_CMD_ERR_EBUSY:
 623                 return (EBUSY);
 624         case MC_CMD_ERR_EINVAL:
 625                 return (EINVAL);
 626         case MC_CMD_ERR_EDEADLK:
 627                 return (EDEADLK);
 628         case MC_CMD_ERR_ENOSYS:
 629                 return (ENOTSUP);
 630         case MC_CMD_ERR_ETIME:
 631                 return (ETIMEDOUT);
 632         case MC_CMD_ERR_ENOTSUP:
 633                 return (ENOTSUP);
 634         case MC_CMD_ERR_EALREADY:
 635                 return (EALREADY);
 636
 637                 /* MCDI v2 */
 638         case MC_CMD_ERR_EEXIST:
 639                 return (EEXIST);
 640 #ifdef MC_CMD_ERR_EAGAIN
 641         case MC_CMD_ERR_EAGAIN:
 642                 return (EAGAIN);
 643 #endif
 644 #ifdef MC_CMD_ERR_ENOSPC
 645         case MC_CMD_ERR_ENOSPC:
 646                 return (ENOSPC);
 647 #endif
 648         case MC_CMD_ERR_ERANGE:
 649                 return (ERANGE);
 650
 651         case MC_CMD_ERR_ALLOC_FAIL:
 652                 return (ENOMEM);
 653         case MC_CMD_ERR_NO_VADAPTOR:
 654                 return (ENOENT);
 655         case MC_CMD_ERR_NO_EVB_PORT:
 656                 return (ENOENT);
 657         case MC_CMD_ERR_NO_VSWITCH:
 658                 return (ENODEV);
 659         case MC_CMD_ERR_VLAN_LIMIT:
 660                 return (EINVAL);
 661         case MC_CMD_ERR_BAD_PCI_FUNC:
 662                 return (ENODEV);
 663         case MC_CMD_ERR_BAD_VLAN_MODE:
 664                 return (EINVAL);
 665         case MC_CMD_ERR_BAD_VSWITCH_TYPE:
 666                 return (EINVAL);
 667         case MC_CMD_ERR_BAD_VPORT_TYPE:
 668                 return (EINVAL);
 669         case MC_CMD_ERR_MAC_EXIST:
 670                 return (EEXIST);
 671
 672         case MC_CMD_ERR_PROXY_PENDING:
 673                 return (EAGAIN);
 674
 675         default:
 676                 EFSYS_PROBE1(mc_pcol_error, int, err);
 677                 return (EIO);
 678         }
 679 }
 680
 681                         void
 682 efx_mcdi_raise_exception(
 683         __in            efx_nic_t *enp,
 684         __in_opt        efx_mcdi_req_t *emrp,
 685         __in            int rc)
 686 {
 687         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 688         efx_mcdi_exception_t exception;
 689
 690         /* Reboot or Assertion failure only */
 691         EFSYS_ASSERT(rc == EIO || rc == EINTR);
 692
 693         /*
 694          * If MC_CMD_REBOOT causes a reboot (dependent on parameters),
 695          * then the EIO is not worthy of an exception.
 696          */
 697         if (emrp != NULL && emrp->emr_cmd == MC_CMD_REBOOT && rc == EIO)
 698                 return;
 699
 700         exception = (rc == EIO)
 701                 ? EFX_MCDI_EXCEPTION_MC_REBOOT
 702                 : EFX_MCDI_EXCEPTION_MC_BADASSERT;
 703
 704         emtp->emt_exception(emtp->emt_context, exception);
 705 }
 706
 707                         void
 708 efx_mcdi_execute(
 709         __in            efx_nic_t *enp,
 710         __inout         efx_mcdi_req_t *emrp)
 711 {
 712         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 713
 714         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
 715         EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
 716
 717         emrp->emr_quiet = B_FALSE;
 718         emtp->emt_execute(emtp->emt_context, emrp);
 719 }
 720
 721                         void
 722 efx_mcdi_execute_quiet(
 723         __in            efx_nic_t *enp,
 724         __inout         efx_mcdi_req_t *emrp)
 725 {
 726         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 727
 728         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
 729         EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
 730
 731         emrp->emr_quiet = B_TRUE;
 732         emtp->emt_execute(emtp->emt_context, emrp);
 733 }
 734
 735                         void
 736 efx_mcdi_ev_cpl(
 737         __in            efx_nic_t *enp,
 738         __in            unsigned int seq,
 739         __in            unsigned int outlen,
 740         __in            int errcode)
 741 {
 742         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 743         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 744         efx_mcdi_req_t *emrp;
 745         efsys_lock_state_t state;
 746
 747         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
 748         EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
 749
 750         /*
 751          * Serialise against efx_mcdi_request_poll()/efx_mcdi_request_start()
 752          * when we're completing an aborted request.
 753          */
 754         EFSYS_LOCK(enp->en_eslp, state);
 755         if (emip->emi_pending_req == NULL || !emip->emi_ev_cpl ||
 756             (seq != ((emip->emi_seq - 1) & EFX_MASK32(MCDI_HEADER_SEQ)))) {
 757                 EFSYS_ASSERT(emip->emi_aborted > 0);
 758                 if (emip->emi_aborted > 0)
 759                         --emip->emi_aborted;
 760                 EFSYS_UNLOCK(enp->en_eslp, state);
 761                 return;
 762         }
 763
 764         emrp = emip->emi_pending_req;
 765         emip->emi_pending_req = NULL;
 766         EFSYS_UNLOCK(enp->en_eslp, state);
 767
 768         if (emip->emi_max_version >= 2) {
 769                 /* MCDIv2 response details do not fit into an event. */
 770                 efx_mcdi_read_response_header(enp, emrp);
 771         } else {
 772                 if (errcode != 0) {
 773                         if (!emrp->emr_quiet) {
 774                                 EFSYS_PROBE2(mcdi_err, int, emrp->emr_cmd,
 775                                     int, errcode);
 776                         }
 777                         emrp->emr_out_length_used = 0;
 778                         emrp->emr_rc = efx_mcdi_request_errcode(errcode);
 779                 } else {
 780                         emrp->emr_out_length_used = outlen;
 781                         emrp->emr_rc = 0;
 782                 }
 783         }
 784         if (emrp->emr_rc == 0)
 785                 efx_mcdi_finish_response(enp, emrp);
 786
 787         emtp->emt_ev_cpl(emtp->emt_context);
 788 }
 789
 790 #if EFSYS_OPT_MCDI_PROXY_AUTH
 791
 792         __checkReturn   efx_rc_t
 793 efx_mcdi_get_proxy_handle(
 794         __in            efx_nic_t *enp,
 795         __in            efx_mcdi_req_t *emrp,
 796         __out           uint32_t *handlep)
 797 {
 798         efx_rc_t rc;
 799
 800         _NOTE(ARGUNUSED(enp))
 801
 802         /*
 803          * Return proxy handle from MCDI request that returned with error
 804          * MC_MCD_ERR_PROXY_PENDING. This handle is used to wait for a matching
 805          * PROXY_RESPONSE event.
 806          */
 807         if ((emrp == NULL) || (handlep == NULL)) {
 808                 rc = EINVAL;
 809                 goto fail1;
 810         }
 811         if ((emrp->emr_rc != 0) &&
 812             (emrp->emr_err_code == MC_CMD_ERR_PROXY_PENDING)) {
 813                 *handlep = emrp->emr_proxy_handle;
 814                 rc = 0;
 815         } else {
 816                 *handlep = 0;
 817                 rc = ENOENT;
 818         }
 819         return (rc);
 820
 821 fail1:
 822         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 823         return (rc);
 824 }
 825
 826                         void
 827 efx_mcdi_ev_proxy_response(
 828         __in            efx_nic_t *enp,
 829         __in            unsigned int handle,
 830         __in            unsigned int status)
 831 {
 832         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 833         efx_rc_t rc;
 834
 835         /*
 836          * Handle results of an authorization request for a privileged MCDI
 837          * command. If authorization was granted then we must re-issue the
 838          * original MCDI request. If authorization failed or timed out,
 839          * then the original MCDI request should be completed with the
 840          * result code from this event.
 841          */
 842         rc = (status == 0) ? 0 : efx_mcdi_request_errcode(status);
 843
 844         emtp->emt_ev_proxy_response(emtp->emt_context, handle, rc);
 845 }
 846 #endif /* EFSYS_OPT_MCDI_PROXY_AUTH */
 847
 848 #if EFSYS_OPT_MCDI_PROXY_AUTH_SERVER
 849                         void
 850 efx_mcdi_ev_proxy_request(
 851         __in            efx_nic_t *enp,
 852         __in            unsigned int index)
 853 {
 854         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 855
 856         if (emtp->emt_ev_proxy_request != NULL)
 857                 emtp->emt_ev_proxy_request(emtp->emt_context, index);
 858 }
 859 #endif /* EFSYS_OPT_MCDI_PROXY_AUTH_SERVER */
 860                         void
 861 efx_mcdi_ev_death(
 862         __in            efx_nic_t *enp,
 863         __in            int rc)
 864 {
 865         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 866         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 867         efx_mcdi_req_t *emrp = NULL;
 868         boolean_t ev_cpl;
 869         efsys_lock_state_t state;
 870
 871         /*
 872          * The MCDI request (if there is one) has been terminated, either
 873          * by a BADASSERT or REBOOT event.
 874          *
 875          * If there is an outstanding event-completed MCDI operation, then we
 876          * will never receive the completion event (because both MCDI
 877          * completions and BADASSERT events are sent to the same evq). So
 878          * complete this MCDI op.
 879          *
 880          * This function might run in parallel with efx_mcdi_request_poll()
 881          * for poll completed mcdi requests, and also with
 882          * efx_mcdi_request_start() for post-watchdog completions.
 883          */
 884         EFSYS_LOCK(enp->en_eslp, state);
 885         emrp = emip->emi_pending_req;
 886         ev_cpl = emip->emi_ev_cpl;
 887         if (emrp != NULL && emip->emi_ev_cpl) {
 888                 emip->emi_pending_req = NULL;
 889
 890                 emrp->emr_out_length_used = 0;
 891                 emrp->emr_rc = rc;
 892                 ++emip->emi_aborted;
 893         }
 894
 895         /*
 896          * Since we're running in parallel with a request, consume the
 897          * status word before dropping the lock.
 898          */
 899         if (rc == EIO || rc == EINTR) {
 900                 EFSYS_SPIN(EFX_MCDI_STATUS_SLEEP_US);
 901                 (void) efx_mcdi_poll_reboot(enp);
 902                 emip->emi_new_epoch = B_TRUE;
 903         }
 904
 905         EFSYS_UNLOCK(enp->en_eslp, state);
 906
 907         efx_mcdi_raise_exception(enp, emrp, rc);
 908
 909         if (emrp != NULL && ev_cpl)
 910                 emtp->emt_ev_cpl(emtp->emt_context);
 911 }
 912
 913         __checkReturn           efx_rc_t
 914 efx_mcdi_version(
 915         __in                    efx_nic_t *enp,
 916         __out_ecount_opt(4)     uint16_t versionp[4],
 917         __out_opt               uint32_t *buildp,
 918         __out_opt               efx_mcdi_boot_t *statusp)
 919 {
 920         efx_mcdi_req_t req;
 921         EFX_MCDI_DECLARE_BUF(payload,
 922                 MAX(MC_CMD_GET_VERSION_IN_LEN, MC_CMD_GET_BOOT_STATUS_IN_LEN),
 923                 MAX(MC_CMD_GET_VERSION_OUT_LEN,
 924                         MC_CMD_GET_BOOT_STATUS_OUT_LEN));
 925         efx_word_t *ver_words;
 926         uint16_t version[4];
 927         uint32_t build;
 928         efx_mcdi_boot_t status;
 929         efx_rc_t rc;
 930
 931         EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
 932
 933         req.emr_cmd = MC_CMD_GET_VERSION;
 934         req.emr_in_buf = payload;
 935         req.emr_in_length = MC_CMD_GET_VERSION_IN_LEN;
 936         req.emr_out_buf = payload;
 937         req.emr_out_length = MC_CMD_GET_VERSION_OUT_LEN;
 938
 939         efx_mcdi_execute(enp, &req);
 940
 941         if (req.emr_rc != 0) {
 942                 rc = req.emr_rc;
 943                 goto fail1;
 944         }
 945
 946         /* bootrom support */
 947         if (req.emr_out_length_used == MC_CMD_GET_VERSION_V0_OUT_LEN) {
 948                 version[0] = version[1] = version[2] = version[3] = 0;
 949                 build = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE);
 950
 951                 goto version;
 952         }
 953
 954         if (req.emr_out_length_used < MC_CMD_GET_VERSION_OUT_LEN) {
 955                 rc = EMSGSIZE;
 956                 goto fail2;
 957         }
 958
 959         ver_words = MCDI_OUT2(req, efx_word_t, GET_VERSION_OUT_VERSION);
 960         version[0] = EFX_WORD_FIELD(ver_words[0], EFX_WORD_0);
 961         version[1] = EFX_WORD_FIELD(ver_words[1], EFX_WORD_0);
 962         version[2] = EFX_WORD_FIELD(ver_words[2], EFX_WORD_0);
 963         version[3] = EFX_WORD_FIELD(ver_words[3], EFX_WORD_0);
 964         build = MCDI_OUT_DWORD(req, GET_VERSION_OUT_FIRMWARE);
 965
 966 version:
 967         /* The bootrom doesn't understand BOOT_STATUS */
 968         if (MC_FW_VERSION_IS_BOOTLOADER(build)) {
 969                 status = EFX_MCDI_BOOT_ROM;
 970                 goto out;
 971         }
 972
 973         (void) memset(payload, 0, sizeof (payload));
 974         req.emr_cmd = MC_CMD_GET_BOOT_STATUS;
 975         req.emr_in_buf = payload;
 976         req.emr_in_length = MC_CMD_GET_BOOT_STATUS_IN_LEN;
 977         req.emr_out_buf = payload;
 978         req.emr_out_length = MC_CMD_GET_BOOT_STATUS_OUT_LEN;
 979
 980         efx_mcdi_execute_quiet(enp, &req);
 981
 982         if (req.emr_rc == EACCES) {
 983                 /* Unprivileged functions cannot access BOOT_STATUS */
 984                 status = EFX_MCDI_BOOT_PRIMARY;
 985                 version[0] = version[1] = version[2] = version[3] = 0;
 986                 build = 0;
 987                 goto out;
 988         }
 989
 990         if (req.emr_rc != 0) {
 991                 rc = req.emr_rc;
 992                 goto fail3;
 993         }
 994
 995         if (req.emr_out_length_used < MC_CMD_GET_BOOT_STATUS_OUT_LEN) {
 996                 rc = EMSGSIZE;
 997                 goto fail4;
 998         }
 999
1000         if (MCDI_OUT_DWORD_FIELD(req, GET_BOOT_STATUS_OUT_FLAGS,
1001             GET_BOOT_STATUS_OUT_FLAGS_PRIMARY))
1002                 status = EFX_MCDI_BOOT_PRIMARY;
1003         else
1004                 status = EFX_MCDI_BOOT_SECONDARY;
1005
1006 out:
1007         if (versionp != NULL)
1008                 memcpy(versionp, version, sizeof (version));
1009         if (buildp != NULL)
1010                 *buildp = build;
1011         if (statusp != NULL)
1012                 *statusp = status;
1013
1014         return (0);
1015
1016 fail4:
1017         EFSYS_PROBE(fail4);
1018 fail3:
1019         EFSYS_PROBE(fail3);
1020 fail2:
1021         EFSYS_PROBE(fail2);
1022 fail1:
1023         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1024
1025         return (rc);
1026 }
1027
1028         __checkReturn   efx_rc_t
1029 efx_mcdi_get_capabilities(
1030         __in            efx_nic_t *enp,
1031         __out_opt       uint32_t *flagsp,
1032         __out_opt       uint16_t *rx_dpcpu_fw_idp,
1033         __out_opt       uint16_t *tx_dpcpu_fw_idp,
1034         __out_opt       uint32_t *flags2p,
1035         __out_opt       uint32_t *tso2ncp)
1036 {
1037         efx_mcdi_req_t req;
1038         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_CAPABILITIES_IN_LEN,
1039                 MC_CMD_GET_CAPABILITIES_V2_OUT_LEN);
1040         boolean_t v2_capable;
1041         efx_rc_t rc;
1042
1043         req.emr_cmd = MC_CMD_GET_CAPABILITIES;
1044         req.emr_in_buf = payload;
1045         req.emr_in_length = MC_CMD_GET_CAPABILITIES_IN_LEN;
1046         req.emr_out_buf = payload;
1047         req.emr_out_length = MC_CMD_GET_CAPABILITIES_V2_OUT_LEN;
1048
1049         efx_mcdi_execute_quiet(enp, &req);
1050
1051         if (req.emr_rc != 0) {
1052                 rc = req.emr_rc;
1053                 goto fail1;
1054         }
1055
1056         if (req.emr_out_length_used < MC_CMD_GET_CAPABILITIES_OUT_LEN) {
1057                 rc = EMSGSIZE;
1058                 goto fail2;
1059         }
1060
1061         if (flagsp != NULL)
1062                 *flagsp = MCDI_OUT_DWORD(req, GET_CAPABILITIES_OUT_FLAGS1);
1063
1064         if (rx_dpcpu_fw_idp != NULL)
1065                 *rx_dpcpu_fw_idp = MCDI_OUT_WORD(req,
1066                                         GET_CAPABILITIES_OUT_RX_DPCPU_FW_ID);
1067
1068         if (tx_dpcpu_fw_idp != NULL)
1069                 *tx_dpcpu_fw_idp = MCDI_OUT_WORD(req,
1070                                         GET_CAPABILITIES_OUT_TX_DPCPU_FW_ID);
1071
1072         if (req.emr_out_length_used < MC_CMD_GET_CAPABILITIES_V2_OUT_LEN)
1073                 v2_capable = B_FALSE;
1074         else
1075                 v2_capable = B_TRUE;
1076
1077         if (flags2p != NULL) {
1078                 *flags2p = (v2_capable) ?
1079                         MCDI_OUT_DWORD(req, GET_CAPABILITIES_V2_OUT_FLAGS2) :
1080                         0;
1081         }
1082
1083         if (tso2ncp != NULL) {
1084                 *tso2ncp = (v2_capable) ?
1085                         MCDI_OUT_WORD(req,
1086                                 GET_CAPABILITIES_V2_OUT_TX_TSO_V2_N_CONTEXTS) :
1087                         0;
1088         }
1089
1090         return (0);
1091
1092 fail2:
1093         EFSYS_PROBE(fail2);
1094 fail1:
1095         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1096
1097         return (rc);
1098 }
1099
1100 static  __checkReturn   efx_rc_t
1101 efx_mcdi_do_reboot(
1102         __in            efx_nic_t *enp,
1103         __in            boolean_t after_assertion)
1104 {
1105         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_REBOOT_IN_LEN,
1106                 MC_CMD_REBOOT_OUT_LEN);
1107         efx_mcdi_req_t req;
1108         efx_rc_t rc;
1109
1110         /*
1111          * We could require the caller to have caused en_mod_flags=0 to
1112          * call this function. This doesn't help the other port though,
1113          * who's about to get the MC ripped out from underneath them.
1114          * Since they have to cope with the subsequent fallout of MCDI
1115          * failures, we should as well.
1116          */
1117         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
1118
1119         req.emr_cmd = MC_CMD_REBOOT;
1120         req.emr_in_buf = payload;
1121         req.emr_in_length = MC_CMD_REBOOT_IN_LEN;
1122         req.emr_out_buf = payload;
1123         req.emr_out_length = MC_CMD_REBOOT_OUT_LEN;
1124
1125         MCDI_IN_SET_DWORD(req, REBOOT_IN_FLAGS,
1126             (after_assertion ? MC_CMD_REBOOT_FLAGS_AFTER_ASSERTION : 0));
1127
1128         efx_mcdi_execute_quiet(enp, &req);
1129
1130         if (req.emr_rc == EACCES) {
1131                 /* Unprivileged functions cannot reboot the MC. */
1132                 goto out;
1133         }
1134
1135         /* A successful reboot request returns EIO. */
1136         if (req.emr_rc != 0 && req.emr_rc != EIO) {
1137                 rc = req.emr_rc;
1138                 goto fail1;
1139         }
1140
1141 out:
1142         return (0);
1143
1144 fail1:
1145         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1146
1147         return (rc);
1148 }
1149
1150         __checkReturn   efx_rc_t
1151 efx_mcdi_reboot(
1152         __in            efx_nic_t *enp)
1153 {
1154         return (efx_mcdi_do_reboot(enp, B_FALSE));
1155 }
1156
1157         __checkReturn   efx_rc_t
1158 efx_mcdi_exit_assertion_handler(
1159         __in            efx_nic_t *enp)
1160 {
1161         return (efx_mcdi_do_reboot(enp, B_TRUE));
1162 }
1163
1164         __checkReturn   efx_rc_t
1165 efx_mcdi_read_assertion(
1166         __in            efx_nic_t *enp)
1167 {
1168         efx_mcdi_req_t req;
1169         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_ASSERTS_IN_LEN,
1170                 MC_CMD_GET_ASSERTS_OUT_LEN);
1171         const char *reason;
1172         unsigned int flags;
1173         unsigned int index;
1174         unsigned int ofst;
1175         int retry;
1176         efx_rc_t rc;
1177
1178         /*
1179          * Before we attempt to chat to the MC, we should verify that the MC
1180          * isn't in it's assertion handler, either due to a previous reboot,
1181          * or because we're reinitializing due to an eec_exception().
1182          *
1183          * Use GET_ASSERTS to read any assertion state that may be present.
1184          * Retry this command twice. Once because a boot-time assertion failure
1185          * might cause the 1st MCDI request to fail. And once again because
1186          * we might race with efx_mcdi_exit_assertion_handler() running on
1187          * partner port(s) on the same NIC.
1188          */
1189         retry = 2;
1190         do {
1191                 (void) memset(payload, 0, sizeof (payload));
1192                 req.emr_cmd = MC_CMD_GET_ASSERTS;
1193                 req.emr_in_buf = payload;
1194                 req.emr_in_length = MC_CMD_GET_ASSERTS_IN_LEN;
1195                 req.emr_out_buf = payload;
1196                 req.emr_out_length = MC_CMD_GET_ASSERTS_OUT_LEN;
1197
1198                 MCDI_IN_SET_DWORD(req, GET_ASSERTS_IN_CLEAR, 1);
1199                 efx_mcdi_execute_quiet(enp, &req);
1200
1201         } while ((req.emr_rc == EINTR || req.emr_rc == EIO) && retry-- > 0);
1202
1203         if (req.emr_rc != 0) {
1204                 if (req.emr_rc == EACCES) {
1205                         /* Unprivileged functions cannot clear assertions. */
1206                         goto out;
1207                 }
1208                 rc = req.emr_rc;
1209                 goto fail1;
1210         }
1211
1212         if (req.emr_out_length_used < MC_CMD_GET_ASSERTS_OUT_LEN) {
1213                 rc = EMSGSIZE;
1214                 goto fail2;
1215         }
1216
1217         /* Print out any assertion state recorded */
1218         flags = MCDI_OUT_DWORD(req, GET_ASSERTS_OUT_GLOBAL_FLAGS);
1219         if (flags == MC_CMD_GET_ASSERTS_FLAGS_NO_FAILS)
1220                 return (0);
1221
1222         reason = (flags == MC_CMD_GET_ASSERTS_FLAGS_SYS_FAIL)
1223                 ? "system-level assertion"
1224                 : (flags == MC_CMD_GET_ASSERTS_FLAGS_THR_FAIL)
1225                 ? "thread-level assertion"
1226                 : (flags == MC_CMD_GET_ASSERTS_FLAGS_WDOG_FIRED)
1227                 ? "watchdog reset"
1228                 : (flags == MC_CMD_GET_ASSERTS_FLAGS_ADDR_TRAP)
1229                 ? "illegal address trap"
1230                 : "unknown assertion";
1231         EFSYS_PROBE3(mcpu_assertion,
1232             const char *, reason, unsigned int,
1233             MCDI_OUT_DWORD(req, GET_ASSERTS_OUT_SAVED_PC_OFFS),
1234             unsigned int,
1235             MCDI_OUT_DWORD(req, GET_ASSERTS_OUT_THREAD_OFFS));
1236
1237         /* Print out the registers (r1 ... r31) */
1238         ofst = MC_CMD_GET_ASSERTS_OUT_GP_REGS_OFFS_OFST;
1239         for (index = 1;
1240                 index < 1 + MC_CMD_GET_ASSERTS_OUT_GP_REGS_OFFS_NUM;
1241                 index++) {
1242                 EFSYS_PROBE2(mcpu_register, unsigned int, index, unsigned int,
1243                             EFX_DWORD_FIELD(*MCDI_OUT(req, efx_dword_t, ofst),
1244                                             EFX_DWORD_0));
1245                 ofst += sizeof (efx_dword_t);
1246         }
1247         EFSYS_ASSERT(ofst <= MC_CMD_GET_ASSERTS_OUT_LEN);
1248
1249 out:
1250         return (0);
1251
1252 fail2:
1253         EFSYS_PROBE(fail2);
1254 fail1:
1255         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1256
1257         return (rc);
1258 }
1259
1260
1261 /*
1262  * Internal routines for for specific MCDI requests.
1263  */
1264
1265         __checkReturn   efx_rc_t
1266 efx_mcdi_drv_attach(
1267         __in            efx_nic_t *enp,
1268         __in            boolean_t attach)
1269 {
1270         efx_mcdi_req_t req;
1271         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_DRV_ATTACH_IN_V2_LEN,
1272                 MC_CMD_DRV_ATTACH_EXT_OUT_LEN);
1273         efx_rc_t rc;
1274
1275         req.emr_cmd = MC_CMD_DRV_ATTACH;
1276         req.emr_in_buf = payload;
1277         if (enp->en_drv_version[0] == '\0') {
1278                 req.emr_in_length = MC_CMD_DRV_ATTACH_IN_LEN;
1279         } else {
1280                 req.emr_in_length = MC_CMD_DRV_ATTACH_IN_V2_LEN;
1281         }
1282         req.emr_out_buf = payload;
1283         req.emr_out_length = MC_CMD_DRV_ATTACH_EXT_OUT_LEN;
1284
1285         /*
1286          * Typically, client drivers use DONT_CARE for the datapath firmware
1287          * type to ensure that the driver can attach to an unprivileged
1288          * function. The datapath firmware type to use is controlled by the
1289          * 'sfboot' utility.
1290          * If a client driver wishes to attach with a specific datapath firmware
1291          * type, that can be passed in second argument of efx_nic_probe API. One
1292          * such example is the ESXi native driver that attempts attaching with
1293          * FULL_FEATURED datapath firmware type first and fall backs to
1294          * DONT_CARE datapath firmware type if MC_CMD_DRV_ATTACH fails.
1295          */
1296         MCDI_IN_POPULATE_DWORD_2(req, DRV_ATTACH_IN_NEW_STATE,
1297             DRV_ATTACH_IN_ATTACH, attach ? 1 : 0,
1298             DRV_ATTACH_IN_SUBVARIANT_AWARE, EFSYS_OPT_FW_SUBVARIANT_AWARE);
1299         MCDI_IN_SET_DWORD(req, DRV_ATTACH_IN_UPDATE, 1);
1300         MCDI_IN_SET_DWORD(req, DRV_ATTACH_IN_FIRMWARE_ID, enp->efv);
1301
1302         if (req.emr_in_length >= MC_CMD_DRV_ATTACH_IN_V2_LEN) {
1303                 EFX_STATIC_ASSERT(sizeof (enp->en_drv_version) ==
1304                     MC_CMD_DRV_ATTACH_IN_V2_DRIVER_VERSION_LEN);
1305                 memcpy(MCDI_IN2(req, char, DRV_ATTACH_IN_V2_DRIVER_VERSION),
1306                     enp->en_drv_version,
1307                     MC_CMD_DRV_ATTACH_IN_V2_DRIVER_VERSION_LEN);
1308         }
1309
1310         efx_mcdi_execute(enp, &req);
1311
1312         if (req.emr_rc != 0) {
1313                 rc = req.emr_rc;
1314                 goto fail1;
1315         }
1316
1317         if (req.emr_out_length_used < MC_CMD_DRV_ATTACH_OUT_LEN) {
1318                 rc = EMSGSIZE;
1319                 goto fail2;
1320         }
1321
1322         return (0);
1323
1324 fail2:
1325         EFSYS_PROBE(fail2);
1326 fail1:
1327         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1328
1329         return (rc);
1330 }
1331
1332         __checkReturn           efx_rc_t
1333 efx_mcdi_get_board_cfg(
1334         __in                    efx_nic_t *enp,
1335         __out_opt               uint32_t *board_typep,
1336         __out_opt               efx_dword_t *capabilitiesp,
1337         __out_ecount_opt(6)     uint8_t mac_addrp[6])
1338 {
1339         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
1340         efx_mcdi_req_t req;
1341         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_BOARD_CFG_IN_LEN,
1342                 MC_CMD_GET_BOARD_CFG_OUT_LENMIN);
1343         efx_rc_t rc;
1344
1345         req.emr_cmd = MC_CMD_GET_BOARD_CFG;
1346         req.emr_in_buf = payload;
1347         req.emr_in_length = MC_CMD_GET_BOARD_CFG_IN_LEN;
1348         req.emr_out_buf = payload;
1349         req.emr_out_length = MC_CMD_GET_BOARD_CFG_OUT_LENMIN;
1350
1351         efx_mcdi_execute(enp, &req);
1352
1353         if (req.emr_rc != 0) {
1354                 rc = req.emr_rc;
1355                 goto fail1;
1356         }
1357
1358         if (req.emr_out_length_used < MC_CMD_GET_BOARD_CFG_OUT_LENMIN) {
1359                 rc = EMSGSIZE;
1360                 goto fail2;
1361         }
1362
1363         if (mac_addrp != NULL) {
1364                 uint8_t *addrp;
1365
1366                 if (emip->emi_port == 1) {
1367                         addrp = MCDI_OUT2(req, uint8_t,
1368                             GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT0);
1369                 } else if (emip->emi_port == 2) {
1370                         addrp = MCDI_OUT2(req, uint8_t,
1371                             GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT1);
1372                 } else {
1373                         rc = EINVAL;
1374                         goto fail3;
1375                 }
1376
1377                 EFX_MAC_ADDR_COPY(mac_addrp, addrp);
1378         }
1379
1380         if (capabilitiesp != NULL) {
1381                 if (emip->emi_port == 1) {
1382                         *capabilitiesp = *MCDI_OUT2(req, efx_dword_t,
1383                             GET_BOARD_CFG_OUT_CAPABILITIES_PORT0);
1384                 } else if (emip->emi_port == 2) {
1385                         *capabilitiesp = *MCDI_OUT2(req, efx_dword_t,
1386                             GET_BOARD_CFG_OUT_CAPABILITIES_PORT1);
1387                 } else {
1388                         rc = EINVAL;
1389                         goto fail4;
1390                 }
1391         }
1392
1393         if (board_typep != NULL) {
1394                 *board_typep = MCDI_OUT_DWORD(req,
1395                     GET_BOARD_CFG_OUT_BOARD_TYPE);
1396         }
1397
1398         return (0);
1399
1400 fail4:
1401         EFSYS_PROBE(fail4);
1402 fail3:
1403         EFSYS_PROBE(fail3);
1404 fail2:
1405         EFSYS_PROBE(fail2);
1406 fail1:
1407         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1408
1409         return (rc);
1410 }
1411
1412         __checkReturn   efx_rc_t
1413 efx_mcdi_get_resource_limits(
1414         __in            efx_nic_t *enp,
1415         __out_opt       uint32_t *nevqp,
1416         __out_opt       uint32_t *nrxqp,
1417         __out_opt       uint32_t *ntxqp)
1418 {
1419         efx_mcdi_req_t req;
1420         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_RESOURCE_LIMITS_IN_LEN,
1421                 MC_CMD_GET_RESOURCE_LIMITS_OUT_LEN);
1422         efx_rc_t rc;
1423
1424         req.emr_cmd = MC_CMD_GET_RESOURCE_LIMITS;
1425         req.emr_in_buf = payload;
1426         req.emr_in_length = MC_CMD_GET_RESOURCE_LIMITS_IN_LEN;
1427         req.emr_out_buf = payload;
1428         req.emr_out_length = MC_CMD_GET_RESOURCE_LIMITS_OUT_LEN;
1429
1430         efx_mcdi_execute(enp, &req);
1431
1432         if (req.emr_rc != 0) {
1433                 rc = req.emr_rc;
1434                 goto fail1;
1435         }
1436
1437         if (req.emr_out_length_used < MC_CMD_GET_RESOURCE_LIMITS_OUT_LEN) {
1438                 rc = EMSGSIZE;
1439                 goto fail2;
1440         }
1441
1442         if (nevqp != NULL)
1443                 *nevqp = MCDI_OUT_DWORD(req, GET_RESOURCE_LIMITS_OUT_EVQ);
1444         if (nrxqp != NULL)
1445                 *nrxqp = MCDI_OUT_DWORD(req, GET_RESOURCE_LIMITS_OUT_RXQ);
1446         if (ntxqp != NULL)
1447                 *ntxqp = MCDI_OUT_DWORD(req, GET_RESOURCE_LIMITS_OUT_TXQ);
1448
1449         return (0);
1450
1451 fail2:
1452         EFSYS_PROBE(fail2);
1453 fail1:
1454         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1455
1456         return (rc);
1457 }
1458
1459         __checkReturn   efx_rc_t
1460 efx_mcdi_get_phy_cfg(
1461         __in            efx_nic_t *enp)
1462 {
1463         efx_port_t *epp = &(enp->en_port);
1464         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1465         efx_mcdi_req_t req;
1466         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_PHY_CFG_IN_LEN,
1467                 MC_CMD_GET_PHY_CFG_OUT_LEN);
1468 #if EFSYS_OPT_NAMES
1469         const char *namep;
1470         size_t namelen;
1471 #endif
1472         uint32_t phy_media_type;
1473         efx_rc_t rc;
1474
1475         req.emr_cmd = MC_CMD_GET_PHY_CFG;
1476         req.emr_in_buf = payload;
1477         req.emr_in_length = MC_CMD_GET_PHY_CFG_IN_LEN;
1478         req.emr_out_buf = payload;
1479         req.emr_out_length = MC_CMD_GET_PHY_CFG_OUT_LEN;
1480
1481         efx_mcdi_execute(enp, &req);
1482
1483         if (req.emr_rc != 0) {
1484                 rc = req.emr_rc;
1485                 goto fail1;
1486         }
1487
1488         if (req.emr_out_length_used < MC_CMD_GET_PHY_CFG_OUT_LEN) {
1489                 rc = EMSGSIZE;
1490                 goto fail2;
1491         }
1492
1493         encp->enc_phy_type = MCDI_OUT_DWORD(req, GET_PHY_CFG_OUT_TYPE);
1494 #if EFSYS_OPT_NAMES
1495         namep = MCDI_OUT2(req, char, GET_PHY_CFG_OUT_NAME);
1496         namelen = MIN(sizeof (encp->enc_phy_name) - 1,
1497                     strnlen(namep, MC_CMD_GET_PHY_CFG_OUT_NAME_LEN));
1498         (void) memset(encp->enc_phy_name, 0,
1499             sizeof (encp->enc_phy_name));
1500         memcpy(encp->enc_phy_name, namep, namelen);
1501 #endif  /* EFSYS_OPT_NAMES */
1502         (void) memset(encp->enc_phy_revision, 0,
1503             sizeof (encp->enc_phy_revision));
1504         memcpy(encp->enc_phy_revision,
1505                 MCDI_OUT2(req, char, GET_PHY_CFG_OUT_REVISION),
1506                 MIN(sizeof (encp->enc_phy_revision) - 1,
1507                     MC_CMD_GET_PHY_CFG_OUT_REVISION_LEN));
1508 #if EFSYS_OPT_PHY_LED_CONTROL
1509         encp->enc_led_mask = ((1 << EFX_PHY_LED_DEFAULT) |
1510                             (1 << EFX_PHY_LED_OFF) |
1511                             (1 << EFX_PHY_LED_ON));
1512 #endif  /* EFSYS_OPT_PHY_LED_CONTROL */
1513
1514         /* Get the media type of the fixed port, if recognised. */
1515         EFX_STATIC_ASSERT(MC_CMD_MEDIA_XAUI == EFX_PHY_MEDIA_XAUI);
1516         EFX_STATIC_ASSERT(MC_CMD_MEDIA_CX4 == EFX_PHY_MEDIA_CX4);
1517         EFX_STATIC_ASSERT(MC_CMD_MEDIA_KX4 == EFX_PHY_MEDIA_KX4);
1518         EFX_STATIC_ASSERT(MC_CMD_MEDIA_XFP == EFX_PHY_MEDIA_XFP);
1519         EFX_STATIC_ASSERT(MC_CMD_MEDIA_SFP_PLUS == EFX_PHY_MEDIA_SFP_PLUS);
1520         EFX_STATIC_ASSERT(MC_CMD_MEDIA_BASE_T == EFX_PHY_MEDIA_BASE_T);
1521         EFX_STATIC_ASSERT(MC_CMD_MEDIA_QSFP_PLUS == EFX_PHY_MEDIA_QSFP_PLUS);
1522         phy_media_type = MCDI_OUT_DWORD(req, GET_PHY_CFG_OUT_MEDIA_TYPE);
1523         epp->ep_fixed_port_type = (efx_phy_media_type_t)phy_media_type;
1524         if (epp->ep_fixed_port_type >= EFX_PHY_MEDIA_NTYPES)
1525                 epp->ep_fixed_port_type = EFX_PHY_MEDIA_INVALID;
1526
1527         epp->ep_phy_cap_mask =
1528                 MCDI_OUT_DWORD(req, GET_PHY_CFG_OUT_SUPPORTED_CAP);
1529 #if EFSYS_OPT_PHY_FLAGS
1530         encp->enc_phy_flags_mask = MCDI_OUT_DWORD(req, GET_PHY_CFG_OUT_FLAGS);
1531 #endif  /* EFSYS_OPT_PHY_FLAGS */
1532
1533         encp->enc_port = (uint8_t)MCDI_OUT_DWORD(req, GET_PHY_CFG_OUT_PRT);
1534
1535         /* Populate internal state */
1536         encp->enc_mcdi_mdio_channel =
1537                 (uint8_t)MCDI_OUT_DWORD(req, GET_PHY_CFG_OUT_CHANNEL);
1538
1539 #if EFSYS_OPT_PHY_STATS
1540         encp->enc_mcdi_phy_stat_mask =
1541                 MCDI_OUT_DWORD(req, GET_PHY_CFG_OUT_STATS_MASK);
1542 #endif  /* EFSYS_OPT_PHY_STATS */
1543
1544 #if EFSYS_OPT_BIST
1545         encp->enc_bist_mask = 0;
1546         if (MCDI_OUT_DWORD_FIELD(req, GET_PHY_CFG_OUT_FLAGS,
1547             GET_PHY_CFG_OUT_BIST_CABLE_SHORT))
1548                 encp->enc_bist_mask |= (1 << EFX_BIST_TYPE_PHY_CABLE_SHORT);
1549         if (MCDI_OUT_DWORD_FIELD(req, GET_PHY_CFG_OUT_FLAGS,
1550             GET_PHY_CFG_OUT_BIST_CABLE_LONG))
1551                 encp->enc_bist_mask |= (1 << EFX_BIST_TYPE_PHY_CABLE_LONG);
1552         if (MCDI_OUT_DWORD_FIELD(req, GET_PHY_CFG_OUT_FLAGS,
1553             GET_PHY_CFG_OUT_BIST))
1554                 encp->enc_bist_mask |= (1 << EFX_BIST_TYPE_PHY_NORMAL);
1555 #endif  /* EFSYS_OPT_BIST */
1556
1557         return (0);
1558
1559 fail2:
1560         EFSYS_PROBE(fail2);
1561 fail1:
1562         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1563
1564         return (rc);
1565 }
1566
1567         __checkReturn           efx_rc_t
1568 efx_mcdi_firmware_update_supported(
1569         __in                    efx_nic_t *enp,
1570         __out                   boolean_t *supportedp)
1571 {
1572         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
1573         efx_rc_t rc;
1574
1575         if (emcop != NULL) {
1576                 if ((rc = emcop->emco_feature_supported(enp,
1577                             EFX_MCDI_FEATURE_FW_UPDATE, supportedp)) != 0)
1578                         goto fail1;
1579         } else {
1580                 /* Earlier devices always supported updates */
1581                 *supportedp = B_TRUE;
1582         }
1583
1584         return (0);
1585
1586 fail1:
1587         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1588
1589         return (rc);
1590 }
1591
1592         __checkReturn           efx_rc_t
1593 efx_mcdi_macaddr_change_supported(
1594         __in                    efx_nic_t *enp,
1595         __out                   boolean_t *supportedp)
1596 {
1597         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
1598         efx_rc_t rc;
1599
1600         if (emcop != NULL) {
1601                 if ((rc = emcop->emco_feature_supported(enp,
1602                             EFX_MCDI_FEATURE_MACADDR_CHANGE, supportedp)) != 0)
1603                         goto fail1;
1604         } else {
1605                 /* Earlier devices always supported MAC changes */
1606                 *supportedp = B_TRUE;
1607         }
1608
1609         return (0);
1610
1611 fail1:
1612         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1613
1614         return (rc);
1615 }
1616
1617         __checkReturn           efx_rc_t
1618 efx_mcdi_link_control_supported(
1619         __in                    efx_nic_t *enp,
1620         __out                   boolean_t *supportedp)
1621 {
1622         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
1623         efx_rc_t rc;
1624
1625         if (emcop != NULL) {
1626                 if ((rc = emcop->emco_feature_supported(enp,
1627                             EFX_MCDI_FEATURE_LINK_CONTROL, supportedp)) != 0)
1628                         goto fail1;
1629         } else {
1630                 /* Earlier devices always supported link control */
1631                 *supportedp = B_TRUE;
1632         }
1633
1634         return (0);
1635
1636 fail1:
1637         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1638
1639         return (rc);
1640 }
1641
1642         __checkReturn           efx_rc_t
1643 efx_mcdi_mac_spoofing_supported(
1644         __in                    efx_nic_t *enp,
1645         __out                   boolean_t *supportedp)
1646 {
1647         const efx_mcdi_ops_t *emcop = enp->en_mcdi.em_emcop;
1648         efx_rc_t rc;
1649
1650         if (emcop != NULL) {
1651                 if ((rc = emcop->emco_feature_supported(enp,
1652                             EFX_MCDI_FEATURE_MAC_SPOOFING, supportedp)) != 0)
1653                         goto fail1;
1654         } else {
1655                 /* Earlier devices always supported MAC spoofing */
1656                 *supportedp = B_TRUE;
1657         }
1658
1659         return (0);
1660
1661 fail1:
1662         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1663
1664         return (rc);
1665 }
1666
1667 #if EFSYS_OPT_BIST
1668
1669 #if EFX_OPTS_EF10()
1670 /*
1671  * Enter bist offline mode. This is a fw mode which puts the NIC into a state
1672  * where memory BIST tests can be run and not much else can interfere or happen.
1673  * A reboot is required to exit this mode.
1674  */
1675         __checkReturn           efx_rc_t
1676 efx_mcdi_bist_enable_offline(
1677         __in                    efx_nic_t *enp)
1678 {
1679         efx_mcdi_req_t req;
1680         efx_rc_t rc;
1681
1682         EFX_STATIC_ASSERT(MC_CMD_ENABLE_OFFLINE_BIST_IN_LEN == 0);
1683         EFX_STATIC_ASSERT(MC_CMD_ENABLE_OFFLINE_BIST_OUT_LEN == 0);
1684
1685         req.emr_cmd = MC_CMD_ENABLE_OFFLINE_BIST;
1686         req.emr_in_buf = NULL;
1687         req.emr_in_length = 0;
1688         req.emr_out_buf = NULL;
1689         req.emr_out_length = 0;
1690
1691         efx_mcdi_execute(enp, &req);
1692
1693         if (req.emr_rc != 0) {
1694                 rc = req.emr_rc;
1695                 goto fail1;
1696         }
1697
1698         return (0);
1699
1700 fail1:
1701         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1702
1703         return (rc);
1704 }
1705 #endif /* EFX_OPTS_EF10() */
1706
1707         __checkReturn           efx_rc_t
1708 efx_mcdi_bist_start(
1709         __in                    efx_nic_t *enp,
1710         __in                    efx_bist_type_t type)
1711 {
1712         efx_mcdi_req_t req;
1713         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_START_BIST_IN_LEN,
1714                 MC_CMD_START_BIST_OUT_LEN);
1715         efx_rc_t rc;
1716
1717         req.emr_cmd = MC_CMD_START_BIST;
1718         req.emr_in_buf = payload;
1719         req.emr_in_length = MC_CMD_START_BIST_IN_LEN;
1720         req.emr_out_buf = payload;
1721         req.emr_out_length = MC_CMD_START_BIST_OUT_LEN;
1722
1723         switch (type) {
1724         case EFX_BIST_TYPE_PHY_NORMAL:
1725                 MCDI_IN_SET_DWORD(req, START_BIST_IN_TYPE, MC_CMD_PHY_BIST);
1726                 break;
1727         case EFX_BIST_TYPE_PHY_CABLE_SHORT:
1728                 MCDI_IN_SET_DWORD(req, START_BIST_IN_TYPE,
1729                     MC_CMD_PHY_BIST_CABLE_SHORT);
1730                 break;
1731         case EFX_BIST_TYPE_PHY_CABLE_LONG:
1732                 MCDI_IN_SET_DWORD(req, START_BIST_IN_TYPE,
1733                     MC_CMD_PHY_BIST_CABLE_LONG);
1734                 break;
1735         case EFX_BIST_TYPE_MC_MEM:
1736                 MCDI_IN_SET_DWORD(req, START_BIST_IN_TYPE,
1737                     MC_CMD_MC_MEM_BIST);
1738                 break;
1739         case EFX_BIST_TYPE_SAT_MEM:
1740                 MCDI_IN_SET_DWORD(req, START_BIST_IN_TYPE,
1741                     MC_CMD_PORT_MEM_BIST);
1742                 break;
1743         case EFX_BIST_TYPE_REG:
1744                 MCDI_IN_SET_DWORD(req, START_BIST_IN_TYPE,
1745                     MC_CMD_REG_BIST);
1746                 break;
1747         default:
1748                 EFSYS_ASSERT(0);
1749         }
1750
1751         efx_mcdi_execute(enp, &req);
1752
1753         if (req.emr_rc != 0) {
1754                 rc = req.emr_rc;
1755                 goto fail1;
1756         }
1757
1758         return (0);
1759
1760 fail1:
1761         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1762
1763         return (rc);
1764 }
1765
1766 #endif /* EFSYS_OPT_BIST */
1767
1768
1769 /* Enable logging of some events (e.g. link state changes) */
1770         __checkReturn   efx_rc_t
1771 efx_mcdi_log_ctrl(
1772         __in            efx_nic_t *enp)
1773 {
1774         efx_mcdi_req_t req;
1775         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_LOG_CTRL_IN_LEN,
1776                 MC_CMD_LOG_CTRL_OUT_LEN);
1777         efx_rc_t rc;
1778
1779         req.emr_cmd = MC_CMD_LOG_CTRL;
1780         req.emr_in_buf = payload;
1781         req.emr_in_length = MC_CMD_LOG_CTRL_IN_LEN;
1782         req.emr_out_buf = payload;
1783         req.emr_out_length = MC_CMD_LOG_CTRL_OUT_LEN;
1784
1785         MCDI_IN_SET_DWORD(req, LOG_CTRL_IN_LOG_DEST,
1786                     MC_CMD_LOG_CTRL_IN_LOG_DEST_EVQ);
1787         MCDI_IN_SET_DWORD(req, LOG_CTRL_IN_LOG_DEST_EVQ, 0);
1788
1789         efx_mcdi_execute(enp, &req);
1790
1791         if (req.emr_rc != 0) {
1792                 rc = req.emr_rc;
1793                 goto fail1;
1794         }
1795
1796         return (0);
1797
1798 fail1:
1799         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1800
1801         return (rc);
1802 }
1803
1804
1805 #if EFSYS_OPT_MAC_STATS
1806
1807 typedef enum efx_stats_action_e {
1808         EFX_STATS_CLEAR,
1809         EFX_STATS_UPLOAD,
1810         EFX_STATS_ENABLE_NOEVENTS,
1811         EFX_STATS_ENABLE_EVENTS,
1812         EFX_STATS_DISABLE,
1813 } efx_stats_action_t;
1814
1815 static  __checkReturn   efx_rc_t
1816 efx_mcdi_mac_stats(
1817         __in            efx_nic_t *enp,
1818         __in_opt        efsys_mem_t *esmp,
1819         __in            efx_stats_action_t action,
1820         __in            uint16_t period_ms)
1821 {
1822         efx_mcdi_req_t req;
1823         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_MAC_STATS_IN_LEN,
1824                 MC_CMD_MAC_STATS_V2_OUT_DMA_LEN);
1825         int clear = (action == EFX_STATS_CLEAR);
1826         int upload = (action == EFX_STATS_UPLOAD);
1827         int enable = (action == EFX_STATS_ENABLE_NOEVENTS);
1828         int events = (action == EFX_STATS_ENABLE_EVENTS);
1829         int disable = (action == EFX_STATS_DISABLE);
1830         efx_rc_t rc;
1831
1832         req.emr_cmd = MC_CMD_MAC_STATS;
1833         req.emr_in_buf = payload;
1834         req.emr_in_length = MC_CMD_MAC_STATS_IN_LEN;
1835         req.emr_out_buf = payload;
1836         req.emr_out_length = MC_CMD_MAC_STATS_V2_OUT_DMA_LEN;
1837
1838         MCDI_IN_POPULATE_DWORD_6(req, MAC_STATS_IN_CMD,
1839             MAC_STATS_IN_DMA, upload,
1840             MAC_STATS_IN_CLEAR, clear,
1841             MAC_STATS_IN_PERIODIC_CHANGE, enable | events | disable,
1842             MAC_STATS_IN_PERIODIC_ENABLE, enable | events,
1843             MAC_STATS_IN_PERIODIC_NOEVENT, !events,
1844             MAC_STATS_IN_PERIOD_MS, (enable | events) ? period_ms : 0);
1845
1846         if (enable || events || upload) {
1847                 const efx_nic_cfg_t *encp = &enp->en_nic_cfg;
1848                 uint32_t bytes;
1849
1850                 /* Periodic stats or stats upload require a DMA buffer */
1851                 if (esmp == NULL) {
1852                         rc = EINVAL;
1853                         goto fail1;
1854                 }
1855
1856                 if (encp->enc_mac_stats_nstats < MC_CMD_MAC_NSTATS) {
1857                         /* MAC stats count too small for legacy MAC stats */
1858                         rc = ENOSPC;
1859                         goto fail2;
1860                 }
1861
1862                 bytes = encp->enc_mac_stats_nstats * sizeof (efx_qword_t);
1863
1864                 if (EFSYS_MEM_SIZE(esmp) < bytes) {
1865                         /* DMA buffer too small */
1866                         rc = ENOSPC;
1867                         goto fail3;
1868                 }
1869
1870                 MCDI_IN_SET_DWORD(req, MAC_STATS_IN_DMA_ADDR_LO,
1871                             EFSYS_MEM_ADDR(esmp) & 0xffffffff);
1872                 MCDI_IN_SET_DWORD(req, MAC_STATS_IN_DMA_ADDR_HI,
1873                             EFSYS_MEM_ADDR(esmp) >> 32);
1874                 MCDI_IN_SET_DWORD(req, MAC_STATS_IN_DMA_LEN, bytes);
1875         }
1876
1877         /*
1878          * NOTE: Do not use EVB_PORT_ID_ASSIGNED when disabling periodic stats,
1879          *       as this may fail (and leave periodic DMA enabled) if the
1880          *       vadapter has already been deleted.
1881          */
1882         MCDI_IN_SET_DWORD(req, MAC_STATS_IN_PORT_ID,
1883             (disable ? EVB_PORT_ID_NULL : enp->en_vport_id));
1884
1885         efx_mcdi_execute(enp, &req);
1886
1887         if (req.emr_rc != 0) {
1888                 /* EF10: Expect ENOENT if no DMA queues are initialised */
1889                 if ((req.emr_rc != ENOENT) ||
1890                     (enp->en_rx_qcount + enp->en_tx_qcount != 0)) {
1891                         rc = req.emr_rc;
1892                         goto fail4;
1893                 }
1894         }
1895
1896         return (0);
1897
1898 fail4:
1899         EFSYS_PROBE(fail4);
1900 fail3:
1901         EFSYS_PROBE(fail3);
1902 fail2:
1903         EFSYS_PROBE(fail2);
1904 fail1:
1905         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1906
1907         return (rc);
1908 }
1909
1910         __checkReturn   efx_rc_t
1911 efx_mcdi_mac_stats_clear(
1912         __in            efx_nic_t *enp)
1913 {
1914         efx_rc_t rc;
1915
1916         if ((rc = efx_mcdi_mac_stats(enp, NULL, EFX_STATS_CLEAR, 0)) != 0)
1917                 goto fail1;
1918
1919         return (0);
1920
1921 fail1:
1922         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1923
1924         return (rc);
1925 }
1926
1927         __checkReturn   efx_rc_t
1928 efx_mcdi_mac_stats_upload(
1929         __in            efx_nic_t *enp,
1930         __in            efsys_mem_t *esmp)
1931 {
1932         efx_rc_t rc;
1933
1934         /*
1935          * The MC DMAs aggregate statistics for our convenience, so we can
1936          * avoid having to pull the statistics buffer into the cache to
1937          * maintain cumulative statistics.
1938          */
1939         if ((rc = efx_mcdi_mac_stats(enp, esmp, EFX_STATS_UPLOAD, 0)) != 0)
1940                 goto fail1;
1941
1942         return (0);
1943
1944 fail1:
1945         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1946
1947         return (rc);
1948 }
1949
1950         __checkReturn   efx_rc_t
1951 efx_mcdi_mac_stats_periodic(
1952         __in            efx_nic_t *enp,
1953         __in            efsys_mem_t *esmp,
1954         __in            uint16_t period_ms,
1955         __in            boolean_t events)
1956 {
1957         efx_rc_t rc;
1958
1959         /*
1960          * The MC DMAs aggregate statistics for our convenience, so we can
1961          * avoid having to pull the statistics buffer into the cache to
1962          * maintain cumulative statistics.
1963          * Huntington uses a fixed 1sec period.
1964          * Medford uses a fixed 1sec period before v6.2.1.1033 firmware.
1965          */
1966         if (period_ms == 0)
1967                 rc = efx_mcdi_mac_stats(enp, NULL, EFX_STATS_DISABLE, 0);
1968         else if (events)
1969                 rc = efx_mcdi_mac_stats(enp, esmp, EFX_STATS_ENABLE_EVENTS,
1970                     period_ms);
1971         else
1972                 rc = efx_mcdi_mac_stats(enp, esmp, EFX_STATS_ENABLE_NOEVENTS,
1973                     period_ms);
1974
1975         if (rc != 0)
1976                 goto fail1;
1977
1978         return (0);
1979
1980 fail1:
1981         EFSYS_PROBE1(fail1, efx_rc_t, rc);
1982
1983         return (rc);
1984 }
1985
1986 #endif  /* EFSYS_OPT_MAC_STATS */
1987
1988 #if EFX_OPTS_EF10()
1989
1990 /*
1991  * This function returns the pf and vf number of a function.  If it is a pf the
1992  * vf number is 0xffff.  The vf number is the index of the vf on that
1993  * function. So if you have 3 vfs on pf 0 the 3 vfs will return (pf=0,vf=0),
1994  * (pf=0,vf=1), (pf=0,vf=2) aand the pf will return (pf=0, vf=0xffff).
1995  */
1996         __checkReturn           efx_rc_t
1997 efx_mcdi_get_function_info(
1998         __in                    efx_nic_t *enp,
1999         __out                   uint32_t *pfp,
2000         __out_opt               uint32_t *vfp)
2001 {
2002         efx_mcdi_req_t req;
2003         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_FUNCTION_INFO_IN_LEN,
2004                 MC_CMD_GET_FUNCTION_INFO_OUT_LEN);
2005         efx_rc_t rc;
2006
2007         req.emr_cmd = MC_CMD_GET_FUNCTION_INFO;
2008         req.emr_in_buf = payload;
2009         req.emr_in_length = MC_CMD_GET_FUNCTION_INFO_IN_LEN;
2010         req.emr_out_buf = payload;
2011         req.emr_out_length = MC_CMD_GET_FUNCTION_INFO_OUT_LEN;
2012
2013         efx_mcdi_execute(enp, &req);
2014
2015         if (req.emr_rc != 0) {
2016                 rc = req.emr_rc;
2017                 goto fail1;
2018         }
2019
2020         if (req.emr_out_length_used < MC_CMD_GET_FUNCTION_INFO_OUT_LEN) {
2021                 rc = EMSGSIZE;
2022                 goto fail2;
2023         }
2024
2025         *pfp = MCDI_OUT_DWORD(req, GET_FUNCTION_INFO_OUT_PF);
2026         if (vfp != NULL)
2027                 *vfp = MCDI_OUT_DWORD(req, GET_FUNCTION_INFO_OUT_VF);
2028
2029         return (0);
2030
2031 fail2:
2032         EFSYS_PROBE(fail2);
2033 fail1:
2034         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2035
2036         return (rc);
2037 }
2038
2039         __checkReturn           efx_rc_t
2040 efx_mcdi_privilege_mask(
2041         __in                    efx_nic_t *enp,
2042         __in                    uint32_t pf,
2043         __in                    uint32_t vf,
2044         __out                   uint32_t *maskp)
2045 {
2046         efx_mcdi_req_t req;
2047         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_PRIVILEGE_MASK_IN_LEN,
2048                 MC_CMD_PRIVILEGE_MASK_OUT_LEN);
2049         efx_rc_t rc;
2050
2051         req.emr_cmd = MC_CMD_PRIVILEGE_MASK;
2052         req.emr_in_buf = payload;
2053         req.emr_in_length = MC_CMD_PRIVILEGE_MASK_IN_LEN;
2054         req.emr_out_buf = payload;
2055         req.emr_out_length = MC_CMD_PRIVILEGE_MASK_OUT_LEN;
2056
2057         MCDI_IN_POPULATE_DWORD_2(req, PRIVILEGE_MASK_IN_FUNCTION,
2058             PRIVILEGE_MASK_IN_FUNCTION_PF, pf,
2059             PRIVILEGE_MASK_IN_FUNCTION_VF, vf);
2060
2061         efx_mcdi_execute(enp, &req);
2062
2063         if (req.emr_rc != 0) {
2064                 rc = req.emr_rc;
2065                 goto fail1;
2066         }
2067
2068         if (req.emr_out_length_used < MC_CMD_PRIVILEGE_MASK_OUT_LEN) {
2069                 rc = EMSGSIZE;
2070                 goto fail2;
2071         }
2072
2073         *maskp = MCDI_OUT_DWORD(req, PRIVILEGE_MASK_OUT_OLD_MASK);
2074
2075         return (0);
2076
2077 fail2:
2078         EFSYS_PROBE(fail2);
2079 fail1:
2080         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2081
2082         return (rc);
2083 }
2084
2085 #endif /* EFX_OPTS_EF10() */
2086
2087         __checkReturn           efx_rc_t
2088 efx_mcdi_set_workaround(
2089         __in                    efx_nic_t *enp,
2090         __in                    uint32_t type,
2091         __in                    boolean_t enabled,
2092         __out_opt               uint32_t *flagsp)
2093 {
2094         efx_mcdi_req_t req;
2095         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_WORKAROUND_IN_LEN,
2096                 MC_CMD_WORKAROUND_EXT_OUT_LEN);
2097         efx_rc_t rc;
2098
2099         req.emr_cmd = MC_CMD_WORKAROUND;
2100         req.emr_in_buf = payload;
2101         req.emr_in_length = MC_CMD_WORKAROUND_IN_LEN;
2102         req.emr_out_buf = payload;
2103         req.emr_out_length = MC_CMD_WORKAROUND_OUT_LEN;
2104
2105         MCDI_IN_SET_DWORD(req, WORKAROUND_IN_TYPE, type);
2106         MCDI_IN_SET_DWORD(req, WORKAROUND_IN_ENABLED, enabled ? 1 : 0);
2107
2108         efx_mcdi_execute_quiet(enp, &req);
2109
2110         if (req.emr_rc != 0) {
2111                 rc = req.emr_rc;
2112                 goto fail1;
2113         }
2114
2115         if (flagsp != NULL) {
2116                 if (req.emr_out_length_used >= MC_CMD_WORKAROUND_EXT_OUT_LEN)
2117                         *flagsp = MCDI_OUT_DWORD(req, WORKAROUND_EXT_OUT_FLAGS);
2118                 else
2119                         *flagsp = 0;
2120         }
2121
2122         return (0);
2123
2124 fail1:
2125         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2126
2127         return (rc);
2128 }
2129
2130
2131         __checkReturn           efx_rc_t
2132 efx_mcdi_get_workarounds(
2133         __in                    efx_nic_t *enp,
2134         __out_opt               uint32_t *implementedp,
2135         __out_opt               uint32_t *enabledp)
2136 {
2137         efx_mcdi_req_t req;
2138         EFX_MCDI_DECLARE_BUF(payload, 0, MC_CMD_GET_WORKAROUNDS_OUT_LEN);
2139         efx_rc_t rc;
2140
2141         req.emr_cmd = MC_CMD_GET_WORKAROUNDS;
2142         req.emr_in_buf = NULL;
2143         req.emr_in_length = 0;
2144         req.emr_out_buf = payload;
2145         req.emr_out_length = MC_CMD_GET_WORKAROUNDS_OUT_LEN;
2146
2147         efx_mcdi_execute(enp, &req);
2148
2149         if (req.emr_rc != 0) {
2150                 rc = req.emr_rc;
2151                 goto fail1;
2152         }
2153
2154         if (implementedp != NULL) {
2155                 *implementedp =
2156                     MCDI_OUT_DWORD(req, GET_WORKAROUNDS_OUT_IMPLEMENTED);
2157         }
2158
2159         if (enabledp != NULL) {
2160                 *enabledp = MCDI_OUT_DWORD(req, GET_WORKAROUNDS_OUT_ENABLED);
2161         }
2162
2163         return (0);
2164
2165 fail1:
2166         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2167
2168         return (rc);
2169 }
2170
2171 /*
2172  * Size of media information page in accordance with SFF-8472 and SFF-8436.
2173  * It is used in MCDI interface as well.
2174  */
2175 #define EFX_PHY_MEDIA_INFO_PAGE_SIZE            0x80
2176
2177 /*
2178  * Transceiver identifiers from SFF-8024 Table 4-1.
2179  */
2180 #define EFX_SFF_TRANSCEIVER_ID_SFP              0x03 /* SFP/SFP+/SFP28 */
2181 #define EFX_SFF_TRANSCEIVER_ID_QSFP             0x0c /* QSFP */
2182 #define EFX_SFF_TRANSCEIVER_ID_QSFP_PLUS        0x0d /* QSFP+ or later */
2183 #define EFX_SFF_TRANSCEIVER_ID_QSFP28           0x11 /* QSFP28 or later */
2184
2185 static  __checkReturn           efx_rc_t
2186 efx_mcdi_get_phy_media_info(
2187         __in                    efx_nic_t *enp,
2188         __in                    uint32_t mcdi_page,
2189         __in                    uint8_t offset,
2190         __in                    uint8_t len,
2191         __out_bcount(len)       uint8_t *data)
2192 {
2193         efx_mcdi_req_t req;
2194         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_PHY_MEDIA_INFO_IN_LEN,
2195                 MC_CMD_GET_PHY_MEDIA_INFO_OUT_LEN(
2196                         EFX_PHY_MEDIA_INFO_PAGE_SIZE));
2197         efx_rc_t rc;
2198
2199         EFSYS_ASSERT((uint32_t)offset + len <= EFX_PHY_MEDIA_INFO_PAGE_SIZE);
2200
2201         req.emr_cmd = MC_CMD_GET_PHY_MEDIA_INFO;
2202         req.emr_in_buf = payload;
2203         req.emr_in_length = MC_CMD_GET_PHY_MEDIA_INFO_IN_LEN;
2204         req.emr_out_buf = payload;
2205         req.emr_out_length =
2206             MC_CMD_GET_PHY_MEDIA_INFO_OUT_LEN(EFX_PHY_MEDIA_INFO_PAGE_SIZE);
2207
2208         MCDI_IN_SET_DWORD(req, GET_PHY_MEDIA_INFO_IN_PAGE, mcdi_page);
2209
2210         efx_mcdi_execute(enp, &req);
2211
2212         if (req.emr_rc != 0) {
2213                 rc = req.emr_rc;
2214                 goto fail1;
2215         }
2216
2217         if (req.emr_out_length_used !=
2218             MC_CMD_GET_PHY_MEDIA_INFO_OUT_LEN(EFX_PHY_MEDIA_INFO_PAGE_SIZE)) {
2219                 rc = EMSGSIZE;
2220                 goto fail2;
2221         }
2222
2223         if (MCDI_OUT_DWORD(req, GET_PHY_MEDIA_INFO_OUT_DATALEN) !=
2224             EFX_PHY_MEDIA_INFO_PAGE_SIZE) {
2225                 rc = EIO;
2226                 goto fail3;
2227         }
2228
2229         memcpy(data,
2230             MCDI_OUT2(req, uint8_t, GET_PHY_MEDIA_INFO_OUT_DATA) + offset,
2231             len);
2232
2233         return (0);
2234
2235 fail3:
2236         EFSYS_PROBE(fail3);
2237 fail2:
2238         EFSYS_PROBE(fail2);
2239 fail1:
2240         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2241
2242         return (rc);
2243 }
2244
2245         __checkReturn           efx_rc_t
2246 efx_mcdi_phy_module_get_info(
2247         __in                    efx_nic_t *enp,
2248         __in                    uint8_t dev_addr,
2249         __in                    size_t offset,
2250         __in                    size_t len,
2251         __out_bcount(len)       uint8_t *data)
2252 {
2253         efx_port_t *epp = &(enp->en_port);
2254         efx_rc_t rc;
2255         uint32_t mcdi_lower_page;
2256         uint32_t mcdi_upper_page;
2257         uint8_t id;
2258
2259         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
2260
2261         /*
2262          * Map device address to MC_CMD_GET_PHY_MEDIA_INFO pages.
2263          * Offset plus length interface allows to access page 0 only.
2264          * I.e. non-zero upper pages are not accessible.
2265          * See SFF-8472 section 4 Memory Organization and SFF-8436 section 7.6
2266          * QSFP+ Memory Map for details on how information is structured
2267          * and accessible.
2268          */
2269         switch (epp->ep_fixed_port_type) {
2270         case EFX_PHY_MEDIA_SFP_PLUS:
2271         case EFX_PHY_MEDIA_QSFP_PLUS:
2272                 /* Port type supports modules */
2273                 break;
2274         default:
2275                 rc = ENOTSUP;
2276                 goto fail1;
2277         }
2278
2279         /*
2280          * For all supported port types, MCDI page 0 offset 0 holds the
2281          * transceiver identifier. Probe to determine the data layout.
2282          * Definitions from SFF-8024 Table 4-1.
2283          */
2284         rc = efx_mcdi_get_phy_media_info(enp,
2285                     0, 0, sizeof(id), &id);
2286         if (rc != 0)
2287                 goto fail2;
2288
2289         switch (id) {
2290         case EFX_SFF_TRANSCEIVER_ID_SFP:
2291                 /*
2292                  * In accordance with SFF-8472 Diagnostic Monitoring
2293                  * Interface for Optical Transceivers section 4 Memory
2294                  * Organization two 2-wire addresses are defined.
2295                  */
2296                 switch (dev_addr) {
2297                 /* Base information */
2298                 case EFX_PHY_MEDIA_INFO_DEV_ADDR_SFP_BASE:
2299                         /*
2300                          * MCDI page 0 should be used to access lower
2301                          * page 0 (0x00 - 0x7f) at the device address 0xA0.
2302                          */
2303                         mcdi_lower_page = 0;
2304                         /*
2305                          * MCDI page 1 should be used to access  upper
2306                          * page 0 (0x80 - 0xff) at the device address 0xA0.
2307                          */
2308                         mcdi_upper_page = 1;
2309                         break;
2310                 /* Diagnostics */
2311                 case EFX_PHY_MEDIA_INFO_DEV_ADDR_SFP_DDM:
2312                         /*
2313                          * MCDI page 2 should be used to access lower
2314                          * page 0 (0x00 - 0x7f) at the device address 0xA2.
2315                          */
2316                         mcdi_lower_page = 2;
2317                         /*
2318                          * MCDI page 3 should be used to access upper
2319                          * page 0 (0x80 - 0xff) at the device address 0xA2.
2320                          */
2321                         mcdi_upper_page = 3;
2322                         break;
2323                 default:
2324                         rc = ENOTSUP;
2325                         goto fail3;
2326                 }
2327                 break;
2328         case EFX_SFF_TRANSCEIVER_ID_QSFP:
2329         case EFX_SFF_TRANSCEIVER_ID_QSFP_PLUS:
2330         case EFX_SFF_TRANSCEIVER_ID_QSFP28:
2331                 switch (dev_addr) {
2332                 case EFX_PHY_MEDIA_INFO_DEV_ADDR_QSFP:
2333                         /*
2334                          * MCDI page -1 should be used to access lower page 0
2335                          * (0x00 - 0x7f).
2336                          */
2337                         mcdi_lower_page = (uint32_t)-1;
2338                         /*
2339                          * MCDI page 0 should be used to access upper page 0
2340                          * (0x80h - 0xff).
2341                          */
2342                         mcdi_upper_page = 0;
2343                         break;
2344                 default:
2345                         rc = ENOTSUP;
2346                         goto fail3;
2347                 }
2348                 break;
2349         default:
2350                 rc = ENOTSUP;
2351                 goto fail3;
2352         }
2353
2354         EFX_STATIC_ASSERT(EFX_PHY_MEDIA_INFO_PAGE_SIZE <= 0xFF);
2355
2356         if (offset < EFX_PHY_MEDIA_INFO_PAGE_SIZE) {
2357                 size_t read_len =
2358                     MIN(len, EFX_PHY_MEDIA_INFO_PAGE_SIZE - offset);
2359
2360                 rc = efx_mcdi_get_phy_media_info(enp,
2361                     mcdi_lower_page, (uint8_t)offset, (uint8_t)read_len, data);
2362                 if (rc != 0)
2363                         goto fail4;
2364
2365                 data += read_len;
2366                 len -= read_len;
2367
2368                 offset = 0;
2369         } else {
2370                 offset -= EFX_PHY_MEDIA_INFO_PAGE_SIZE;
2371         }
2372
2373         if (len > 0) {
2374                 EFSYS_ASSERT3U(len, <=, EFX_PHY_MEDIA_INFO_PAGE_SIZE);
2375                 EFSYS_ASSERT3U(offset, <, EFX_PHY_MEDIA_INFO_PAGE_SIZE);
2376
2377                 rc = efx_mcdi_get_phy_media_info(enp,
2378                     mcdi_upper_page, (uint8_t)offset, (uint8_t)len, data);
2379                 if (rc != 0)
2380                         goto fail5;
2381         }
2382
2383         return (0);
2384
2385 fail5:
2386         EFSYS_PROBE(fail5);
2387 fail4:
2388         EFSYS_PROBE(fail4);
2389 fail3:
2390         EFSYS_PROBE(fail3);
2391 fail2:
2392         EFSYS_PROBE(fail2);
2393 fail1:
2394         EFSYS_PROBE1(fail1, efx_rc_t, rc);
2395
2396         return (rc);
2397 }
2398
2399 #endif  /* EFSYS_OPT_MCDI */