sys/dev/sfxge/sfxge_mcdi.c

   1 /*-
   2  * Copyright (c) 2010-2016 Solarflare Communications Inc.
   3  * All rights reserved.
   4  *
   5  * This software was developed in part by Philip Paeps under contract for
   6  * Solarflare Communications, Inc.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright notice,
  12  *    this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright notice,
  14  *    this list of conditions and the following disclaimer in the documentation
  15  *    and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  19  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  24  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  27  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * The views and conclusions contained in the software and documentation are
  30  * those of the authors and should not be interpreted as representing official
  31  * policies, either expressed or implied, of the FreeBSD Project.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/param.h>
  38 #include <sys/condvar.h>
  39 #include <sys/lock.h>
  40 #include <sys/mutex.h>
  41 #include <sys/proc.h>
  42 #include <sys/syslog.h>
  43 #include <sys/taskqueue.h>
  44 #include <sys/malloc.h>
  45
  46 #include "common/efx.h"
  47 #include "common/efx_mcdi.h"
  48 #include "common/efx_regs_mcdi.h"
  49
  50 #include "sfxge.h"
  51
  52 #if EFSYS_OPT_MCDI_LOGGING
  53 #include <dev/pci/pcivar.h>
  54 #endif
  55
  56 #define SFXGE_MCDI_POLL_INTERVAL_MIN 10         /* 10us in 1us units */
  57 #define SFXGE_MCDI_POLL_INTERVAL_MAX 100000     /* 100ms in 1us units */
  58 #define SFXGE_MCDI_WATCHDOG_INTERVAL 10000000   /* 10s in 1us units */
  59
  60 static void
  61 sfxge_mcdi_timeout(struct sfxge_softc *sc)
  62 {
  63         device_t dev = sc->dev;
  64
  65         log(LOG_WARNING, "[%s%d] MC_TIMEOUT", device_get_name(dev),
  66                 device_get_unit(dev));
  67
  68         EFSYS_PROBE(mcdi_timeout);
  69         sfxge_schedule_reset(sc);
  70 }
  71
  72 static void
  73 sfxge_mcdi_poll(struct sfxge_softc *sc)
  74 {
  75         efx_nic_t *enp;
  76         clock_t delay_total;
  77         clock_t delay_us;
  78         boolean_t aborted;
  79
  80         delay_total = 0;
  81         delay_us = SFXGE_MCDI_POLL_INTERVAL_MIN;
  82         enp = sc->enp;
  83
  84         do {
  85                 if (efx_mcdi_request_poll(enp)) {
  86                         EFSYS_PROBE1(mcdi_delay, clock_t, delay_total);
  87                         return;
  88                 }
  89
  90                 if (delay_total > SFXGE_MCDI_WATCHDOG_INTERVAL) {
  91                         aborted = efx_mcdi_request_abort(enp);
  92                         KASSERT(aborted, ("abort failed"));
  93                         sfxge_mcdi_timeout(sc);
  94                         return;
  95                 }
  96
  97                 /* Spin or block depending on delay interval. */
  98                 if (delay_us < 1000000)
  99                         DELAY(delay_us);
 100                 else
 101                         pause("mcdi wait", delay_us * hz / 1000000);
 102
 103                 delay_total += delay_us;
 104
 105                 /* Exponentially back off the poll frequency. */
 106                 delay_us = delay_us * 2;
 107                 if (delay_us > SFXGE_MCDI_POLL_INTERVAL_MAX)
 108                         delay_us = SFXGE_MCDI_POLL_INTERVAL_MAX;
 109
 110         } while (1);
 111 }
 112
 113 static void
 114 sfxge_mcdi_execute(void *arg, efx_mcdi_req_t *emrp)
 115 {
 116         struct sfxge_softc *sc;
 117         struct sfxge_mcdi *mcdi;
 118
 119         sc = (struct sfxge_softc *)arg;
 120         mcdi = &sc->mcdi;
 121
 122         SFXGE_MCDI_LOCK(mcdi);
 123
 124         KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED,
 125             ("MCDI not initialized"));
 126
 127         /* Issue request and poll for completion. */
 128         efx_mcdi_request_start(sc->enp, emrp, B_FALSE);
 129         sfxge_mcdi_poll(sc);
 130
 131         SFXGE_MCDI_UNLOCK(mcdi);
 132 }
 133
 134 static void
 135 sfxge_mcdi_ev_cpl(void *arg)
 136 {
 137         struct sfxge_softc *sc;
 138         struct sfxge_mcdi *mcdi;
 139
 140         sc = (struct sfxge_softc *)arg;
 141         mcdi = &sc->mcdi;
 142
 143         KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED,
 144             ("MCDI not initialized"));
 145
 146         /* We do not use MCDI completion, MCDI is simply polled */
 147 }
 148
 149 static void
 150 sfxge_mcdi_exception(void *arg, efx_mcdi_exception_t eme)
 151 {
 152         struct sfxge_softc *sc;
 153         device_t dev;
 154
 155         sc = (struct sfxge_softc *)arg;
 156         dev = sc->dev;
 157
 158         log(LOG_WARNING, "[%s%d] MC_%s", device_get_name(dev),
 159             device_get_unit(dev),
 160             (eme == EFX_MCDI_EXCEPTION_MC_REBOOT)
 161             ? "REBOOT"
 162             : (eme == EFX_MCDI_EXCEPTION_MC_BADASSERT)
 163             ? "BADASSERT" : "UNKNOWN");
 164
 165         EFSYS_PROBE(mcdi_exception);
 166
 167         sfxge_schedule_reset(sc);
 168 }
 169
 170 #if EFSYS_OPT_MCDI_LOGGING
 171
 172 #define SFXGE_MCDI_LOG_BUF_SIZE 128
 173
 174 static size_t
 175 sfxge_mcdi_do_log(char *buffer, void *data, size_t data_size,
 176                   size_t pfxsize, size_t position)
 177 {
 178         uint32_t *words = data;
 179         size_t i;
 180
 181         for (i = 0; i < data_size; i += sizeof(*words)) {
 182                 if (position + 2 * sizeof(*words) + 1 >= SFXGE_MCDI_LOG_BUF_SIZE) {
 183                         buffer[position] = '\0';
 184                         printf("%s \\\n", buffer);
 185                         position = pfxsize;
 186                 }
 187                 snprintf(buffer + position, SFXGE_MCDI_LOG_BUF_SIZE - position,
 188                          " %08x", *words);
 189                 words++;
 190                 position += 2 * sizeof(uint32_t) + 1;
 191         }
 192         return (position);
 193 }
 194
 195 static void
 196 sfxge_mcdi_logger(void *arg, efx_log_msg_t type,
 197                   void *header, size_t header_size,
 198                   void *data, size_t data_size)
 199 {
 200         struct sfxge_softc *sc = (struct sfxge_softc *)arg;
 201         char buffer[SFXGE_MCDI_LOG_BUF_SIZE];
 202         size_t pfxsize;
 203         size_t start;
 204
 205         if (!sc->mcdi_logging)
 206                 return;
 207
 208         pfxsize = snprintf(buffer, sizeof(buffer),
 209                            "sfc %04x:%02x:%02x.%02x %s MCDI RPC %s:",
 210                            pci_get_domain(sc->dev),
 211                            pci_get_bus(sc->dev),
 212                            pci_get_slot(sc->dev),
 213                            pci_get_function(sc->dev),
 214                            device_get_nameunit(sc->dev),
 215                            type == EFX_LOG_MCDI_REQUEST ? "REQ" :
 216                            type == EFX_LOG_MCDI_RESPONSE ? "RESP" : "???");
 217         start = sfxge_mcdi_do_log(buffer, header, header_size,
 218                                   pfxsize, pfxsize);
 219         start = sfxge_mcdi_do_log(buffer, data, data_size, pfxsize, start);
 220         if (start != pfxsize) {
 221                 buffer[start] = '\0';
 222                 printf("%s\n", buffer);
 223         }
 224 }
 225
 226 #endif
 227
 228 int
 229 sfxge_mcdi_ioctl(struct sfxge_softc *sc, sfxge_ioc_t *ip)
 230 {
 231         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sc->enp);
 232         struct sfxge_mcdi *mp = &(sc->mcdi);
 233         efx_mcdi_req_t emr;
 234         uint8_t *mcdibuf;
 235         int rc;
 236
 237         if (mp->state == SFXGE_MCDI_UNINITIALIZED) {
 238                 rc = ENODEV;
 239                 goto fail1;
 240         }
 241
 242         if (!(encp->enc_features & EFX_FEATURE_MCDI)) {
 243                 rc = ENOTSUP;
 244                 goto fail2;
 245         }
 246
 247         if (ip->u.mcdi.len > SFXGE_MCDI_MAX_PAYLOAD) {
 248                 rc = EINVAL;
 249                 goto fail3;
 250         }
 251
 252         mcdibuf = malloc(SFXGE_MCDI_MAX_PAYLOAD, M_TEMP, M_WAITOK | M_ZERO);
 253         if ((rc = copyin(ip->u.mcdi.payload, mcdibuf, ip->u.mcdi.len)) != 0) {
 254                 goto fail5;
 255         }
 256
 257         emr.emr_cmd = ip->u.mcdi.cmd;
 258         emr.emr_in_buf = mcdibuf;
 259         emr.emr_in_length = ip->u.mcdi.len;
 260
 261         emr.emr_out_buf = mcdibuf;
 262         emr.emr_out_length = SFXGE_MCDI_MAX_PAYLOAD;
 263
 264         sfxge_mcdi_execute(sc, &emr);
 265
 266         ip->u.mcdi.rc = emr.emr_rc;
 267         ip->u.mcdi.cmd = emr.emr_cmd;
 268         ip->u.mcdi.len = emr.emr_out_length_used;
 269         if ((rc = copyout(mcdibuf, ip->u.mcdi.payload, ip->u.mcdi.len)) != 0) {
 270                 goto fail6;
 271         }
 272
 273         /*
 274          * Helpfully trigger a device reset in response to an MCDI_CMD_REBOOT
 275          * Both ports will see ->emt_exception callbacks on the next MCDI poll
 276          */
 277         if (ip->u.mcdi.cmd == MC_CMD_REBOOT) {
 278
 279                 EFSYS_PROBE(mcdi_ioctl_mc_reboot);
 280                 /* sfxge_t->s_state_lock held */
 281                 (void) sfxge_schedule_reset(sc);
 282         }
 283
 284         free(mcdibuf, M_TEMP);
 285
 286         return (0);
 287
 288 fail6:
 289 fail5:
 290         free(mcdibuf, M_TEMP);
 291 fail3:
 292 fail2:
 293 fail1:
 294         return (rc);
 295 }
 296
 297
 298 int
 299 sfxge_mcdi_init(struct sfxge_softc *sc)
 300 {
 301         efx_nic_t *enp;
 302         struct sfxge_mcdi *mcdi;
 303         efx_mcdi_transport_t *emtp;
 304         efsys_mem_t *esmp;
 305         int max_msg_size;
 306         int rc;
 307
 308         enp = sc->enp;
 309         mcdi = &sc->mcdi;
 310         emtp = &mcdi->transport;
 311         esmp = &mcdi->mem;
 312         max_msg_size = sizeof (uint32_t) + MCDI_CTL_SDU_LEN_MAX_V2;
 313
 314         KASSERT(mcdi->state == SFXGE_MCDI_UNINITIALIZED,
 315             ("MCDI already initialized"));
 316
 317         SFXGE_MCDI_LOCK_INIT(mcdi, device_get_nameunit(sc->dev));
 318
 319         mcdi->state = SFXGE_MCDI_INITIALIZED;
 320
 321         if ((rc = sfxge_dma_alloc(sc, max_msg_size, esmp)) != 0)
 322                 goto fail;
 323
 324         emtp->emt_context = sc;
 325         emtp->emt_dma_mem = esmp;
 326         emtp->emt_execute = sfxge_mcdi_execute;
 327         emtp->emt_ev_cpl = sfxge_mcdi_ev_cpl;
 328         emtp->emt_exception = sfxge_mcdi_exception;
 329 #if EFSYS_OPT_MCDI_LOGGING
 330         emtp->emt_logger = sfxge_mcdi_logger;
 331         SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev),
 332                        SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
 333                        OID_AUTO, "mcdi_logging", CTLFLAG_RW,
 334                        &sc->mcdi_logging, 0,
 335                        "MCDI logging");
 336 #endif
 337
 338         if ((rc = efx_mcdi_init(enp, emtp)) != 0)
 339                 goto fail;
 340
 341         return (0);
 342
 343 fail:
 344         SFXGE_MCDI_LOCK_DESTROY(mcdi);
 345         mcdi->state = SFXGE_MCDI_UNINITIALIZED;
 346         return (rc);
 347 }
 348
 349 void
 350 sfxge_mcdi_fini(struct sfxge_softc *sc)
 351 {
 352         struct sfxge_mcdi *mcdi;
 353         efx_nic_t *enp;
 354         efx_mcdi_transport_t *emtp;
 355         efsys_mem_t *esmp;
 356
 357         enp = sc->enp;
 358         mcdi = &sc->mcdi;
 359         emtp = &mcdi->transport;
 360         esmp = &mcdi->mem;
 361
 362         SFXGE_MCDI_LOCK(mcdi);
 363         KASSERT(mcdi->state == SFXGE_MCDI_INITIALIZED,
 364             ("MCDI not initialized"));
 365
 366         efx_mcdi_fini(enp);
 367         bzero(emtp, sizeof(*emtp));
 368
 369         SFXGE_MCDI_UNLOCK(mcdi);
 370
 371         sfxge_dma_free(esmp);
 372
 373         SFXGE_MCDI_LOCK_DESTROY(mcdi);
 374 }