drivers/net/sfc/sfc_mcdi.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright(c) 2019-2020 Xilinx, Inc.
   4  * Copyright(c) 2016-2019 Solarflare Communications Inc.
   5  *
   6  * This software was jointly developed between OKTET Labs (under contract
   7  * for Solarflare) and Solarflare Communications, Inc.
   8  */
   9
  10 #include <rte_cycles.h>
  11
  12 #include "efx.h"
  13 #include "efx_mcdi.h"
  14 #include "efx_regs_mcdi.h"
  15
  16 #include "sfc_mcdi.h"
  17 #include "sfc.h"
  18 #include "sfc_debug.h"
  19 #include "sfc_log.h"
  20 #include "sfc_ev.h"
  21
  22 #define SFC_EFX_MCDI_POLL_INTERVAL_MIN_US       10              /* 10us */
  23 #define SFC_EFX_MCDI_POLL_INTERVAL_MAX_US       (US_PER_S / 10) /* 100ms */
  24 #define SFC_EFX_MCDI_WATCHDOG_INTERVAL_US       (10 * US_PER_S) /* 10s */
  25
  26 #define sfc_efx_mcdi_log(mcdi, level, ...) \
  27         do {                                                            \
  28                 const struct sfc_efx_mcdi *_mcdi = (mcdi);              \
  29                                                                         \
  30                 rte_log(level, _mcdi->logtype,                          \
  31                         RTE_FMT("%s" RTE_FMT_HEAD(__VA_ARGS__ ,) "\n",  \
  32                                 _mcdi->log_prefix,                      \
  33                                 RTE_FMT_TAIL(__VA_ARGS__,)));           \
  34         } while (0)
  35
  36 #define sfc_efx_mcdi_crit(mcdi, ...) \
  37         sfc_efx_mcdi_log(mcdi, RTE_LOG_CRIT, __VA_ARGS__)
  38
  39 #define sfc_efx_mcdi_err(mcdi, ...) \
  40         sfc_efx_mcdi_log(mcdi, RTE_LOG_ERR, __VA_ARGS__)
  41
  42 #define sfc_efx_mcdi_warn(mcdi, ...) \
  43         sfc_efx_mcdi_log(mcdi, RTE_LOG_WARNING, __VA_ARGS__)
  44
  45 #define sfc_efx_mcdi_info(mcdi, ...) \
  46         sfc_efx_mcdi_log(mcdi, RTE_LOG_INFO, __VA_ARGS__)
  47
  48 /** Level value used by MCDI log statements */
  49 #define SFC_EFX_LOG_LEVEL_MCDI  RTE_LOG_INFO
  50
  51 #define sfc_efx_log_mcdi(mcdi, ...) \
  52         sfc_efx_mcdi_log(mcdi, SFC_EFX_LOG_LEVEL_MCDI, __VA_ARGS__)
  53
  54 static void
  55 sfc_efx_mcdi_timeout(struct sfc_adapter *sa)
  56 {
  57         struct sfc_efx_mcdi *mcdi = &sa->mcdi;
  58
  59         sfc_efx_mcdi_warn(mcdi, "MC TIMEOUT");
  60
  61         mcdi->state = SFC_EFX_MCDI_DEAD;
  62         sfc_efx_mcdi_crit(mcdi,
  63                 "MCDI timeout handling is not implemented - NIC is unusable");
  64 }
  65
  66 static inline boolean_t
  67 sfc_efx_mcdi_proxy_event_available(struct sfc_adapter *sa)
  68 {
  69         struct sfc_efx_mcdi *mcdi = &sa->mcdi;
  70
  71         mcdi->proxy_handle = 0;
  72         mcdi->proxy_result = ETIMEDOUT;
  73         sfc_ev_mgmt_qpoll(sa);
  74         if (mcdi->proxy_result != ETIMEDOUT)
  75                 return B_TRUE;
  76
  77         return B_FALSE;
  78 }
  79
  80 static void
  81 sfc_efx_mcdi_poll(struct sfc_adapter *sa, boolean_t proxy)
  82 {
  83         struct sfc_efx_mcdi *mcdi = &sa->mcdi;
  84         efx_nic_t *enp;
  85         unsigned int delay_total;
  86         unsigned int delay_us;
  87         boolean_t aborted __rte_unused;
  88
  89         delay_total = 0;
  90         delay_us = SFC_EFX_MCDI_POLL_INTERVAL_MIN_US;
  91         enp = mcdi->nic;
  92
  93         do {
  94                 boolean_t poll_completed;
  95
  96                 poll_completed = (proxy) ? sfc_efx_mcdi_proxy_event_available(sa) :
  97                                            efx_mcdi_request_poll(enp);
  98                 if (poll_completed)
  99                         return;
 100
 101                 if (delay_total > SFC_EFX_MCDI_WATCHDOG_INTERVAL_US) {
 102                         if (!proxy) {
 103                                 aborted = efx_mcdi_request_abort(enp);
 104                                 SFC_ASSERT(aborted);
 105                                 sfc_efx_mcdi_timeout(sa);
 106                         }
 107
 108                         return;
 109                 }
 110
 111                 rte_delay_us(delay_us);
 112
 113                 delay_total += delay_us;
 114
 115                 /* Exponentially back off the poll frequency */
 116                 RTE_BUILD_BUG_ON(SFC_EFX_MCDI_POLL_INTERVAL_MAX_US >
 117                                  UINT_MAX / 2);
 118                 delay_us *= 2;
 119                 if (delay_us > SFC_EFX_MCDI_POLL_INTERVAL_MAX_US)
 120                         delay_us = SFC_EFX_MCDI_POLL_INTERVAL_MAX_US;
 121
 122         } while (1);
 123 }
 124
 125 static void
 126 sfc_efx_mcdi_execute(void *arg, efx_mcdi_req_t *emrp)
 127 {
 128         struct sfc_adapter *sa = (struct sfc_adapter *)arg;
 129         struct sfc_efx_mcdi *mcdi = &sa->mcdi;
 130         uint32_t proxy_handle;
 131
 132         if (mcdi->state == SFC_EFX_MCDI_DEAD) {
 133                 emrp->emr_rc = ENOEXEC;
 134                 return;
 135         }
 136
 137         rte_spinlock_lock(&mcdi->lock);
 138
 139         SFC_ASSERT(mcdi->state == SFC_EFX_MCDI_INITIALIZED);
 140
 141         efx_mcdi_request_start(mcdi->nic, emrp, B_FALSE);
 142         sfc_efx_mcdi_poll(sa, B_FALSE);
 143
 144         if (efx_mcdi_get_proxy_handle(mcdi->nic, emrp, &proxy_handle) == 0) {
 145                 /*
 146                  * Authorization is required for the MCDI request;
 147                  * wait for an MCDI proxy response event to bring
 148                  * a non-zero proxy handle (should be the same as
 149                  * the value obtained above) and operation status
 150                  */
 151                 sfc_efx_mcdi_poll(sa, B_TRUE);
 152
 153                 if ((mcdi->proxy_handle != 0) &&
 154                     (mcdi->proxy_handle != proxy_handle)) {
 155                         sfc_efx_mcdi_err(mcdi, "Unexpected MCDI proxy event");
 156                         emrp->emr_rc = EFAULT;
 157                 } else if (mcdi->proxy_result == 0) {
 158                         /*
 159                          * Authorization succeeded; re-issue the original
 160                          * request and poll for an ordinary MCDI response
 161                          */
 162                         efx_mcdi_request_start(mcdi->nic, emrp, B_FALSE);
 163                         sfc_efx_mcdi_poll(sa, B_FALSE);
 164                 } else {
 165                         emrp->emr_rc = mcdi->proxy_result;
 166                         sfc_efx_mcdi_err(mcdi,
 167                                 "MCDI proxy authorization failed (handle=%08x, result=%d)",
 168                                 proxy_handle, mcdi->proxy_result);
 169                 }
 170         }
 171
 172         rte_spinlock_unlock(&mcdi->lock);
 173 }
 174
 175 static void
 176 sfc_efx_mcdi_ev_cpl(void *arg)
 177 {
 178         struct sfc_adapter *sa = (struct sfc_adapter *)arg;
 179         struct sfc_efx_mcdi *mcdi __rte_unused;
 180
 181         mcdi = &sa->mcdi;
 182         SFC_ASSERT(mcdi->state == SFC_EFX_MCDI_INITIALIZED);
 183
 184         /* MCDI is polled, completions are not expected */
 185         SFC_ASSERT(0);
 186 }
 187
 188 static void
 189 sfc_efx_mcdi_exception(void *arg, efx_mcdi_exception_t eme)
 190 {
 191         struct sfc_adapter *sa = (struct sfc_adapter *)arg;
 192         struct sfc_efx_mcdi *mcdi  = &sa->mcdi;
 193
 194         sfc_efx_mcdi_warn(mcdi, "MC %s",
 195             (eme == EFX_MCDI_EXCEPTION_MC_REBOOT) ? "REBOOT" :
 196             (eme == EFX_MCDI_EXCEPTION_MC_BADASSERT) ? "BADASSERT" : "UNKNOWN");
 197
 198         sfc_schedule_restart(sa);
 199 }
 200
 201 #define SFC_MCDI_LOG_BUF_SIZE   128
 202
 203 static size_t
 204 sfc_efx_mcdi_do_log(const struct sfc_efx_mcdi *mcdi,
 205                 char *buffer, void *data, size_t data_size,
 206                 size_t pfxsize, size_t position)
 207 {
 208         uint32_t *words = data;
 209         /* Space separator plus 2 characters per byte */
 210         const size_t word_str_space = 1 + 2 * sizeof(*words);
 211         size_t i;
 212
 213         for (i = 0; i < data_size; i += sizeof(*words)) {
 214                 if (position + word_str_space >=
 215                     SFC_MCDI_LOG_BUF_SIZE) {
 216                         /* Flush at SFC_MCDI_LOG_BUF_SIZE with backslash
 217                          * at the end which is required by netlogdecode.
 218                          */
 219                         buffer[position] = '\0';
 220                         sfc_efx_log_mcdi(mcdi, "%s \\", buffer);
 221                         /* Preserve prefix for the next log message */
 222                         position = pfxsize;
 223                 }
 224                 position += snprintf(buffer + position,
 225                                      SFC_MCDI_LOG_BUF_SIZE - position,
 226                                      " %08x", *words);
 227                 words++;
 228         }
 229         return position;
 230 }
 231
 232 static void
 233 sfc_efx_mcdi_logger(void *arg, efx_log_msg_t type,
 234                 void *header, size_t header_size,
 235                 void *data, size_t data_size)
 236 {
 237         struct sfc_adapter *sa = (struct sfc_adapter *)arg;
 238         struct sfc_efx_mcdi *mcdi = &sa->mcdi;
 239         char buffer[SFC_MCDI_LOG_BUF_SIZE];
 240         size_t pfxsize;
 241         size_t start;
 242
 243         /*
 244          * Unlike the other cases, MCDI logging implies more onerous work
 245          * needed to produce a message. If the dynamic log level prevents
 246          * the end result from being printed, the CPU time will be wasted.
 247          *
 248          * To avoid wasting time, the actual level is examined in advance.
 249          */
 250         if (rte_log_get_level(mcdi->logtype) < (int)SFC_EFX_LOG_LEVEL_MCDI)
 251                 return;
 252
 253         /* The format including prefix added by sfc_efx_log_mcdi() is the
 254          * format consumed by the Solarflare netlogdecode tool.
 255          */
 256         pfxsize = snprintf(buffer, sizeof(buffer), "MCDI RPC %s:",
 257                            type == EFX_LOG_MCDI_REQUEST ? "REQ" :
 258                            type == EFX_LOG_MCDI_RESPONSE ? "RESP" : "???");
 259         start = sfc_efx_mcdi_do_log(mcdi, buffer, header, header_size,
 260                                     pfxsize, pfxsize);
 261         start = sfc_efx_mcdi_do_log(mcdi, buffer, data, data_size,
 262                                     pfxsize, start);
 263         if (start != pfxsize) {
 264                 buffer[start] = '\0';
 265                 sfc_efx_log_mcdi(mcdi, "%s", buffer);
 266         }
 267 }
 268
 269 static void
 270 sfc_efx_mcdi_ev_proxy_response(void *arg, uint32_t handle, efx_rc_t result)
 271 {
 272         struct sfc_adapter *sa = (struct sfc_adapter *)arg;
 273         struct sfc_efx_mcdi *mcdi = &sa->mcdi;
 274
 275         mcdi->proxy_handle = handle;
 276         mcdi->proxy_result = result;
 277 }
 278
 279 static int
 280 sfc_efx_mcdi_init(struct sfc_adapter *sa, struct sfc_efx_mcdi *mcdi,
 281                   uint32_t logtype, const char *log_prefix, efx_nic_t *nic)
 282 {
 283         size_t max_msg_size;
 284         efx_mcdi_transport_t *emtp;
 285         int rc;
 286
 287         SFC_ASSERT(mcdi->state == SFC_EFX_MCDI_UNINITIALIZED);
 288
 289         rte_spinlock_init(&mcdi->lock);
 290
 291         mcdi->nic = nic;
 292
 293         mcdi->state = SFC_EFX_MCDI_INITIALIZED;
 294
 295         mcdi->logtype = logtype;
 296         mcdi->log_prefix = log_prefix;
 297
 298         max_msg_size = sizeof(uint32_t) + MCDI_CTL_SDU_LEN_MAX_V2;
 299         rc = sfc_dma_alloc(sa, "mcdi", 0, max_msg_size, sa->socket_id,
 300                            &mcdi->mem);
 301         if (rc != 0)
 302                 goto fail_dma_alloc;
 303
 304         emtp = &mcdi->transport;
 305         emtp->emt_context = sa;
 306         emtp->emt_dma_mem = &mcdi->mem;
 307         emtp->emt_execute = sfc_efx_mcdi_execute;
 308         emtp->emt_ev_cpl = sfc_efx_mcdi_ev_cpl;
 309         emtp->emt_exception = sfc_efx_mcdi_exception;
 310         emtp->emt_logger = sfc_efx_mcdi_logger;
 311         emtp->emt_ev_proxy_response = sfc_efx_mcdi_ev_proxy_response;
 312
 313         sfc_efx_mcdi_info(mcdi, "init MCDI");
 314         rc = efx_mcdi_init(mcdi->nic, emtp);
 315         if (rc != 0)
 316                 goto fail_mcdi_init;
 317
 318         return 0;
 319
 320 fail_mcdi_init:
 321         memset(emtp, 0, sizeof(*emtp));
 322         sfc_dma_free(sa, &mcdi->mem);
 323
 324 fail_dma_alloc:
 325         mcdi->state = SFC_EFX_MCDI_UNINITIALIZED;
 326         return rc;
 327 }
 328
 329 static void
 330 sfc_efx_mcdi_fini(struct sfc_adapter *sa, struct sfc_efx_mcdi *mcdi)
 331 {
 332         efx_mcdi_transport_t *emtp;
 333
 334         emtp = &mcdi->transport;
 335
 336         rte_spinlock_lock(&mcdi->lock);
 337
 338         SFC_ASSERT(mcdi->state == SFC_EFX_MCDI_INITIALIZED ||
 339                    mcdi->state == SFC_EFX_MCDI_DEAD);
 340         mcdi->state = SFC_EFX_MCDI_UNINITIALIZED;
 341
 342         sfc_efx_mcdi_info(mcdi, "fini MCDI");
 343         efx_mcdi_fini(mcdi->nic);
 344         memset(emtp, 0, sizeof(*emtp));
 345
 346         rte_spinlock_unlock(&mcdi->lock);
 347
 348         sfc_dma_free(sa, &mcdi->mem);
 349 }
 350
 351 int
 352 sfc_mcdi_init(struct sfc_adapter *sa)
 353 {
 354         uint32_t logtype;
 355
 356         sfc_log_init(sa, "entry");
 357
 358         logtype = sfc_register_logtype(&sa->priv.shared->pci_addr,
 359                                        SFC_LOGTYPE_MCDI_STR,
 360                                        RTE_LOG_NOTICE);
 361
 362         return sfc_efx_mcdi_init(sa, &sa->mcdi, logtype,
 363                                  sa->priv.shared->log_prefix, sa->nic);
 364 }
 365
 366 void
 367 sfc_mcdi_fini(struct sfc_adapter *sa)
 368 {
 369         sfc_log_init(sa, "entry");
 370         sfc_efx_mcdi_fini(sa, &sa->mcdi);
 371 }