kernel/drivers/net/sfxge/sfxge_mcdi.c

   1 /*
   2  * Copyright (c) 2009-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/types.h>
  32 #include <sys/ddi.h>
  33 #include <sys/sunddi.h>
  34 #include <sys/stream.h>
  35 #include <sys/dlpi.h>
  36 #include <sys/pci.h>
  37
  38 #include "sfxge.h"
  39 #include "efsys.h"
  40 #include "efx.h"
  41 #include "efx_mcdi.h"
  42 #include "efx_regs_mcdi.h"
  43
  44 /* MAC DMA attributes */
  45 static ddi_device_acc_attr_t sfxge_mcdi_devacc = {
  46
  47         DDI_DEVICE_ATTR_V0,     /* devacc_attr_version */
  48         DDI_NEVERSWAP_ACC,      /* devacc_attr_endian_flags */
  49         DDI_STRICTORDER_ACC     /* devacc_attr_dataorder */
  50 };
  51
  52 static ddi_dma_attr_t sfxge_mcdi_dma_attr = {
  53         DMA_ATTR_V0,            /* dma_attr_version     */
  54         0,                      /* dma_attr_addr_lo     */
  55         0xffffffffffffffffull,  /* dma_attr_addr_hi     */
  56         0xffffffffffffffffull,  /* dma_attr_count_max   */
  57         0x1000,                 /* dma_attr_align       */
  58         0xffffffff,             /* dma_attr_burstsizes  */
  59         1,                      /* dma_attr_minxfer     */
  60         0xffffffffffffffffull,  /* dma_attr_maxxfer     */
  61         0xffffffffffffffffull,  /* dma_attr_seg         */
  62         1,                      /* dma_attr_sgllen      */
  63         1,                      /* dma_attr_granular    */
  64         0                       /* dma_attr_flags       */
  65 };
  66
  67 /*
  68  * Notes on MCDI operation:
  69  * ------------------------
  70  * MCDI requests can be made in arbitrary thread context, and as a synchronous
  71  * API must therefore block until the response is available from the MC, or
  72  * a watchdog timeout occurs.
  73  *
  74  * This interacts badly with the limited number of worker threads (2 per CPU)
  75  * used by the Solaris callout subsystem to invoke timeout handlers. If both
  76  * worker threads are blocked (e.g. waiting for a condvar or mutex) then timeout
  77  * processing is deadlocked on that CPU, causing system failure.
  78  *
  79  * For this reason the driver does not use event based MCDI completion, as this
  80  * leads to numerous paths involving timeouts and reentrant GLDv3 entrypoints
  81  * that result in a deadlocked system.
  82  */
  83 #define SFXGE_MCDI_POLL_INTERVAL        10              /* 10us in 1us units */
  84 #define SFXGE_MCDI_WATCHDOG_INTERVAL    10000000        /* 10s in 1us units */
  85
  86
  87 /* Acquire exclusive access to MCDI for the duration of a request */
  88 static void
  89 sfxge_mcdi_acquire(sfxge_mcdi_t *smp)
  90 {
  91         mutex_enter(&(smp->sm_lock));
  92         ASSERT3U(smp->sm_state, !=, SFXGE_MCDI_UNINITIALIZED);
  93
  94         while (smp->sm_state != SFXGE_MCDI_INITIALIZED) {
  95                 (void) cv_wait(&(smp->sm_kv), &(smp->sm_lock));
  96         }
  97         smp->sm_state = SFXGE_MCDI_BUSY;
  98
  99         mutex_exit(&(smp->sm_lock));
 100 }
 101
 102
 103 /* Release ownership of MCDI on request completion */
 104 static void
 105 sfxge_mcdi_release(sfxge_mcdi_t *smp)
 106 {
 107         mutex_enter(&(smp->sm_lock));
 108         ASSERT((smp->sm_state == SFXGE_MCDI_BUSY) ||
 109             (smp->sm_state == SFXGE_MCDI_COMPLETED));
 110
 111         smp->sm_state = SFXGE_MCDI_INITIALIZED;
 112         cv_broadcast(&(smp->sm_kv));
 113
 114         mutex_exit(&(smp->sm_lock));
 115 }
 116
 117
 118 static void
 119 sfxge_mcdi_timeout(sfxge_t *sp)
 120 {
 121         dev_info_t *dip = sp->s_dip;
 122
 123         dev_err(dip, CE_WARN, SFXGE_CMN_ERR "MC_TIMEOUT");
 124
 125         DTRACE_PROBE(mcdi_timeout);
 126         (void) sfxge_restart_dispatch(sp, DDI_SLEEP, SFXGE_HW_ERR,
 127             "MCDI timeout", 0);
 128 }
 129
 130
 131 static void
 132 sfxge_mcdi_poll(sfxge_t *sp)
 133 {
 134         efx_nic_t *enp = sp->s_enp;
 135         clock_t timeout;
 136         boolean_t aborted;
 137
 138         /* Poll until request completes or timeout */
 139         timeout = ddi_get_lbolt() + drv_usectohz(SFXGE_MCDI_WATCHDOG_INTERVAL);
 140         while (efx_mcdi_request_poll(enp) == B_FALSE) {
 141
 142                 /* No response received yet */
 143                 if (ddi_get_lbolt() > timeout) {
 144                         /* Timeout expired */
 145                         goto fail;
 146                 }
 147
 148                 /* Short delay to avoid excessive PCIe traffic */
 149                 drv_usecwait(SFXGE_MCDI_POLL_INTERVAL);
 150         }
 151
 152         /* Request completed (or polling failed) */
 153         return;
 154
 155 fail:
 156         /* Timeout before request completion */
 157         DTRACE_PROBE(fail);
 158         aborted = efx_mcdi_request_abort(enp);
 159         ASSERT(aborted);
 160         sfxge_mcdi_timeout(sp);
 161 }
 162
 163
 164 static void
 165 sfxge_mcdi_execute(void *arg, efx_mcdi_req_t *emrp)
 166 {
 167         sfxge_t *sp = (sfxge_t *)arg;
 168         sfxge_mcdi_t *smp = &(sp->s_mcdi);
 169
 170         sfxge_mcdi_acquire(smp);
 171
 172         /* Issue request and poll for completion */
 173         efx_mcdi_request_start(sp->s_enp, emrp, B_FALSE);
 174         sfxge_mcdi_poll(sp);
 175
 176         sfxge_mcdi_release(smp);
 177 }
 178
 179
 180 static void
 181 sfxge_mcdi_ev_cpl(void *arg)
 182 {
 183         sfxge_t *sp = (sfxge_t *)arg;
 184         sfxge_mcdi_t *smp = &(sp->s_mcdi);
 185
 186         mutex_enter(&(smp->sm_lock));
 187         ASSERT(smp->sm_state == SFXGE_MCDI_BUSY);
 188         smp->sm_state = SFXGE_MCDI_COMPLETED;
 189         cv_broadcast(&(smp->sm_kv));
 190         mutex_exit(&(smp->sm_lock));
 191 }
 192
 193
 194 static void
 195 sfxge_mcdi_exception(void *arg, efx_mcdi_exception_t eme)
 196 {
 197         sfxge_t *sp = (sfxge_t *)arg;
 198         const char *reason;
 199
 200         if (eme == EFX_MCDI_EXCEPTION_MC_REBOOT)
 201                 reason = "MC_REBOOT";
 202         else if (eme == EFX_MCDI_EXCEPTION_MC_BADASSERT)
 203                 reason = "MC_BADASSERT";
 204         else
 205                 reason = "MC_UNKNOWN";
 206
 207         DTRACE_PROBE(mcdi_exception);
 208         /* sfxge_evq_t->se_lock held */
 209         (void) sfxge_restart_dispatch(sp, DDI_SLEEP, SFXGE_HW_ERR, reason, 0);
 210 }
 211
 212 #if EFSYS_OPT_MCDI_LOGGING
 213 #define SFXGE_MCDI_LOG_BUF_SIZE 128
 214
 215 static size_t
 216 sfxge_mcdi_do_log(char *buffer, void *data, size_t data_size,
 217     size_t pfxsize, size_t position)
 218 {
 219         uint32_t *words = data;
 220         size_t i;
 221
 222         for (i = 0; i < data_size; i += sizeof (*words)) {
 223                 if (position + 2 * sizeof (*words) + 1 >=
 224                     SFXGE_MCDI_LOG_BUF_SIZE) {
 225                         buffer[position] = '\0';
 226                         cmn_err(CE_NOTE, "%s \\", buffer);
 227                         position = pfxsize;
 228                 }
 229                 snprintf(buffer + position, SFXGE_MCDI_LOG_BUF_SIZE - position,
 230                     " %08x", *words);
 231                 words++;
 232                 position += 2 * sizeof (uint32_t) + 1;
 233         }
 234         return (position);
 235 }
 236
 237
 238 static void
 239 sfxge_mcdi_logger(void *arg, efx_log_msg_t type,
 240     void *header, size_t header_size, void *data, size_t data_size)
 241 {
 242         sfxge_t *sp = (sfxge_t *)arg;
 243         char buffer[SFXGE_MCDI_LOG_BUF_SIZE];
 244         size_t pfxsize;
 245         size_t start;
 246
 247         if (!sp->s_mcdi_logging)
 248                 return;
 249
 250         pfxsize = snprintf(buffer, sizeof (buffer),
 251             "sfc %04x:%02x:%02x.%02x %s%d MCDI RPC %s:",
 252             0,
 253             PCI_REG_BUS_G(sp->s_bus_addr),
 254             PCI_REG_DEV_G(sp->s_bus_addr),
 255             PCI_REG_FUNC_G(sp->s_bus_addr),
 256             ddi_driver_name(sp->s_dip),
 257             ddi_get_instance(sp->s_dip),
 258             type == EFX_LOG_MCDI_REQUEST ? "REQ" :
 259             type == EFX_LOG_MCDI_RESPONSE ? "RESP" : "???");
 260         start = sfxge_mcdi_do_log(buffer, header, header_size,
 261             pfxsize, pfxsize);
 262         start = sfxge_mcdi_do_log(buffer, data, data_size, pfxsize, start);
 263         if (start != pfxsize) {
 264                 buffer[start] = '\0';
 265                 cmn_err(CE_NOTE, "%s", buffer);
 266         }
 267 }
 268 #endif /* EFSYS_OPT_MCDI_LOGGING */
 269
 270 int
 271 sfxge_mcdi_init(sfxge_t *sp)
 272 {
 273         efx_nic_t *enp = sp->s_enp;
 274         sfxge_mcdi_t *smp = &(sp->s_mcdi);
 275         efsys_mem_t *esmp = &(smp->sm_mem);
 276         efx_mcdi_transport_t *emtp = &(smp->sm_emt);
 277         sfxge_dma_buffer_attr_t dma_attr;
 278         int msg_buf_size;
 279         int rc;
 280
 281         ASSERT3U(smp->sm_state, ==, SFXGE_MCDI_UNINITIALIZED);
 282
 283         msg_buf_size = sizeof (uint32_t) + MCDI_CTL_SDU_LEN_MAX_V2;
 284
 285         /* Allocate host DMA buffer for MCDI commands */
 286         dma_attr.sdba_dip        = sp->s_dip;
 287         dma_attr.sdba_dattrp     = &sfxge_mcdi_dma_attr;
 288         dma_attr.sdba_callback   = DDI_DMA_SLEEP;
 289         dma_attr.sdba_length     = msg_buf_size;
 290         dma_attr.sdba_memflags   = DDI_DMA_CONSISTENT;
 291         dma_attr.sdba_devaccp    = &sfxge_mcdi_devacc;
 292         dma_attr.sdba_bindflags  = DDI_DMA_RDWR | DDI_DMA_CONSISTENT;
 293         dma_attr.sdba_maxcookies = 1;
 294         dma_attr.sdba_zeroinit   = B_TRUE;
 295
 296         if ((rc = sfxge_dma_buffer_create(esmp, &dma_attr)) != 0)
 297                 goto fail1;
 298
 299         mutex_init(&(smp->sm_lock), NULL, MUTEX_DRIVER, NULL);
 300
 301         smp->sm_state = SFXGE_MCDI_INITIALIZED;
 302
 303         emtp->emt_context   = sp;
 304         emtp->emt_dma_mem   = esmp;
 305         emtp->emt_execute   = sfxge_mcdi_execute;
 306         emtp->emt_ev_cpl    = sfxge_mcdi_ev_cpl;
 307         emtp->emt_exception = sfxge_mcdi_exception;
 308 #if EFSYS_OPT_MCDI_LOGGING
 309         emtp->emt_logger    = sfxge_mcdi_logger;
 310 #endif
 311
 312         cv_init(&(smp->sm_kv), NULL, CV_DRIVER, NULL);
 313
 314         if ((rc = efx_mcdi_init(enp, emtp)) != 0)
 315                 goto fail2;
 316
 317         return (0);
 318
 319 fail2:
 320         DTRACE_PROBE(fail2);
 321
 322         cv_destroy(&(smp->sm_kv));
 323         mutex_destroy(&(smp->sm_lock));
 324
 325         sfxge_dma_buffer_destroy(esmp);
 326
 327         smp->sm_state = SFXGE_MCDI_UNINITIALIZED;
 328         smp->sm_sp = NULL;
 329         SFXGE_OBJ_CHECK(smp, sfxge_mcdi_t);
 330
 331 fail1:
 332         DTRACE_PROBE1(fail1, int, rc);
 333
 334         return (rc);
 335 }
 336
 337
 338 void
 339 sfxge_mcdi_fini(sfxge_t *sp)
 340 {
 341         efx_nic_t *enp = sp->s_enp;
 342         sfxge_mcdi_t *smp = &(sp->s_mcdi);
 343         efsys_mem_t *esmp = &(smp->sm_mem);
 344         efx_mcdi_transport_t *emtp;
 345
 346         mutex_enter(&(smp->sm_lock));
 347         ASSERT3U(smp->sm_state, ==, SFXGE_MCDI_INITIALIZED);
 348
 349         efx_mcdi_fini(enp);
 350         emtp = &(smp->sm_emt);
 351         bzero(emtp, sizeof (*emtp));
 352
 353         smp->sm_sp = NULL;
 354
 355         cv_destroy(&(smp->sm_kv));
 356         mutex_exit(&(smp->sm_lock));
 357
 358         sfxge_dma_buffer_destroy(esmp);
 359
 360         mutex_destroy(&(smp->sm_lock));
 361
 362         smp->sm_state = SFXGE_MCDI_UNINITIALIZED;
 363         SFXGE_OBJ_CHECK(smp, sfxge_mcdi_t);
 364 }
 365
 366
 367 int
 368 sfxge_mcdi_ioctl(sfxge_t *sp, sfxge_mcdi_ioc_t *smip)
 369 {
 370         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sp->s_enp);
 371         sfxge_mcdi_t *smp = &(sp->s_mcdi);
 372         efx_mcdi_req_t emr;
 373         uint8_t *out;
 374         int rc;
 375
 376         if (smp->sm_state == SFXGE_MCDI_UNINITIALIZED) {
 377                 rc = ENODEV;
 378                 goto fail1;
 379         }
 380
 381         if (!(encp->enc_features & EFX_FEATURE_MCDI)) {
 382                 rc = ENOTSUP;
 383                 goto fail2;
 384         }
 385
 386         out = kmem_zalloc(sizeof (smip->smi_payload), KM_NOSLEEP);
 387         if (out == NULL) {
 388                 rc = ENOMEM;
 389                 goto fail3;
 390         }
 391
 392         emr.emr_cmd = smip->smi_cmd;
 393         emr.emr_in_buf = smip->smi_payload;
 394         emr.emr_in_length = smip->smi_len;
 395
 396         emr.emr_out_buf = out;
 397         emr.emr_out_length = sizeof (smip->smi_payload);
 398
 399         sfxge_mcdi_execute(sp, &emr);
 400
 401         smip->smi_rc = (uint8_t)emr.emr_rc;
 402         smip->smi_cmd = (uint8_t)emr.emr_cmd;
 403         smip->smi_len = (uint8_t)emr.emr_out_length_used;
 404         bcopy(out, smip->smi_payload, smip->smi_len);
 405
 406         /*
 407          * Helpfully trigger a device reset in response to an MCDI_CMD_REBOOT
 408          * Both ports will see ->emt_exception callbacks on the next MCDI poll
 409          */
 410         if (smip->smi_cmd == MC_CMD_REBOOT) {
 411
 412                 DTRACE_PROBE(mcdi_ioctl_mc_reboot);
 413                 /* sfxge_t->s_state_lock held */
 414                 (void) sfxge_restart_dispatch(sp, DDI_SLEEP, SFXGE_HW_OK,
 415                     "MC_REBOOT triggering restart", 0);
 416         }
 417
 418         kmem_free(out, sizeof (smip->smi_payload));
 419
 420         return (0);
 421
 422 fail3:
 423         DTRACE_PROBE(fail3);
 424 fail2:
 425         DTRACE_PROBE(fail2);
 426 fail1:
 427         DTRACE_PROBE1(fail1, int, rc);
 428         return (rc);
 429 }
 430
 431 int
 432 sfxge_mcdi2_ioctl(sfxge_t *sp, sfxge_mcdi2_ioc_t *smip)
 433 {
 434         const efx_nic_cfg_t *encp = efx_nic_cfg_get(sp->s_enp);
 435         sfxge_mcdi_t *smp = &(sp->s_mcdi);
 436         efx_mcdi_req_t emr;
 437         uint8_t *out;
 438         int rc;
 439
 440         if (smp->sm_state == SFXGE_MCDI_UNINITIALIZED) {
 441                 rc = ENODEV;
 442                 goto fail1;
 443         }
 444
 445         if (!(encp->enc_features & EFX_FEATURE_MCDI)) {
 446                 rc = ENOTSUP;
 447                 goto fail2;
 448         }
 449
 450         out = kmem_zalloc(sizeof (smip->smi_payload), KM_NOSLEEP);
 451         if (out == NULL) {
 452                 rc = ENOMEM;
 453                 goto fail3;
 454         }
 455
 456         emr.emr_cmd = smip->smi_cmd;
 457         emr.emr_in_buf = smip->smi_payload;
 458         emr.emr_in_length = smip->smi_len;
 459
 460         emr.emr_out_buf = out;
 461         emr.emr_out_length = sizeof (smip->smi_payload);
 462
 463         sfxge_mcdi_execute(sp, &emr);
 464
 465         smip->smi_rc = emr.emr_rc;
 466         smip->smi_cmd = emr.emr_cmd;
 467         smip->smi_len = (uint32_t)emr.emr_out_length_used;
 468         bcopy(out, smip->smi_payload, smip->smi_len);
 469
 470         /*
 471          * Helpfully trigger a device reset in response to an MCDI_CMD_REBOOT
 472          * Both ports will see ->emt_exception callbacks on the next MCDI poll
 473          */
 474         if (smip->smi_cmd == MC_CMD_REBOOT) {
 475
 476                 DTRACE_PROBE(mcdi_ioctl_mc_reboot);
 477                 /* sfxge_t->s_state_lock held */
 478                 (void) sfxge_restart_dispatch(sp, DDI_SLEEP, SFXGE_HW_OK,
 479                     "MC_REBOOT triggering restart", 0);
 480         }
 481
 482         kmem_free(out, sizeof (smip->smi_payload));
 483
 484         return (0);
 485
 486 fail3:
 487         DTRACE_PROBE(fail3);
 488 fail2:
 489         DTRACE_PROBE(fail2);
 490 fail1:
 491         DTRACE_PROBE1(fail1, int, rc);
 492         return (rc);
 493 }