sys/dev/sfxge/common/ef10_mcdi.c

   1 /*-
   2  * Copyright (c) 2012-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 <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include "efx.h"
  35 #include "efx_impl.h"
  36
  37
  38 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
  39
  40 #if EFSYS_OPT_MCDI
  41
  42 #ifndef WITH_MCDI_V2
  43 #error "WITH_MCDI_V2 required for EF10 MCDIv2 commands."
  44 #endif
  45
  46
  47         __checkReturn   efx_rc_t
  48 ef10_mcdi_init(
  49         __in            efx_nic_t *enp,
  50         __in            const efx_mcdi_transport_t *emtp)
  51 {
  52         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
  53         efsys_mem_t *esmp = emtp->emt_dma_mem;
  54         efx_dword_t dword;
  55         efx_rc_t rc;
  56
  57         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
  58             enp->en_family == EFX_FAMILY_MEDFORD ||
  59             enp->en_family == EFX_FAMILY_MEDFORD2);
  60         EFSYS_ASSERT(enp->en_features & EFX_FEATURE_MCDI_DMA);
  61
  62         /*
  63          * All EF10 firmware supports MCDIv2 and MCDIv1.
  64          * Medford BootROM supports MCDIv2 and MCDIv1.
  65          * Huntington BootROM supports MCDIv1 only.
  66          */
  67         emip->emi_max_version = 2;
  68
  69         /* A host DMA buffer is required for EF10 MCDI */
  70         if (esmp == NULL) {
  71                 rc = EINVAL;
  72                 goto fail1;
  73         }
  74
  75         /*
  76          * Ensure that the MC doorbell is in a known state before issuing MCDI
  77          * commands. The recovery algorithm requires that the MC command buffer
  78          * must be 256 byte aligned. See bug24769.
  79          */
  80         if ((EFSYS_MEM_ADDR(esmp) & 0xFF) != 0) {
  81                 rc = EINVAL;
  82                 goto fail2;
  83         }
  84         EFX_POPULATE_DWORD_1(dword, EFX_DWORD_0, 1);
  85         EFX_BAR_WRITED(enp, ER_DZ_MC_DB_HWRD_REG, &dword, B_FALSE);
  86
  87         /* Save initial MC reboot status */
  88         (void) ef10_mcdi_poll_reboot(enp);
  89
  90         /* Start a new epoch (allow fresh MCDI requests to succeed) */
  91         efx_mcdi_new_epoch(enp);
  92
  93         return (0);
  94
  95 fail2:
  96         EFSYS_PROBE(fail2);
  97 fail1:
  98         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  99
 100         return (rc);
 101 }
 102
 103                         void
 104 ef10_mcdi_fini(
 105         __in            efx_nic_t *enp)
 106 {
 107         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 108
 109         emip->emi_new_epoch = B_FALSE;
 110 }
 111
 112 /*
 113  * In older firmware all commands are processed in a single thread, so a long
 114  * running command for one PCIe function can block processing for another
 115  * function (see bug 61269).
 116  *
 117  * In newer firmware that supports multithreaded MCDI processing, we can extend
 118  * the timeout for long-running requests which we know firmware may choose to
 119  * process in a background thread.
 120  */
 121 #define EF10_MCDI_CMD_TIMEOUT_US        (10 * 1000 * 1000)
 122 #define EF10_MCDI_CMD_LONG_TIMEOUT_US   (60 * 1000 * 1000)
 123
 124                         void
 125 ef10_mcdi_get_timeout(
 126         __in            efx_nic_t *enp,
 127         __in            efx_mcdi_req_t *emrp,
 128         __out           uint32_t *timeoutp)
 129 {
 130         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 131
 132         switch (emrp->emr_cmd) {
 133         case MC_CMD_POLL_BIST:
 134         case MC_CMD_NVRAM_ERASE:
 135         case MC_CMD_LICENSING_V3:
 136         case MC_CMD_NVRAM_UPDATE_FINISH:
 137                 if (encp->enc_nvram_update_verify_result_supported != B_FALSE) {
 138                         /*
 139                          * Potentially longer running commands, which firmware
 140                          * may choose to process in a background thread.
 141                          */
 142                         *timeoutp = EF10_MCDI_CMD_LONG_TIMEOUT_US;
 143                         break;
 144                 }
 145                 /* FALLTHRU */
 146         default:
 147                 *timeoutp = EF10_MCDI_CMD_TIMEOUT_US;
 148                 break;
 149         }
 150 }
 151
 152                         void
 153 ef10_mcdi_send_request(
 154         __in                    efx_nic_t *enp,
 155         __in_bcount(hdr_len)    void *hdrp,
 156         __in                    size_t hdr_len,
 157         __in_bcount(sdu_len)    void *sdup,
 158         __in                    size_t sdu_len)
 159 {
 160         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 161         efsys_mem_t *esmp = emtp->emt_dma_mem;
 162         efx_dword_t dword;
 163         unsigned int pos;
 164
 165         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
 166             enp->en_family == EFX_FAMILY_MEDFORD ||
 167             enp->en_family == EFX_FAMILY_MEDFORD2);
 168
 169         /* Write the header */
 170         for (pos = 0; pos < hdr_len; pos += sizeof (efx_dword_t)) {
 171                 dword = *(efx_dword_t *)((uint8_t *)hdrp + pos);
 172                 EFSYS_MEM_WRITED(esmp, pos, &dword);
 173         }
 174
 175         /* Write the payload */
 176         for (pos = 0; pos < sdu_len; pos += sizeof (efx_dword_t)) {
 177                 dword = *(efx_dword_t *)((uint8_t *)sdup + pos);
 178                 EFSYS_MEM_WRITED(esmp, hdr_len + pos, &dword);
 179         }
 180
 181         /* Guarantee ordering of memory (MCDI request) and PIO (MC doorbell) */
 182         EFSYS_DMA_SYNC_FOR_DEVICE(esmp, 0, hdr_len + sdu_len);
 183         EFSYS_PIO_WRITE_BARRIER();
 184
 185         /* Ring the doorbell to post the command DMA address to the MC */
 186         EFX_POPULATE_DWORD_1(dword, EFX_DWORD_0,
 187             EFSYS_MEM_ADDR(esmp) >> 32);
 188         EFX_BAR_WRITED(enp, ER_DZ_MC_DB_LWRD_REG, &dword, B_FALSE);
 189
 190         EFX_POPULATE_DWORD_1(dword, EFX_DWORD_0,
 191             EFSYS_MEM_ADDR(esmp) & 0xffffffff);
 192         EFX_BAR_WRITED(enp, ER_DZ_MC_DB_HWRD_REG, &dword, B_FALSE);
 193 }
 194
 195         __checkReturn   boolean_t
 196 ef10_mcdi_poll_response(
 197         __in            efx_nic_t *enp)
 198 {
 199         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 200         efsys_mem_t *esmp = emtp->emt_dma_mem;
 201         efx_dword_t hdr;
 202
 203         EFSYS_MEM_READD(esmp, 0, &hdr);
 204         EFSYS_MEM_READ_BARRIER();
 205
 206         return (EFX_DWORD_FIELD(hdr, MCDI_HEADER_RESPONSE) ? B_TRUE : B_FALSE);
 207 }
 208
 209                         void
 210 ef10_mcdi_read_response(
 211         __in                    efx_nic_t *enp,
 212         __out_bcount(length)    void *bufferp,
 213         __in                    size_t offset,
 214         __in                    size_t length)
 215 {
 216         const efx_mcdi_transport_t *emtp = enp->en_mcdi.em_emtp;
 217         efsys_mem_t *esmp = emtp->emt_dma_mem;
 218         unsigned int pos = 0;
 219         efx_dword_t data;
 220         size_t remaining = length;
 221
 222         while (remaining > 0) {
 223                 size_t chunk = MIN(remaining, sizeof (data));
 224
 225                 EFSYS_MEM_READD(esmp, offset + pos, &data);
 226                 memcpy((uint8_t *)bufferp + pos, &data, chunk);
 227                 pos += chunk;
 228                 remaining -= chunk;
 229         }
 230 }
 231
 232                         efx_rc_t
 233 ef10_mcdi_poll_reboot(
 234         __in            efx_nic_t *enp)
 235 {
 236         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 237         efx_dword_t dword;
 238         uint32_t old_status;
 239         uint32_t new_status;
 240         efx_rc_t rc;
 241
 242         old_status = emip->emi_mc_reboot_status;
 243
 244         /* Update MC reboot status word */
 245         EFX_BAR_TBL_READD(enp, ER_DZ_BIU_MC_SFT_STATUS_REG, 0, &dword, B_FALSE);
 246         new_status = dword.ed_u32[0];
 247
 248         /* MC has rebooted if the value has changed */
 249         if (new_status != old_status) {
 250                 emip->emi_mc_reboot_status = new_status;
 251
 252                 /*
 253                  * FIXME: Ignore detected MC REBOOT for now.
 254                  *
 255                  * The Siena support for checking for MC reboot from status
 256                  * flags is broken - see comments in siena_mcdi_poll_reboot().
 257                  * As the generic MCDI code is shared the EF10 reboot
 258                  * detection suffers similar problems.
 259                  *
 260                  * Do not report an error when the boot status changes until
 261                  * this can be handled by common code drivers (and reworked to
 262                  * support Siena too).
 263                  */
 264                 _NOTE(CONSTANTCONDITION)
 265                 if (B_FALSE) {
 266                         rc = EIO;
 267                         goto fail1;
 268                 }
 269         }
 270
 271         return (0);
 272
 273 fail1:
 274         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 275
 276         return (rc);
 277 }
 278
 279         __checkReturn   efx_rc_t
 280 ef10_mcdi_feature_supported(
 281         __in            efx_nic_t *enp,
 282         __in            efx_mcdi_feature_id_t id,
 283         __out           boolean_t *supportedp)
 284 {
 285         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 286         uint32_t privilege_mask = encp->enc_privilege_mask;
 287         efx_rc_t rc;
 288
 289         EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
 290             enp->en_family == EFX_FAMILY_MEDFORD ||
 291             enp->en_family == EFX_FAMILY_MEDFORD2);
 292
 293         /*
 294          * Use privilege mask state at MCDI attach.
 295          */
 296
 297         switch (id) {
 298         case EFX_MCDI_FEATURE_FW_UPDATE:
 299                 /*
 300                  * Admin privilege must be used prior to introduction of
 301                  * specific flag.
 302                  */
 303                 *supportedp =
 304                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, ADMIN);
 305                 break;
 306         case EFX_MCDI_FEATURE_LINK_CONTROL:
 307                 /*
 308                  * Admin privilege used prior to introduction of
 309                  * specific flag.
 310                  */
 311                 *supportedp =
 312                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, LINK) ||
 313                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, ADMIN);
 314                 break;
 315         case EFX_MCDI_FEATURE_MACADDR_CHANGE:
 316                 /*
 317                  * Admin privilege must be used prior to introduction of
 318                  * mac spoofing privilege (at v4.6), which is used up to
 319                  * introduction of change mac spoofing privilege (at v4.7)
 320                  */
 321                 *supportedp =
 322                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, CHANGE_MAC) ||
 323                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, MAC_SPOOFING) ||
 324                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, ADMIN);
 325                 break;
 326         case EFX_MCDI_FEATURE_MAC_SPOOFING:
 327                 /*
 328                  * Admin privilege must be used prior to introduction of
 329                  * mac spoofing privilege (at v4.6), which is used up to
 330                  * introduction of mac spoofing TX privilege (at v4.7)
 331                  */
 332                 *supportedp =
 333                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, MAC_SPOOFING_TX) ||
 334                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, MAC_SPOOFING) ||
 335                     EFX_MCDI_HAVE_PRIVILEGE(privilege_mask, ADMIN);
 336                 break;
 337         default:
 338                 rc = ENOTSUP;
 339                 goto fail1;
 340         }
 341
 342         return (0);
 343
 344 fail1:
 345         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 346
 347         return (rc);
 348 }
 349
 350 #endif  /* EFSYS_OPT_MCDI */
 351
 352 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */