drivers/net/sfc/base/efx_mcdi.c

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