drivers/net/ethernet/sfc/mcdi.c

   1 /****************************************************************************
   2  * Driver for Solarflare network controllers and boards
   3  * Copyright 2008-2013 Solarflare Communications Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published
   7  * by the Free Software Foundation, incorporated herein by reference.
   8  */
   9
  10 #include <linux/delay.h>
  11 #include <asm/cmpxchg.h>
  12 #include "net_driver.h"
  13 #include "nic.h"
  14 #include "io.h"
  15 #include "farch_regs.h"
  16 #include "mcdi_pcol.h"
  17 #include "phy.h"
  18
  19 /**************************************************************************
  20  *
  21  * Management-Controller-to-Driver Interface
  22  *
  23  **************************************************************************
  24  */
  25
  26 #define MCDI_RPC_TIMEOUT       (10 * HZ)
  27
  28 /* A reboot/assertion causes the MCDI status word to be set after the
  29  * command word is set or a REBOOT event is sent. If we notice a reboot
  30  * via these mechanisms then wait 250ms for the status word to be set.
  31  */
  32 #define MCDI_STATUS_DELAY_US            100
  33 #define MCDI_STATUS_DELAY_COUNT         2500
  34 #define MCDI_STATUS_SLEEP_MS                                            \
  35         (MCDI_STATUS_DELAY_US * MCDI_STATUS_DELAY_COUNT / 1000)
  36
  37 #define SEQ_MASK                                                        \
  38         EFX_MASK32(EFX_WIDTH(MCDI_HEADER_SEQ))
  39
  40 struct efx_mcdi_async_param {
  41         struct list_head list;
  42         unsigned int cmd;
  43         size_t inlen;
  44         size_t outlen;
  45         efx_mcdi_async_completer *complete;
  46         unsigned long cookie;
  47         /* followed by request/response buffer */
  48 };
  49
  50 static void efx_mcdi_timeout_async(unsigned long context);
  51 static int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
  52                                bool *was_attached_out);
  53 static bool efx_mcdi_poll_once(struct efx_nic *efx);
  54
  55 static inline struct efx_mcdi_iface *efx_mcdi(struct efx_nic *efx)
  56 {
  57         EFX_BUG_ON_PARANOID(!efx->mcdi);
  58         return &efx->mcdi->iface;
  59 }
  60
  61 int efx_mcdi_init(struct efx_nic *efx)
  62 {
  63         struct efx_mcdi_iface *mcdi;
  64         bool already_attached;
  65         int rc;
  66
  67         efx->mcdi = kzalloc(sizeof(*efx->mcdi), GFP_KERNEL);
  68         if (!efx->mcdi)
  69                 return -ENOMEM;
  70
  71         mcdi = efx_mcdi(efx);
  72         mcdi->efx = efx;
  73         init_waitqueue_head(&mcdi->wq);
  74         spin_lock_init(&mcdi->iface_lock);
  75         mcdi->state = MCDI_STATE_QUIESCENT;
  76         mcdi->mode = MCDI_MODE_POLL;
  77         spin_lock_init(&mcdi->async_lock);
  78         INIT_LIST_HEAD(&mcdi->async_list);
  79         setup_timer(&mcdi->async_timer, efx_mcdi_timeout_async,
  80                     (unsigned long)mcdi);
  81
  82         (void) efx_mcdi_poll_reboot(efx);
  83         mcdi->new_epoch = true;
  84
  85         /* Recover from a failed assertion before probing */
  86         rc = efx_mcdi_handle_assertion(efx);
  87         if (rc)
  88                 return rc;
  89
  90         /* Let the MC (and BMC, if this is a LOM) know that the driver
  91          * is loaded. We should do this before we reset the NIC.
  92          */
  93         rc = efx_mcdi_drv_attach(efx, true, &already_attached);
  94         if (rc) {
  95                 netif_err(efx, probe, efx->net_dev,
  96                           "Unable to register driver with MCPU\n");
  97                 return rc;
  98         }
  99         if (already_attached)
 100                 /* Not a fatal error */
 101                 netif_err(efx, probe, efx->net_dev,
 102                           "Host already registered with MCPU\n");
 103
 104         return 0;
 105 }
 106
 107 void efx_mcdi_fini(struct efx_nic *efx)
 108 {
 109         if (!efx->mcdi)
 110                 return;
 111
 112         BUG_ON(efx->mcdi->iface.state != MCDI_STATE_QUIESCENT);
 113
 114         /* Relinquish the device (back to the BMC, if this is a LOM) */
 115         efx_mcdi_drv_attach(efx, false, NULL);
 116
 117         kfree(efx->mcdi);
 118 }
 119
 120 static void efx_mcdi_send_request(struct efx_nic *efx, unsigned cmd,
 121                                   const efx_dword_t *inbuf, size_t inlen)
 122 {
 123         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 124         efx_dword_t hdr[2];
 125         size_t hdr_len;
 126         u32 xflags, seqno;
 127
 128         BUG_ON(mcdi->state == MCDI_STATE_QUIESCENT);
 129
 130         /* Serialise with efx_mcdi_ev_cpl() and efx_mcdi_ev_death() */
 131         spin_lock_bh(&mcdi->iface_lock);
 132         ++mcdi->seqno;
 133         spin_unlock_bh(&mcdi->iface_lock);
 134
 135         seqno = mcdi->seqno & SEQ_MASK;
 136         xflags = 0;
 137         if (mcdi->mode == MCDI_MODE_EVENTS)
 138                 xflags |= MCDI_HEADER_XFLAGS_EVREQ;
 139
 140         if (efx->type->mcdi_max_ver == 1) {
 141                 /* MCDI v1 */
 142                 EFX_POPULATE_DWORD_7(hdr[0],
 143                                      MCDI_HEADER_RESPONSE, 0,
 144                                      MCDI_HEADER_RESYNC, 1,
 145                                      MCDI_HEADER_CODE, cmd,
 146                                      MCDI_HEADER_DATALEN, inlen,
 147                                      MCDI_HEADER_SEQ, seqno,
 148                                      MCDI_HEADER_XFLAGS, xflags,
 149                                      MCDI_HEADER_NOT_EPOCH, !mcdi->new_epoch);
 150                 hdr_len = 4;
 151         } else {
 152                 /* MCDI v2 */
 153                 BUG_ON(inlen > MCDI_CTL_SDU_LEN_MAX_V2);
 154                 EFX_POPULATE_DWORD_7(hdr[0],
 155                                      MCDI_HEADER_RESPONSE, 0,
 156                                      MCDI_HEADER_RESYNC, 1,
 157                                      MCDI_HEADER_CODE, MC_CMD_V2_EXTN,
 158                                      MCDI_HEADER_DATALEN, 0,
 159                                      MCDI_HEADER_SEQ, seqno,
 160                                      MCDI_HEADER_XFLAGS, xflags,
 161                                      MCDI_HEADER_NOT_EPOCH, !mcdi->new_epoch);
 162                 EFX_POPULATE_DWORD_2(hdr[1],
 163                                      MC_CMD_V2_EXTN_IN_EXTENDED_CMD, cmd,
 164                                      MC_CMD_V2_EXTN_IN_ACTUAL_LEN, inlen);
 165                 hdr_len = 8;
 166         }
 167
 168         efx->type->mcdi_request(efx, hdr, hdr_len, inbuf, inlen);
 169
 170         mcdi->new_epoch = false;
 171 }
 172
 173 static int efx_mcdi_errno(unsigned int mcdi_err)
 174 {
 175         switch (mcdi_err) {
 176         case 0:
 177                 return 0;
 178 #define TRANSLATE_ERROR(name)                                   \
 179         case MC_CMD_ERR_ ## name:                               \
 180                 return -name;
 181         TRANSLATE_ERROR(EPERM);
 182         TRANSLATE_ERROR(ENOENT);
 183         TRANSLATE_ERROR(EINTR);
 184         TRANSLATE_ERROR(EAGAIN);
 185         TRANSLATE_ERROR(EACCES);
 186         TRANSLATE_ERROR(EBUSY);
 187         TRANSLATE_ERROR(EINVAL);
 188         TRANSLATE_ERROR(EDEADLK);
 189         TRANSLATE_ERROR(ENOSYS);
 190         TRANSLATE_ERROR(ETIME);
 191         TRANSLATE_ERROR(EALREADY);
 192         TRANSLATE_ERROR(ENOSPC);
 193 #undef TRANSLATE_ERROR
 194         case MC_CMD_ERR_ALLOC_FAIL:
 195                 return -ENOBUFS;
 196         case MC_CMD_ERR_MAC_EXIST:
 197                 return -EADDRINUSE;
 198         default:
 199                 return -EPROTO;
 200         }
 201 }
 202
 203 static void efx_mcdi_read_response_header(struct efx_nic *efx)
 204 {
 205         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 206         unsigned int respseq, respcmd, error;
 207         efx_dword_t hdr;
 208
 209         efx->type->mcdi_read_response(efx, &hdr, 0, 4);
 210         respseq = EFX_DWORD_FIELD(hdr, MCDI_HEADER_SEQ);
 211         respcmd = EFX_DWORD_FIELD(hdr, MCDI_HEADER_CODE);
 212         error = EFX_DWORD_FIELD(hdr, MCDI_HEADER_ERROR);
 213
 214         if (respcmd != MC_CMD_V2_EXTN) {
 215                 mcdi->resp_hdr_len = 4;
 216                 mcdi->resp_data_len = EFX_DWORD_FIELD(hdr, MCDI_HEADER_DATALEN);
 217         } else {
 218                 efx->type->mcdi_read_response(efx, &hdr, 4, 4);
 219                 mcdi->resp_hdr_len = 8;
 220                 mcdi->resp_data_len =
 221                         EFX_DWORD_FIELD(hdr, MC_CMD_V2_EXTN_IN_ACTUAL_LEN);
 222         }
 223
 224         if (error && mcdi->resp_data_len == 0) {
 225                 netif_err(efx, hw, efx->net_dev, "MC rebooted\n");
 226                 mcdi->resprc = -EIO;
 227         } else if ((respseq ^ mcdi->seqno) & SEQ_MASK) {
 228                 netif_err(efx, hw, efx->net_dev,
 229                           "MC response mismatch tx seq 0x%x rx seq 0x%x\n",
 230                           respseq, mcdi->seqno);
 231                 mcdi->resprc = -EIO;
 232         } else if (error) {
 233                 efx->type->mcdi_read_response(efx, &hdr, mcdi->resp_hdr_len, 4);
 234                 mcdi->resprc =
 235                         efx_mcdi_errno(EFX_DWORD_FIELD(hdr, EFX_DWORD_0));
 236         } else {
 237                 mcdi->resprc = 0;
 238         }
 239 }
 240
 241 static bool efx_mcdi_poll_once(struct efx_nic *efx)
 242 {
 243         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 244
 245         rmb();
 246         if (!efx->type->mcdi_poll_response(efx))
 247                 return false;
 248
 249         spin_lock_bh(&mcdi->iface_lock);
 250         efx_mcdi_read_response_header(efx);
 251         spin_unlock_bh(&mcdi->iface_lock);
 252
 253         return true;
 254 }
 255
 256 static int efx_mcdi_poll(struct efx_nic *efx)
 257 {
 258         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 259         unsigned long time, finish;
 260         unsigned int spins;
 261         int rc;
 262
 263         /* Check for a reboot atomically with respect to efx_mcdi_copyout() */
 264         rc = efx_mcdi_poll_reboot(efx);
 265         if (rc) {
 266                 spin_lock_bh(&mcdi->iface_lock);
 267                 mcdi->resprc = rc;
 268                 mcdi->resp_hdr_len = 0;
 269                 mcdi->resp_data_len = 0;
 270                 spin_unlock_bh(&mcdi->iface_lock);
 271                 return 0;
 272         }
 273
 274         /* Poll for completion. Poll quickly (once a us) for the 1st jiffy,
 275          * because generally mcdi responses are fast. After that, back off
 276          * and poll once a jiffy (approximately)
 277          */
 278         spins = TICK_USEC;
 279         finish = jiffies + MCDI_RPC_TIMEOUT;
 280
 281         while (1) {
 282                 if (spins != 0) {
 283                         --spins;
 284                         udelay(1);
 285                 } else {
 286                         schedule_timeout_uninterruptible(1);
 287                 }
 288
 289                 time = jiffies;
 290
 291                 if (efx_mcdi_poll_once(efx))
 292                         break;
 293
 294                 if (time_after(time, finish))
 295                         return -ETIMEDOUT;
 296         }
 297
 298         /* Return rc=0 like wait_event_timeout() */
 299         return 0;
 300 }
 301
 302 /* Test and clear MC-rebooted flag for this port/function; reset
 303  * software state as necessary.
 304  */
 305 int efx_mcdi_poll_reboot(struct efx_nic *efx)
 306 {
 307         if (!efx->mcdi)
 308                 return 0;
 309
 310         return efx->type->mcdi_poll_reboot(efx);
 311 }
 312
 313 static bool efx_mcdi_acquire_async(struct efx_mcdi_iface *mcdi)
 314 {
 315         return cmpxchg(&mcdi->state,
 316                        MCDI_STATE_QUIESCENT, MCDI_STATE_RUNNING_ASYNC) ==
 317                 MCDI_STATE_QUIESCENT;
 318 }
 319
 320 static void efx_mcdi_acquire_sync(struct efx_mcdi_iface *mcdi)
 321 {
 322         /* Wait until the interface becomes QUIESCENT and we win the race
 323          * to mark it RUNNING_SYNC.
 324          */
 325         wait_event(mcdi->wq,
 326                    cmpxchg(&mcdi->state,
 327                            MCDI_STATE_QUIESCENT, MCDI_STATE_RUNNING_SYNC) ==
 328                    MCDI_STATE_QUIESCENT);
 329 }
 330
 331 static int efx_mcdi_await_completion(struct efx_nic *efx)
 332 {
 333         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 334
 335         if (wait_event_timeout(mcdi->wq, mcdi->state == MCDI_STATE_COMPLETED,
 336                                MCDI_RPC_TIMEOUT) == 0)
 337                 return -ETIMEDOUT;
 338
 339         /* Check if efx_mcdi_set_mode() switched us back to polled completions.
 340          * In which case, poll for completions directly. If efx_mcdi_ev_cpl()
 341          * completed the request first, then we'll just end up completing the
 342          * request again, which is safe.
 343          *
 344          * We need an smp_rmb() to synchronise with efx_mcdi_mode_poll(), which
 345          * wait_event_timeout() implicitly provides.
 346          */
 347         if (mcdi->mode == MCDI_MODE_POLL)
 348                 return efx_mcdi_poll(efx);
 349
 350         return 0;
 351 }
 352
 353 /* If the interface is RUNNING_SYNC, switch to COMPLETED and wake the
 354  * requester.  Return whether this was done.  Does not take any locks.
 355  */
 356 static bool efx_mcdi_complete_sync(struct efx_mcdi_iface *mcdi)
 357 {
 358         if (cmpxchg(&mcdi->state,
 359                     MCDI_STATE_RUNNING_SYNC, MCDI_STATE_COMPLETED) ==
 360             MCDI_STATE_RUNNING_SYNC) {
 361                 wake_up(&mcdi->wq);
 362                 return true;
 363         }
 364
 365         return false;
 366 }
 367
 368 static void efx_mcdi_release(struct efx_mcdi_iface *mcdi)
 369 {
 370         if (mcdi->mode == MCDI_MODE_EVENTS) {
 371                 struct efx_mcdi_async_param *async;
 372                 struct efx_nic *efx = mcdi->efx;
 373
 374                 /* Process the asynchronous request queue */
 375                 spin_lock_bh(&mcdi->async_lock);
 376                 async = list_first_entry_or_null(
 377                         &mcdi->async_list, struct efx_mcdi_async_param, list);
 378                 if (async) {
 379                         mcdi->state = MCDI_STATE_RUNNING_ASYNC;
 380                         efx_mcdi_send_request(efx, async->cmd,
 381                                               (const efx_dword_t *)(async + 1),
 382                                               async->inlen);
 383                         mod_timer(&mcdi->async_timer,
 384                                   jiffies + MCDI_RPC_TIMEOUT);
 385                 }
 386                 spin_unlock_bh(&mcdi->async_lock);
 387
 388                 if (async)
 389                         return;
 390         }
 391
 392         mcdi->state = MCDI_STATE_QUIESCENT;
 393         wake_up(&mcdi->wq);
 394 }
 395
 396 /* If the interface is RUNNING_ASYNC, switch to COMPLETED, call the
 397  * asynchronous completion function, and release the interface.
 398  * Return whether this was done.  Must be called in bh-disabled
 399  * context.  Will take iface_lock and async_lock.
 400  */
 401 static bool efx_mcdi_complete_async(struct efx_mcdi_iface *mcdi, bool timeout)
 402 {
 403         struct efx_nic *efx = mcdi->efx;
 404         struct efx_mcdi_async_param *async;
 405         size_t hdr_len, data_len;
 406         efx_dword_t *outbuf;
 407         int rc;
 408
 409         if (cmpxchg(&mcdi->state,
 410                     MCDI_STATE_RUNNING_ASYNC, MCDI_STATE_COMPLETED) !=
 411             MCDI_STATE_RUNNING_ASYNC)
 412                 return false;
 413
 414         spin_lock(&mcdi->iface_lock);
 415         if (timeout) {
 416                 /* Ensure that if the completion event arrives later,
 417                  * the seqno check in efx_mcdi_ev_cpl() will fail
 418                  */
 419                 ++mcdi->seqno;
 420                 ++mcdi->credits;
 421                 rc = -ETIMEDOUT;
 422                 hdr_len = 0;
 423                 data_len = 0;
 424         } else {
 425                 rc = mcdi->resprc;
 426                 hdr_len = mcdi->resp_hdr_len;
 427                 data_len = mcdi->resp_data_len;
 428         }
 429         spin_unlock(&mcdi->iface_lock);
 430
 431         /* Stop the timer.  In case the timer function is running, we
 432          * must wait for it to return so that there is no possibility
 433          * of it aborting the next request.
 434          */
 435         if (!timeout)
 436                 del_timer_sync(&mcdi->async_timer);
 437
 438         spin_lock(&mcdi->async_lock);
 439         async = list_first_entry(&mcdi->async_list,
 440                                  struct efx_mcdi_async_param, list);
 441         list_del(&async->list);
 442         spin_unlock(&mcdi->async_lock);
 443
 444         outbuf = (efx_dword_t *)(async + 1);
 445         efx->type->mcdi_read_response(efx, outbuf, hdr_len,
 446                                       min(async->outlen, data_len));
 447         async->complete(efx, async->cookie, rc, outbuf, data_len);
 448         kfree(async);
 449
 450         efx_mcdi_release(mcdi);
 451
 452         return true;
 453 }
 454
 455 static void efx_mcdi_ev_cpl(struct efx_nic *efx, unsigned int seqno,
 456                             unsigned int datalen, unsigned int mcdi_err)
 457 {
 458         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 459         bool wake = false;
 460
 461         spin_lock(&mcdi->iface_lock);
 462
 463         if ((seqno ^ mcdi->seqno) & SEQ_MASK) {
 464                 if (mcdi->credits)
 465                         /* The request has been cancelled */
 466                         --mcdi->credits;
 467                 else
 468                         netif_err(efx, hw, efx->net_dev,
 469                                   "MC response mismatch tx seq 0x%x rx "
 470                                   "seq 0x%x\n", seqno, mcdi->seqno);
 471         } else {
 472                 if (efx->type->mcdi_max_ver >= 2) {
 473                         /* MCDI v2 responses don't fit in an event */
 474                         efx_mcdi_read_response_header(efx);
 475                 } else {
 476                         mcdi->resprc = efx_mcdi_errno(mcdi_err);
 477                         mcdi->resp_hdr_len = 4;
 478                         mcdi->resp_data_len = datalen;
 479                 }
 480
 481                 wake = true;
 482         }
 483
 484         spin_unlock(&mcdi->iface_lock);
 485
 486         if (wake) {
 487                 if (!efx_mcdi_complete_async(mcdi, false))
 488                         (void) efx_mcdi_complete_sync(mcdi);
 489
 490                 /* If the interface isn't RUNNING_ASYNC or
 491                  * RUNNING_SYNC then we've received a duplicate
 492                  * completion after we've already transitioned back to
 493                  * QUIESCENT. [A subsequent invocation would increment
 494                  * seqno, so would have failed the seqno check].
 495                  */
 496         }
 497 }
 498
 499 static void efx_mcdi_timeout_async(unsigned long context)
 500 {
 501         struct efx_mcdi_iface *mcdi = (struct efx_mcdi_iface *)context;
 502
 503         efx_mcdi_complete_async(mcdi, true);
 504 }
 505
 506 static int
 507 efx_mcdi_check_supported(struct efx_nic *efx, unsigned int cmd, size_t inlen)
 508 {
 509         if (efx->type->mcdi_max_ver < 0 ||
 510              (efx->type->mcdi_max_ver < 2 &&
 511               cmd > MC_CMD_CMD_SPACE_ESCAPE_7))
 512                 return -EINVAL;
 513
 514         if (inlen > MCDI_CTL_SDU_LEN_MAX_V2 ||
 515             (efx->type->mcdi_max_ver < 2 &&
 516              inlen > MCDI_CTL_SDU_LEN_MAX_V1))
 517                 return -EMSGSIZE;
 518
 519         return 0;
 520 }
 521
 522 int efx_mcdi_rpc(struct efx_nic *efx, unsigned cmd,
 523                  const efx_dword_t *inbuf, size_t inlen,
 524                  efx_dword_t *outbuf, size_t outlen,
 525                  size_t *outlen_actual)
 526 {
 527         int rc;
 528
 529         rc = efx_mcdi_rpc_start(efx, cmd, inbuf, inlen);
 530         if (rc)
 531                 return rc;
 532         return efx_mcdi_rpc_finish(efx, cmd, inlen,
 533                                    outbuf, outlen, outlen_actual);
 534 }
 535
 536 int efx_mcdi_rpc_start(struct efx_nic *efx, unsigned cmd,
 537                        const efx_dword_t *inbuf, size_t inlen)
 538 {
 539         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 540         int rc;
 541
 542         rc = efx_mcdi_check_supported(efx, cmd, inlen);
 543         if (rc)
 544                 return rc;
 545
 546         if (efx->mc_bist_for_other_fn)
 547                 return -ENETDOWN;
 548
 549         efx_mcdi_acquire_sync(mcdi);
 550         efx_mcdi_send_request(efx, cmd, inbuf, inlen);
 551         return 0;
 552 }
 553
 554 /**
 555  * efx_mcdi_rpc_async - Schedule an MCDI command to run asynchronously
 556  * @efx: NIC through which to issue the command
 557  * @cmd: Command type number
 558  * @inbuf: Command parameters
 559  * @inlen: Length of command parameters, in bytes
 560  * @outlen: Length to allocate for response buffer, in bytes
 561  * @complete: Function to be called on completion or cancellation.
 562  * @cookie: Arbitrary value to be passed to @complete.
 563  *
 564  * This function does not sleep and therefore may be called in atomic
 565  * context.  It will fail if event queues are disabled or if MCDI
 566  * event completions have been disabled due to an error.
 567  *
 568  * If it succeeds, the @complete function will be called exactly once
 569  * in atomic context, when one of the following occurs:
 570  * (a) the completion event is received (in NAPI context)
 571  * (b) event queues are disabled (in the process that disables them)
 572  * (c) the request times-out (in timer context)
 573  */
 574 int
 575 efx_mcdi_rpc_async(struct efx_nic *efx, unsigned int cmd,
 576                    const efx_dword_t *inbuf, size_t inlen, size_t outlen,
 577                    efx_mcdi_async_completer *complete, unsigned long cookie)
 578 {
 579         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 580         struct efx_mcdi_async_param *async;
 581         int rc;
 582
 583         rc = efx_mcdi_check_supported(efx, cmd, inlen);
 584         if (rc)
 585                 return rc;
 586
 587         if (efx->mc_bist_for_other_fn)
 588                 return -ENETDOWN;
 589
 590         async = kmalloc(sizeof(*async) + ALIGN(max(inlen, outlen), 4),
 591                         GFP_ATOMIC);
 592         if (!async)
 593                 return -ENOMEM;
 594
 595         async->cmd = cmd;
 596         async->inlen = inlen;
 597         async->outlen = outlen;
 598         async->complete = complete;
 599         async->cookie = cookie;
 600         memcpy(async + 1, inbuf, inlen);
 601
 602         spin_lock_bh(&mcdi->async_lock);
 603
 604         if (mcdi->mode == MCDI_MODE_EVENTS) {
 605                 list_add_tail(&async->list, &mcdi->async_list);
 606
 607                 /* If this is at the front of the queue, try to start it
 608                  * immediately
 609                  */
 610                 if (mcdi->async_list.next == &async->list &&
 611                     efx_mcdi_acquire_async(mcdi)) {
 612                         efx_mcdi_send_request(efx, cmd, inbuf, inlen);
 613                         mod_timer(&mcdi->async_timer,
 614                                   jiffies + MCDI_RPC_TIMEOUT);
 615                 }
 616         } else {
 617                 kfree(async);
 618                 rc = -ENETDOWN;
 619         }
 620
 621         spin_unlock_bh(&mcdi->async_lock);
 622
 623         return rc;
 624 }
 625
 626 int efx_mcdi_rpc_finish(struct efx_nic *efx, unsigned cmd, size_t inlen,
 627                         efx_dword_t *outbuf, size_t outlen,
 628                         size_t *outlen_actual)
 629 {
 630         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 631         int rc;
 632
 633         if (mcdi->mode == MCDI_MODE_POLL)
 634                 rc = efx_mcdi_poll(efx);
 635         else
 636                 rc = efx_mcdi_await_completion(efx);
 637
 638         if (rc != 0) {
 639                 netif_err(efx, hw, efx->net_dev,
 640                           "MC command 0x%x inlen %d mode %d timed out\n",
 641                           cmd, (int)inlen, mcdi->mode);
 642
 643                 if (mcdi->mode == MCDI_MODE_EVENTS && efx_mcdi_poll_once(efx)) {
 644                         netif_err(efx, hw, efx->net_dev,
 645                                   "MCDI request was completed without an event\n");
 646                         rc = 0;
 647                 }
 648
 649                 /* Close the race with efx_mcdi_ev_cpl() executing just too late
 650                  * and completing a request we've just cancelled, by ensuring
 651                  * that the seqno check therein fails.
 652                  */
 653                 spin_lock_bh(&mcdi->iface_lock);
 654                 ++mcdi->seqno;
 655                 ++mcdi->credits;
 656                 spin_unlock_bh(&mcdi->iface_lock);
 657         }
 658
 659         if (rc == 0) {
 660                 size_t hdr_len, data_len;
 661
 662                 /* At the very least we need a memory barrier here to ensure
 663                  * we pick up changes from efx_mcdi_ev_cpl(). Protect against
 664                  * a spurious efx_mcdi_ev_cpl() running concurrently by
 665                  * acquiring the iface_lock. */
 666                 spin_lock_bh(&mcdi->iface_lock);
 667                 rc = mcdi->resprc;
 668                 hdr_len = mcdi->resp_hdr_len;
 669                 data_len = mcdi->resp_data_len;
 670                 spin_unlock_bh(&mcdi->iface_lock);
 671
 672                 BUG_ON(rc > 0);
 673
 674                 if (rc == 0) {
 675                         efx->type->mcdi_read_response(efx, outbuf, hdr_len,
 676                                                       min(outlen, data_len));
 677                         if (outlen_actual != NULL)
 678                                 *outlen_actual = data_len;
 679                 } else if (cmd == MC_CMD_REBOOT && rc == -EIO)
 680                         ; /* Don't reset if MC_CMD_REBOOT returns EIO */
 681                 else if (rc == -EIO || rc == -EINTR) {
 682                         netif_err(efx, hw, efx->net_dev, "MC fatal error %d\n",
 683                                   -rc);
 684                         efx_schedule_reset(efx, RESET_TYPE_MC_FAILURE);
 685                 } else
 686                         netif_dbg(efx, hw, efx->net_dev,
 687                                   "MC command 0x%x inlen %d failed rc=%d\n",
 688                                   cmd, (int)inlen, -rc);
 689
 690                 if (rc == -EIO || rc == -EINTR) {
 691                         msleep(MCDI_STATUS_SLEEP_MS);
 692                         efx_mcdi_poll_reboot(efx);
 693                         mcdi->new_epoch = true;
 694                 }
 695         }
 696
 697         efx_mcdi_release(mcdi);
 698         return rc;
 699 }
 700
 701 /* Switch to polled MCDI completions.  This can be called in various
 702  * error conditions with various locks held, so it must be lockless.
 703  * Caller is responsible for flushing asynchronous requests later.
 704  */
 705 void efx_mcdi_mode_poll(struct efx_nic *efx)
 706 {
 707         struct efx_mcdi_iface *mcdi;
 708
 709         if (!efx->mcdi)
 710                 return;
 711
 712         mcdi = efx_mcdi(efx);
 713         if (mcdi->mode == MCDI_MODE_POLL)
 714                 return;
 715
 716         /* We can switch from event completion to polled completion, because
 717          * mcdi requests are always completed in shared memory. We do this by
 718          * switching the mode to POLL'd then completing the request.
 719          * efx_mcdi_await_completion() will then call efx_mcdi_poll().
 720          *
 721          * We need an smp_wmb() to synchronise with efx_mcdi_await_completion(),
 722          * which efx_mcdi_complete_sync() provides for us.
 723          */
 724         mcdi->mode = MCDI_MODE_POLL;
 725
 726         efx_mcdi_complete_sync(mcdi);
 727 }
 728
 729 /* Flush any running or queued asynchronous requests, after event processing
 730  * is stopped
 731  */
 732 void efx_mcdi_flush_async(struct efx_nic *efx)
 733 {
 734         struct efx_mcdi_async_param *async, *next;
 735         struct efx_mcdi_iface *mcdi;
 736
 737         if (!efx->mcdi)
 738                 return;
 739
 740         mcdi = efx_mcdi(efx);
 741
 742         /* We must be in polling mode so no more requests can be queued */
 743         BUG_ON(mcdi->mode != MCDI_MODE_POLL);
 744
 745         del_timer_sync(&mcdi->async_timer);
 746
 747         /* If a request is still running, make sure we give the MC
 748          * time to complete it so that the response won't overwrite our
 749          * next request.
 750          */
 751         if (mcdi->state == MCDI_STATE_RUNNING_ASYNC) {
 752                 efx_mcdi_poll(efx);
 753                 mcdi->state = MCDI_STATE_QUIESCENT;
 754         }
 755
 756         /* Nothing else will access the async list now, so it is safe
 757          * to walk it without holding async_lock.  If we hold it while
 758          * calling a completer then lockdep may warn that we have
 759          * acquired locks in the wrong order.
 760          */
 761         list_for_each_entry_safe(async, next, &mcdi->async_list, list) {
 762                 async->complete(efx, async->cookie, -ENETDOWN, NULL, 0);
 763                 list_del(&async->list);
 764                 kfree(async);
 765         }
 766 }
 767
 768 void efx_mcdi_mode_event(struct efx_nic *efx)
 769 {
 770         struct efx_mcdi_iface *mcdi;
 771
 772         if (!efx->mcdi)
 773                 return;
 774
 775         mcdi = efx_mcdi(efx);
 776
 777         if (mcdi->mode == MCDI_MODE_EVENTS)
 778                 return;
 779
 780         /* We can't switch from polled to event completion in the middle of a
 781          * request, because the completion method is specified in the request.
 782          * So acquire the interface to serialise the requestors. We don't need
 783          * to acquire the iface_lock to change the mode here, but we do need a
 784          * write memory barrier ensure that efx_mcdi_rpc() sees it, which
 785          * efx_mcdi_acquire() provides.
 786          */
 787         efx_mcdi_acquire_sync(mcdi);
 788         mcdi->mode = MCDI_MODE_EVENTS;
 789         efx_mcdi_release(mcdi);
 790 }
 791
 792 static void efx_mcdi_ev_death(struct efx_nic *efx, int rc)
 793 {
 794         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 795
 796         /* If there is an outstanding MCDI request, it has been terminated
 797          * either by a BADASSERT or REBOOT event. If the mcdi interface is
 798          * in polled mode, then do nothing because the MC reboot handler will
 799          * set the header correctly. However, if the mcdi interface is waiting
 800          * for a CMDDONE event it won't receive it [and since all MCDI events
 801          * are sent to the same queue, we can't be racing with
 802          * efx_mcdi_ev_cpl()]
 803          *
 804          * If there is an outstanding asynchronous request, we can't
 805          * complete it now (efx_mcdi_complete() would deadlock).  The
 806          * reset process will take care of this.
 807          *
 808          * There's a race here with efx_mcdi_send_request(), because
 809          * we might receive a REBOOT event *before* the request has
 810          * been copied out. In polled mode (during startup) this is
 811          * irrelevant, because efx_mcdi_complete_sync() is ignored. In
 812          * event mode, this condition is just an edge-case of
 813          * receiving a REBOOT event after posting the MCDI
 814          * request. Did the mc reboot before or after the copyout? The
 815          * best we can do always is just return failure.
 816          */
 817         spin_lock(&mcdi->iface_lock);
 818         if (efx_mcdi_complete_sync(mcdi)) {
 819                 if (mcdi->mode == MCDI_MODE_EVENTS) {
 820                         mcdi->resprc = rc;
 821                         mcdi->resp_hdr_len = 0;
 822                         mcdi->resp_data_len = 0;
 823                         ++mcdi->credits;
 824                 }
 825         } else {
 826                 int count;
 827
 828                 /* Consume the status word since efx_mcdi_rpc_finish() won't */
 829                 for (count = 0; count < MCDI_STATUS_DELAY_COUNT; ++count) {
 830                         if (efx_mcdi_poll_reboot(efx))
 831                                 break;
 832                         udelay(MCDI_STATUS_DELAY_US);
 833                 }
 834                 mcdi->new_epoch = true;
 835
 836                 /* Nobody was waiting for an MCDI request, so trigger a reset */
 837                 efx_schedule_reset(efx, RESET_TYPE_MC_FAILURE);
 838         }
 839
 840         spin_unlock(&mcdi->iface_lock);
 841 }
 842
 843 /* The MC is going down in to BIST mode. set the BIST flag to block
 844  * new MCDI, cancel any outstanding MCDI and and schedule a BIST-type reset
 845  * (which doesn't actually execute a reset, it waits for the controlling
 846  * function to reset it).
 847  */
 848 static void efx_mcdi_ev_bist(struct efx_nic *efx)
 849 {
 850         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
 851
 852         spin_lock(&mcdi->iface_lock);
 853         efx->mc_bist_for_other_fn = true;
 854         if (efx_mcdi_complete_sync(mcdi)) {
 855                 if (mcdi->mode == MCDI_MODE_EVENTS) {
 856                         mcdi->resprc = -EIO;
 857                         mcdi->resp_hdr_len = 0;
 858                         mcdi->resp_data_len = 0;
 859                         ++mcdi->credits;
 860                 }
 861         }
 862         mcdi->new_epoch = true;
 863         efx_schedule_reset(efx, RESET_TYPE_MC_BIST);
 864         spin_unlock(&mcdi->iface_lock);
 865 }
 866
 867 /* Called from  falcon_process_eventq for MCDI events */
 868 void efx_mcdi_process_event(struct efx_channel *channel,
 869                             efx_qword_t *event)
 870 {
 871         struct efx_nic *efx = channel->efx;
 872         int code = EFX_QWORD_FIELD(*event, MCDI_EVENT_CODE);
 873         u32 data = EFX_QWORD_FIELD(*event, MCDI_EVENT_DATA);
 874
 875         switch (code) {
 876         case MCDI_EVENT_CODE_BADSSERT:
 877                 netif_err(efx, hw, efx->net_dev,
 878                           "MC watchdog or assertion failure at 0x%x\n", data);
 879                 efx_mcdi_ev_death(efx, -EINTR);
 880                 break;
 881
 882         case MCDI_EVENT_CODE_PMNOTICE:
 883                 netif_info(efx, wol, efx->net_dev, "MCDI PM event.\n");
 884                 break;
 885
 886         case MCDI_EVENT_CODE_CMDDONE:
 887                 efx_mcdi_ev_cpl(efx,
 888                                 MCDI_EVENT_FIELD(*event, CMDDONE_SEQ),
 889                                 MCDI_EVENT_FIELD(*event, CMDDONE_DATALEN),
 890                                 MCDI_EVENT_FIELD(*event, CMDDONE_ERRNO));
 891                 break;
 892
 893         case MCDI_EVENT_CODE_LINKCHANGE:
 894                 efx_mcdi_process_link_change(efx, event);
 895                 break;
 896         case MCDI_EVENT_CODE_SENSOREVT:
 897                 efx_mcdi_sensor_event(efx, event);
 898                 break;
 899         case MCDI_EVENT_CODE_SCHEDERR:
 900                 netif_dbg(efx, hw, efx->net_dev,
 901                           "MC Scheduler alert (0x%x)\n", data);
 902                 break;
 903         case MCDI_EVENT_CODE_REBOOT:
 904         case MCDI_EVENT_CODE_MC_REBOOT:
 905                 netif_info(efx, hw, efx->net_dev, "MC Reboot\n");
 906                 efx_mcdi_ev_death(efx, -EIO);
 907                 break;
 908         case MCDI_EVENT_CODE_MC_BIST:
 909                 netif_info(efx, hw, efx->net_dev, "MC entered BIST mode\n");
 910                 efx_mcdi_ev_bist(efx);
 911                 break;
 912         case MCDI_EVENT_CODE_MAC_STATS_DMA:
 913                 /* MAC stats are gather lazily.  We can ignore this. */
 914                 break;
 915         case MCDI_EVENT_CODE_FLR:
 916                 efx_sriov_flr(efx, MCDI_EVENT_FIELD(*event, FLR_VF));
 917                 break;
 918         case MCDI_EVENT_CODE_PTP_RX:
 919         case MCDI_EVENT_CODE_PTP_FAULT:
 920         case MCDI_EVENT_CODE_PTP_PPS:
 921                 efx_ptp_event(efx, event);
 922                 break;
 923         case MCDI_EVENT_CODE_TX_FLUSH:
 924         case MCDI_EVENT_CODE_RX_FLUSH:
 925                 /* Two flush events will be sent: one to the same event
 926                  * queue as completions, and one to event queue 0.
 927                  * In the latter case the {RX,TX}_FLUSH_TO_DRIVER
 928                  * flag will be set, and we should ignore the event
 929                  * because we want to wait for all completions.
 930                  */
 931                 BUILD_BUG_ON(MCDI_EVENT_TX_FLUSH_TO_DRIVER_LBN !=
 932                              MCDI_EVENT_RX_FLUSH_TO_DRIVER_LBN);
 933                 if (!MCDI_EVENT_FIELD(*event, TX_FLUSH_TO_DRIVER))
 934                         efx_ef10_handle_drain_event(efx);
 935                 break;
 936         case MCDI_EVENT_CODE_TX_ERR:
 937         case MCDI_EVENT_CODE_RX_ERR:
 938                 netif_err(efx, hw, efx->net_dev,
 939                           "%s DMA error (event: "EFX_QWORD_FMT")\n",
 940                           code == MCDI_EVENT_CODE_TX_ERR ? "TX" : "RX",
 941                           EFX_QWORD_VAL(*event));
 942                 efx_schedule_reset(efx, RESET_TYPE_DMA_ERROR);
 943                 break;
 944         default:
 945                 netif_err(efx, hw, efx->net_dev, "Unknown MCDI event 0x%x\n",
 946                           code);
 947         }
 948 }
 949
 950 /**************************************************************************
 951  *
 952  * Specific request functions
 953  *
 954  **************************************************************************
 955  */
 956
 957 void efx_mcdi_print_fwver(struct efx_nic *efx, char *buf, size_t len)
 958 {
 959         MCDI_DECLARE_BUF(outbuf,
 960                          max(MC_CMD_GET_VERSION_OUT_LEN,
 961                              MC_CMD_GET_CAPABILITIES_OUT_LEN));
 962         size_t outlength;
 963         const __le16 *ver_words;
 964         size_t offset;
 965         int rc;
 966
 967         BUILD_BUG_ON(MC_CMD_GET_VERSION_IN_LEN != 0);
 968         rc = efx_mcdi_rpc(efx, MC_CMD_GET_VERSION, NULL, 0,
 969                           outbuf, sizeof(outbuf), &outlength);
 970         if (rc)
 971                 goto fail;
 972         if (outlength < MC_CMD_GET_VERSION_OUT_LEN) {
 973                 rc = -EIO;
 974                 goto fail;
 975         }
 976
 977         ver_words = (__le16 *)MCDI_PTR(outbuf, GET_VERSION_OUT_VERSION);
 978         offset = snprintf(buf, len, "%u.%u.%u.%u",
 979                           le16_to_cpu(ver_words[0]), le16_to_cpu(ver_words[1]),
 980                           le16_to_cpu(ver_words[2]), le16_to_cpu(ver_words[3]));
 981
 982         /* EF10 may have multiple datapath firmware variants within a
 983          * single version.  Report which variants are running.
 984          */
 985         if (efx_nic_rev(efx) >= EFX_REV_HUNT_A0) {
 986                 BUILD_BUG_ON(MC_CMD_GET_CAPABILITIES_IN_LEN != 0);
 987                 rc = efx_mcdi_rpc(efx, MC_CMD_GET_CAPABILITIES, NULL, 0,
 988                                   outbuf, sizeof(outbuf), &outlength);
 989                 if (rc || outlength < MC_CMD_GET_CAPABILITIES_OUT_LEN)
 990                         offset += snprintf(
 991                                 buf + offset, len - offset, " rx? tx?");
 992                 else
 993                         offset += snprintf(
 994                                 buf + offset, len - offset, " rx%x tx%x",
 995                                 MCDI_WORD(outbuf,
 996                                           GET_CAPABILITIES_OUT_RX_DPCPU_FW_ID),
 997                                 MCDI_WORD(outbuf,
 998                                           GET_CAPABILITIES_OUT_TX_DPCPU_FW_ID));
 999
1000                 /* It's theoretically possible for the string to exceed 31
1001                  * characters, though in practice the first three version
1002                  * components are short enough that this doesn't happen.
1003                  */
1004                 if (WARN_ON(offset >= len))
1005                         buf[0] = 0;
1006         }
1007
1008         return;
1009
1010 fail:
1011         netif_err(efx, probe, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1012         buf[0] = 0;
1013 }
1014
1015 static int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
1016                                bool *was_attached)
1017 {
1018         MCDI_DECLARE_BUF(inbuf, MC_CMD_DRV_ATTACH_IN_LEN);
1019         MCDI_DECLARE_BUF(outbuf, MC_CMD_DRV_ATTACH_EXT_OUT_LEN);
1020         size_t outlen;
1021         int rc;
1022
1023         MCDI_SET_DWORD(inbuf, DRV_ATTACH_IN_NEW_STATE,
1024                        driver_operating ? 1 : 0);
1025         MCDI_SET_DWORD(inbuf, DRV_ATTACH_IN_UPDATE, 1);
1026         MCDI_SET_DWORD(inbuf, DRV_ATTACH_IN_FIRMWARE_ID, MC_CMD_FW_LOW_LATENCY);
1027
1028         rc = efx_mcdi_rpc(efx, MC_CMD_DRV_ATTACH, inbuf, sizeof(inbuf),
1029                           outbuf, sizeof(outbuf), &outlen);
1030         if (rc)
1031                 goto fail;
1032         if (outlen < MC_CMD_DRV_ATTACH_OUT_LEN) {
1033                 rc = -EIO;
1034                 goto fail;
1035         }
1036
1037         /* We currently assume we have control of the external link
1038          * and are completely trusted by firmware.  Abort probing
1039          * if that's not true for this function.
1040          */
1041         if (driver_operating &&
1042             outlen >= MC_CMD_DRV_ATTACH_EXT_OUT_LEN &&
1043             (MCDI_DWORD(outbuf, DRV_ATTACH_EXT_OUT_FUNC_FLAGS) &
1044              (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_LINKCTRL |
1045               1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_TRUSTED)) !=
1046             (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_LINKCTRL |
1047              1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_TRUSTED)) {
1048                 netif_err(efx, probe, efx->net_dev,
1049                           "This driver version only supports one function per port\n");
1050                 return -ENODEV;
1051         }
1052
1053         if (was_attached != NULL)
1054                 *was_attached = MCDI_DWORD(outbuf, DRV_ATTACH_OUT_OLD_STATE);
1055         return 0;
1056
1057 fail:
1058         netif_err(efx, probe, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1059         return rc;
1060 }
1061
1062 int efx_mcdi_get_board_cfg(struct efx_nic *efx, u8 *mac_address,
1063                            u16 *fw_subtype_list, u32 *capabilities)
1064 {
1065         MCDI_DECLARE_BUF(outbuf, MC_CMD_GET_BOARD_CFG_OUT_LENMAX);
1066         size_t outlen, i;
1067         int port_num = efx_port_num(efx);
1068         int rc;
1069
1070         BUILD_BUG_ON(MC_CMD_GET_BOARD_CFG_IN_LEN != 0);
1071
1072         rc = efx_mcdi_rpc(efx, MC_CMD_GET_BOARD_CFG, NULL, 0,
1073                           outbuf, sizeof(outbuf), &outlen);
1074         if (rc)
1075                 goto fail;
1076
1077         if (outlen < MC_CMD_GET_BOARD_CFG_OUT_LENMIN) {
1078                 rc = -EIO;
1079                 goto fail;
1080         }
1081
1082         if (mac_address)
1083                 memcpy(mac_address,
1084                        port_num ?
1085                        MCDI_PTR(outbuf, GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT1) :
1086                        MCDI_PTR(outbuf, GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT0),
1087                        ETH_ALEN);
1088         if (fw_subtype_list) {
1089                 for (i = 0;
1090                      i < MCDI_VAR_ARRAY_LEN(outlen,
1091                                             GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST);
1092                      i++)
1093                         fw_subtype_list[i] = MCDI_ARRAY_WORD(
1094                                 outbuf, GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST, i);
1095                 for (; i < MC_CMD_GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST_MAXNUM; i++)
1096                         fw_subtype_list[i] = 0;
1097         }
1098         if (capabilities) {
1099                 if (port_num)
1100                         *capabilities = MCDI_DWORD(outbuf,
1101                                         GET_BOARD_CFG_OUT_CAPABILITIES_PORT1);
1102                 else
1103                         *capabilities = MCDI_DWORD(outbuf,
1104                                         GET_BOARD_CFG_OUT_CAPABILITIES_PORT0);
1105         }
1106
1107         return 0;
1108
1109 fail:
1110         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d len=%d\n",
1111                   __func__, rc, (int)outlen);
1112
1113         return rc;
1114 }
1115
1116 int efx_mcdi_log_ctrl(struct efx_nic *efx, bool evq, bool uart, u32 dest_evq)
1117 {
1118         MCDI_DECLARE_BUF(inbuf, MC_CMD_LOG_CTRL_IN_LEN);
1119         u32 dest = 0;
1120         int rc;
1121
1122         if (uart)
1123                 dest |= MC_CMD_LOG_CTRL_IN_LOG_DEST_UART;
1124         if (evq)
1125                 dest |= MC_CMD_LOG_CTRL_IN_LOG_DEST_EVQ;
1126
1127         MCDI_SET_DWORD(inbuf, LOG_CTRL_IN_LOG_DEST, dest);
1128         MCDI_SET_DWORD(inbuf, LOG_CTRL_IN_LOG_DEST_EVQ, dest_evq);
1129
1130         BUILD_BUG_ON(MC_CMD_LOG_CTRL_OUT_LEN != 0);
1131
1132         rc = efx_mcdi_rpc(efx, MC_CMD_LOG_CTRL, inbuf, sizeof(inbuf),
1133                           NULL, 0, NULL);
1134         if (rc)
1135                 goto fail;
1136
1137         return 0;
1138
1139 fail:
1140         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1141         return rc;
1142 }
1143
1144 int efx_mcdi_nvram_types(struct efx_nic *efx, u32 *nvram_types_out)
1145 {
1146         MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_TYPES_OUT_LEN);
1147         size_t outlen;
1148         int rc;
1149
1150         BUILD_BUG_ON(MC_CMD_NVRAM_TYPES_IN_LEN != 0);
1151
1152         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_TYPES, NULL, 0,
1153                           outbuf, sizeof(outbuf), &outlen);
1154         if (rc)
1155                 goto fail;
1156         if (outlen < MC_CMD_NVRAM_TYPES_OUT_LEN) {
1157                 rc = -EIO;
1158                 goto fail;
1159         }
1160
1161         *nvram_types_out = MCDI_DWORD(outbuf, NVRAM_TYPES_OUT_TYPES);
1162         return 0;
1163
1164 fail:
1165         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
1166                   __func__, rc);
1167         return rc;
1168 }
1169
1170 int efx_mcdi_nvram_info(struct efx_nic *efx, unsigned int type,
1171                         size_t *size_out, size_t *erase_size_out,
1172                         bool *protected_out)
1173 {
1174         MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_INFO_IN_LEN);
1175         MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_INFO_OUT_LEN);
1176         size_t outlen;
1177         int rc;
1178
1179         MCDI_SET_DWORD(inbuf, NVRAM_INFO_IN_TYPE, type);
1180
1181         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_INFO, inbuf, sizeof(inbuf),
1182                           outbuf, sizeof(outbuf), &outlen);
1183         if (rc)
1184                 goto fail;
1185         if (outlen < MC_CMD_NVRAM_INFO_OUT_LEN) {
1186                 rc = -EIO;
1187                 goto fail;
1188         }
1189
1190         *size_out = MCDI_DWORD(outbuf, NVRAM_INFO_OUT_SIZE);
1191         *erase_size_out = MCDI_DWORD(outbuf, NVRAM_INFO_OUT_ERASESIZE);
1192         *protected_out = !!(MCDI_DWORD(outbuf, NVRAM_INFO_OUT_FLAGS) &
1193                                 (1 << MC_CMD_NVRAM_INFO_OUT_PROTECTED_LBN));
1194         return 0;
1195
1196 fail:
1197         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1198         return rc;
1199 }
1200
1201 static int efx_mcdi_nvram_test(struct efx_nic *efx, unsigned int type)
1202 {
1203         MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_TEST_IN_LEN);
1204         MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_TEST_OUT_LEN);
1205         int rc;
1206
1207         MCDI_SET_DWORD(inbuf, NVRAM_TEST_IN_TYPE, type);
1208
1209         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_TEST, inbuf, sizeof(inbuf),
1210                           outbuf, sizeof(outbuf), NULL);
1211         if (rc)
1212                 return rc;
1213
1214         switch (MCDI_DWORD(outbuf, NVRAM_TEST_OUT_RESULT)) {
1215         case MC_CMD_NVRAM_TEST_PASS:
1216         case MC_CMD_NVRAM_TEST_NOTSUPP:
1217                 return 0;
1218         default:
1219                 return -EIO;
1220         }
1221 }
1222
1223 int efx_mcdi_nvram_test_all(struct efx_nic *efx)
1224 {
1225         u32 nvram_types;
1226         unsigned int type;
1227         int rc;
1228
1229         rc = efx_mcdi_nvram_types(efx, &nvram_types);
1230         if (rc)
1231                 goto fail1;
1232
1233         type = 0;
1234         while (nvram_types != 0) {
1235                 if (nvram_types & 1) {
1236                         rc = efx_mcdi_nvram_test(efx, type);
1237                         if (rc)
1238                                 goto fail2;
1239                 }
1240                 type++;
1241                 nvram_types >>= 1;
1242         }
1243
1244         return 0;
1245
1246 fail2:
1247         netif_err(efx, hw, efx->net_dev, "%s: failed type=%u\n",
1248                   __func__, type);
1249 fail1:
1250         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1251         return rc;
1252 }
1253
1254 static int efx_mcdi_read_assertion(struct efx_nic *efx)
1255 {
1256         MCDI_DECLARE_BUF(inbuf, MC_CMD_GET_ASSERTS_IN_LEN);
1257         MCDI_DECLARE_BUF(outbuf, MC_CMD_GET_ASSERTS_OUT_LEN);
1258         unsigned int flags, index;
1259         const char *reason;
1260         size_t outlen;
1261         int retry;
1262         int rc;
1263
1264         /* Attempt to read any stored assertion state before we reboot
1265          * the mcfw out of the assertion handler. Retry twice, once
1266          * because a boot-time assertion might cause this command to fail
1267          * with EINTR. And once again because GET_ASSERTS can race with
1268          * MC_CMD_REBOOT running on the other port. */
1269         retry = 2;
1270         do {
1271                 MCDI_SET_DWORD(inbuf, GET_ASSERTS_IN_CLEAR, 1);
1272                 rc = efx_mcdi_rpc(efx, MC_CMD_GET_ASSERTS,
1273                                   inbuf, MC_CMD_GET_ASSERTS_IN_LEN,
1274                                   outbuf, sizeof(outbuf), &outlen);
1275         } while ((rc == -EINTR || rc == -EIO) && retry-- > 0);
1276
1277         if (rc)
1278                 return rc;
1279         if (outlen < MC_CMD_GET_ASSERTS_OUT_LEN)
1280                 return -EIO;
1281
1282         /* Print out any recorded assertion state */
1283         flags = MCDI_DWORD(outbuf, GET_ASSERTS_OUT_GLOBAL_FLAGS);
1284         if (flags == MC_CMD_GET_ASSERTS_FLAGS_NO_FAILS)
1285                 return 0;
1286
1287         reason = (flags == MC_CMD_GET_ASSERTS_FLAGS_SYS_FAIL)
1288                 ? "system-level assertion"
1289                 : (flags == MC_CMD_GET_ASSERTS_FLAGS_THR_FAIL)
1290                 ? "thread-level assertion"
1291                 : (flags == MC_CMD_GET_ASSERTS_FLAGS_WDOG_FIRED)
1292                 ? "watchdog reset"
1293                 : "unknown assertion";
1294         netif_err(efx, hw, efx->net_dev,
1295                   "MCPU %s at PC = 0x%.8x in thread 0x%.8x\n", reason,
1296                   MCDI_DWORD(outbuf, GET_ASSERTS_OUT_SAVED_PC_OFFS),
1297                   MCDI_DWORD(outbuf, GET_ASSERTS_OUT_THREAD_OFFS));
1298
1299         /* Print out the registers */
1300         for (index = 0;
1301              index < MC_CMD_GET_ASSERTS_OUT_GP_REGS_OFFS_NUM;
1302              index++)
1303                 netif_err(efx, hw, efx->net_dev, "R%.2d (?): 0x%.8x\n",
1304                           1 + index,
1305                           MCDI_ARRAY_DWORD(outbuf, GET_ASSERTS_OUT_GP_REGS_OFFS,
1306                                            index));
1307
1308         return 0;
1309 }
1310
1311 static void efx_mcdi_exit_assertion(struct efx_nic *efx)
1312 {
1313         MCDI_DECLARE_BUF(inbuf, MC_CMD_REBOOT_IN_LEN);
1314
1315         /* If the MC is running debug firmware, it might now be
1316          * waiting for a debugger to attach, but we just want it to
1317          * reboot.  We set a flag that makes the command a no-op if it
1318          * has already done so.  We don't know what return code to
1319          * expect (0 or -EIO), so ignore it.
1320          */
1321         BUILD_BUG_ON(MC_CMD_REBOOT_OUT_LEN != 0);
1322         MCDI_SET_DWORD(inbuf, REBOOT_IN_FLAGS,
1323                        MC_CMD_REBOOT_FLAGS_AFTER_ASSERTION);
1324         (void) efx_mcdi_rpc(efx, MC_CMD_REBOOT, inbuf, MC_CMD_REBOOT_IN_LEN,
1325                             NULL, 0, NULL);
1326 }
1327
1328 int efx_mcdi_handle_assertion(struct efx_nic *efx)
1329 {
1330         int rc;
1331
1332         rc = efx_mcdi_read_assertion(efx);
1333         if (rc)
1334                 return rc;
1335
1336         efx_mcdi_exit_assertion(efx);
1337
1338         return 0;
1339 }
1340
1341 void efx_mcdi_set_id_led(struct efx_nic *efx, enum efx_led_mode mode)
1342 {
1343         MCDI_DECLARE_BUF(inbuf, MC_CMD_SET_ID_LED_IN_LEN);
1344         int rc;
1345
1346         BUILD_BUG_ON(EFX_LED_OFF != MC_CMD_LED_OFF);
1347         BUILD_BUG_ON(EFX_LED_ON != MC_CMD_LED_ON);
1348         BUILD_BUG_ON(EFX_LED_DEFAULT != MC_CMD_LED_DEFAULT);
1349
1350         BUILD_BUG_ON(MC_CMD_SET_ID_LED_OUT_LEN != 0);
1351
1352         MCDI_SET_DWORD(inbuf, SET_ID_LED_IN_STATE, mode);
1353
1354         rc = efx_mcdi_rpc(efx, MC_CMD_SET_ID_LED, inbuf, sizeof(inbuf),
1355                           NULL, 0, NULL);
1356         if (rc)
1357                 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
1358                           __func__, rc);
1359 }
1360
1361 static int efx_mcdi_reset_port(struct efx_nic *efx)
1362 {
1363         int rc = efx_mcdi_rpc(efx, MC_CMD_ENTITY_RESET, NULL, 0, NULL, 0, NULL);
1364         if (rc)
1365                 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
1366                           __func__, rc);
1367         return rc;
1368 }
1369
1370 static int efx_mcdi_reset_mc(struct efx_nic *efx)
1371 {
1372         MCDI_DECLARE_BUF(inbuf, MC_CMD_REBOOT_IN_LEN);
1373         int rc;
1374
1375         BUILD_BUG_ON(MC_CMD_REBOOT_OUT_LEN != 0);
1376         MCDI_SET_DWORD(inbuf, REBOOT_IN_FLAGS, 0);
1377         rc = efx_mcdi_rpc(efx, MC_CMD_REBOOT, inbuf, sizeof(inbuf),
1378                           NULL, 0, NULL);
1379         /* White is black, and up is down */
1380         if (rc == -EIO)
1381                 return 0;
1382         if (rc == 0)
1383                 rc = -EIO;
1384         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1385         return rc;
1386 }
1387
1388 enum reset_type efx_mcdi_map_reset_reason(enum reset_type reason)
1389 {
1390         return RESET_TYPE_RECOVER_OR_ALL;
1391 }
1392
1393 int efx_mcdi_reset(struct efx_nic *efx, enum reset_type method)
1394 {
1395         int rc;
1396
1397         /* Recover from a failed assertion pre-reset */
1398         rc = efx_mcdi_handle_assertion(efx);
1399         if (rc)
1400                 return rc;
1401
1402         if (method == RESET_TYPE_WORLD)
1403                 return efx_mcdi_reset_mc(efx);
1404         else
1405                 return efx_mcdi_reset_port(efx);
1406 }
1407
1408 static int efx_mcdi_wol_filter_set(struct efx_nic *efx, u32 type,
1409                                    const u8 *mac, int *id_out)
1410 {
1411         MCDI_DECLARE_BUF(inbuf, MC_CMD_WOL_FILTER_SET_IN_LEN);
1412         MCDI_DECLARE_BUF(outbuf, MC_CMD_WOL_FILTER_SET_OUT_LEN);
1413         size_t outlen;
1414         int rc;
1415
1416         MCDI_SET_DWORD(inbuf, WOL_FILTER_SET_IN_WOL_TYPE, type);
1417         MCDI_SET_DWORD(inbuf, WOL_FILTER_SET_IN_FILTER_MODE,
1418                        MC_CMD_FILTER_MODE_SIMPLE);
1419         memcpy(MCDI_PTR(inbuf, WOL_FILTER_SET_IN_MAGIC_MAC), mac, ETH_ALEN);
1420
1421         rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_SET, inbuf, sizeof(inbuf),
1422                           outbuf, sizeof(outbuf), &outlen);
1423         if (rc)
1424                 goto fail;
1425
1426         if (outlen < MC_CMD_WOL_FILTER_SET_OUT_LEN) {
1427                 rc = -EIO;
1428                 goto fail;
1429         }
1430
1431         *id_out = (int)MCDI_DWORD(outbuf, WOL_FILTER_SET_OUT_FILTER_ID);
1432
1433         return 0;
1434
1435 fail:
1436         *id_out = -1;
1437         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1438         return rc;
1439
1440 }
1441
1442
1443 int
1444 efx_mcdi_wol_filter_set_magic(struct efx_nic *efx,  const u8 *mac, int *id_out)
1445 {
1446         return efx_mcdi_wol_filter_set(efx, MC_CMD_WOL_TYPE_MAGIC, mac, id_out);
1447 }
1448
1449
1450 int efx_mcdi_wol_filter_get_magic(struct efx_nic *efx, int *id_out)
1451 {
1452         MCDI_DECLARE_BUF(outbuf, MC_CMD_WOL_FILTER_GET_OUT_LEN);
1453         size_t outlen;
1454         int rc;
1455
1456         rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_GET, NULL, 0,
1457                           outbuf, sizeof(outbuf), &outlen);
1458         if (rc)
1459                 goto fail;
1460
1461         if (outlen < MC_CMD_WOL_FILTER_GET_OUT_LEN) {
1462                 rc = -EIO;
1463                 goto fail;
1464         }
1465
1466         *id_out = (int)MCDI_DWORD(outbuf, WOL_FILTER_GET_OUT_FILTER_ID);
1467
1468         return 0;
1469
1470 fail:
1471         *id_out = -1;
1472         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1473         return rc;
1474 }
1475
1476
1477 int efx_mcdi_wol_filter_remove(struct efx_nic *efx, int id)
1478 {
1479         MCDI_DECLARE_BUF(inbuf, MC_CMD_WOL_FILTER_REMOVE_IN_LEN);
1480         int rc;
1481
1482         MCDI_SET_DWORD(inbuf, WOL_FILTER_REMOVE_IN_FILTER_ID, (u32)id);
1483
1484         rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_REMOVE, inbuf, sizeof(inbuf),
1485                           NULL, 0, NULL);
1486         if (rc)
1487                 goto fail;
1488
1489         return 0;
1490
1491 fail:
1492         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1493         return rc;
1494 }
1495
1496 int efx_mcdi_flush_rxqs(struct efx_nic *efx)
1497 {
1498         struct efx_channel *channel;
1499         struct efx_rx_queue *rx_queue;
1500         MCDI_DECLARE_BUF(inbuf,
1501                          MC_CMD_FLUSH_RX_QUEUES_IN_LEN(EFX_MAX_CHANNELS));
1502         int rc, count;
1503
1504         BUILD_BUG_ON(EFX_MAX_CHANNELS >
1505                      MC_CMD_FLUSH_RX_QUEUES_IN_QID_OFST_MAXNUM);
1506
1507         count = 0;
1508         efx_for_each_channel(channel, efx) {
1509                 efx_for_each_channel_rx_queue(rx_queue, channel) {
1510                         if (rx_queue->flush_pending) {
1511                                 rx_queue->flush_pending = false;
1512                                 atomic_dec(&efx->rxq_flush_pending);
1513                                 MCDI_SET_ARRAY_DWORD(
1514                                         inbuf, FLUSH_RX_QUEUES_IN_QID_OFST,
1515                                         count, efx_rx_queue_index(rx_queue));
1516                                 count++;
1517                         }
1518                 }
1519         }
1520
1521         rc = efx_mcdi_rpc(efx, MC_CMD_FLUSH_RX_QUEUES, inbuf,
1522                           MC_CMD_FLUSH_RX_QUEUES_IN_LEN(count), NULL, 0, NULL);
1523         WARN_ON(rc < 0);
1524
1525         return rc;
1526 }
1527
1528 int efx_mcdi_wol_filter_reset(struct efx_nic *efx)
1529 {
1530         int rc;
1531
1532         rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_RESET, NULL, 0, NULL, 0, NULL);
1533         if (rc)
1534                 goto fail;
1535
1536         return 0;
1537
1538 fail:
1539         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1540         return rc;
1541 }
1542
1543 int efx_mcdi_set_workaround(struct efx_nic *efx, u32 type, bool enabled)
1544 {
1545         MCDI_DECLARE_BUF(inbuf, MC_CMD_WORKAROUND_IN_LEN);
1546
1547         BUILD_BUG_ON(MC_CMD_WORKAROUND_OUT_LEN != 0);
1548         MCDI_SET_DWORD(inbuf, WORKAROUND_IN_TYPE, type);
1549         MCDI_SET_DWORD(inbuf, WORKAROUND_IN_ENABLED, enabled);
1550         return efx_mcdi_rpc(efx, MC_CMD_WORKAROUND, inbuf, sizeof(inbuf),
1551                             NULL, 0, NULL);
1552 }
1553
1554 #ifdef CONFIG_SFC_MTD
1555
1556 #define EFX_MCDI_NVRAM_LEN_MAX 128
1557
1558 static int efx_mcdi_nvram_update_start(struct efx_nic *efx, unsigned int type)
1559 {
1560         MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_START_IN_LEN);
1561         int rc;
1562
1563         MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_START_IN_TYPE, type);
1564
1565         BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_START_OUT_LEN != 0);
1566
1567         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_START, inbuf, sizeof(inbuf),
1568                           NULL, 0, NULL);
1569         if (rc)
1570                 goto fail;
1571
1572         return 0;
1573
1574 fail:
1575         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1576         return rc;
1577 }
1578
1579 static int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,
1580                                loff_t offset, u8 *buffer, size_t length)
1581 {
1582         MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_READ_IN_LEN);
1583         MCDI_DECLARE_BUF(outbuf,
1584                          MC_CMD_NVRAM_READ_OUT_LEN(EFX_MCDI_NVRAM_LEN_MAX));
1585         size_t outlen;
1586         int rc;
1587
1588         MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_TYPE, type);
1589         MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_OFFSET, offset);
1590         MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_LENGTH, length);
1591
1592         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_READ, inbuf, sizeof(inbuf),
1593                           outbuf, sizeof(outbuf), &outlen);
1594         if (rc)
1595                 goto fail;
1596
1597         memcpy(buffer, MCDI_PTR(outbuf, NVRAM_READ_OUT_READ_BUFFER), length);
1598         return 0;
1599
1600 fail:
1601         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1602         return rc;
1603 }
1604
1605 static int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,
1606                                 loff_t offset, const u8 *buffer, size_t length)
1607 {
1608         MCDI_DECLARE_BUF(inbuf,
1609                          MC_CMD_NVRAM_WRITE_IN_LEN(EFX_MCDI_NVRAM_LEN_MAX));
1610         int rc;
1611
1612         MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_TYPE, type);
1613         MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_OFFSET, offset);
1614         MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_LENGTH, length);
1615         memcpy(MCDI_PTR(inbuf, NVRAM_WRITE_IN_WRITE_BUFFER), buffer, length);
1616
1617         BUILD_BUG_ON(MC_CMD_NVRAM_WRITE_OUT_LEN != 0);
1618
1619         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_WRITE, inbuf,
1620                           ALIGN(MC_CMD_NVRAM_WRITE_IN_LEN(length), 4),
1621                           NULL, 0, NULL);
1622         if (rc)
1623                 goto fail;
1624
1625         return 0;
1626
1627 fail:
1628         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1629         return rc;
1630 }
1631
1632 static int efx_mcdi_nvram_erase(struct efx_nic *efx, unsigned int type,
1633                                 loff_t offset, size_t length)
1634 {
1635         MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_ERASE_IN_LEN);
1636         int rc;
1637
1638         MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_TYPE, type);
1639         MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_OFFSET, offset);
1640         MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_LENGTH, length);
1641
1642         BUILD_BUG_ON(MC_CMD_NVRAM_ERASE_OUT_LEN != 0);
1643
1644         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_ERASE, inbuf, sizeof(inbuf),
1645                           NULL, 0, NULL);
1646         if (rc)
1647                 goto fail;
1648
1649         return 0;
1650
1651 fail:
1652         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1653         return rc;
1654 }
1655
1656 static int efx_mcdi_nvram_update_finish(struct efx_nic *efx, unsigned int type)
1657 {
1658         MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_FINISH_IN_LEN);
1659         int rc;
1660
1661         MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_FINISH_IN_TYPE, type);
1662
1663         BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_FINISH_OUT_LEN != 0);
1664
1665         rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_FINISH, inbuf, sizeof(inbuf),
1666                           NULL, 0, NULL);
1667         if (rc)
1668                 goto fail;
1669
1670         return 0;
1671
1672 fail:
1673         netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1674         return rc;
1675 }
1676
1677 int efx_mcdi_mtd_read(struct mtd_info *mtd, loff_t start,
1678                       size_t len, size_t *retlen, u8 *buffer)
1679 {
1680         struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1681         struct efx_nic *efx = mtd->priv;
1682         loff_t offset = start;
1683         loff_t end = min_t(loff_t, start + len, mtd->size);
1684         size_t chunk;
1685         int rc = 0;
1686
1687         while (offset < end) {
1688                 chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);
1689                 rc = efx_mcdi_nvram_read(efx, part->nvram_type, offset,
1690                                          buffer, chunk);
1691                 if (rc)
1692                         goto out;
1693                 offset += chunk;
1694                 buffer += chunk;
1695         }
1696 out:
1697         *retlen = offset - start;
1698         return rc;
1699 }
1700
1701 int efx_mcdi_mtd_erase(struct mtd_info *mtd, loff_t start, size_t len)
1702 {
1703         struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1704         struct efx_nic *efx = mtd->priv;
1705         loff_t offset = start & ~((loff_t)(mtd->erasesize - 1));
1706         loff_t end = min_t(loff_t, start + len, mtd->size);
1707         size_t chunk = part->common.mtd.erasesize;
1708         int rc = 0;
1709
1710         if (!part->updating) {
1711                 rc = efx_mcdi_nvram_update_start(efx, part->nvram_type);
1712                 if (rc)
1713                         goto out;
1714                 part->updating = true;
1715         }
1716
1717         /* The MCDI interface can in fact do multiple erase blocks at once;
1718          * but erasing may be slow, so we make multiple calls here to avoid
1719          * tripping the MCDI RPC timeout. */
1720         while (offset < end) {
1721                 rc = efx_mcdi_nvram_erase(efx, part->nvram_type, offset,
1722                                           chunk);
1723                 if (rc)
1724                         goto out;
1725                 offset += chunk;
1726         }
1727 out:
1728         return rc;
1729 }
1730
1731 int efx_mcdi_mtd_write(struct mtd_info *mtd, loff_t start,
1732                        size_t len, size_t *retlen, const u8 *buffer)
1733 {
1734         struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1735         struct efx_nic *efx = mtd->priv;
1736         loff_t offset = start;
1737         loff_t end = min_t(loff_t, start + len, mtd->size);
1738         size_t chunk;
1739         int rc = 0;
1740
1741         if (!part->updating) {
1742                 rc = efx_mcdi_nvram_update_start(efx, part->nvram_type);
1743                 if (rc)
1744                         goto out;
1745                 part->updating = true;
1746         }
1747
1748         while (offset < end) {
1749                 chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);
1750                 rc = efx_mcdi_nvram_write(efx, part->nvram_type, offset,
1751                                           buffer, chunk);
1752                 if (rc)
1753                         goto out;
1754                 offset += chunk;
1755                 buffer += chunk;
1756         }
1757 out:
1758         *retlen = offset - start;
1759         return rc;
1760 }
1761
1762 int efx_mcdi_mtd_sync(struct mtd_info *mtd)
1763 {
1764         struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1765         struct efx_nic *efx = mtd->priv;
1766         int rc = 0;
1767
1768         if (part->updating) {
1769                 part->updating = false;
1770                 rc = efx_mcdi_nvram_update_finish(efx, part->nvram_type);
1771         }
1772
1773         return rc;
1774 }
1775
1776 void efx_mcdi_mtd_rename(struct efx_mtd_partition *part)
1777 {
1778         struct efx_mcdi_mtd_partition *mcdi_part =
1779                 container_of(part, struct efx_mcdi_mtd_partition, common);
1780         struct efx_nic *efx = part->mtd.priv;
1781
1782         snprintf(part->name, sizeof(part->name), "%s %s:%02x",
1783                  efx->name, part->type_name, mcdi_part->fw_subtype);
1784 }
1785
1786 #endif /* CONFIG_SFC_MTD */