1 /****************************************************************************
2 * Driver for Solarflare network controllers and boards
3 * Copyright 2008-2013 Solarflare Communications Inc.
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.
10 #include <linux/delay.h>
11 #include <asm/cmpxchg.h>
12 #include "net_driver.h"
15 #include "farch_regs.h"
16 #include "mcdi_pcol.h"
19 /**************************************************************************
21 * Management-Controller-to-Driver Interface
23 **************************************************************************
26 #define MCDI_RPC_TIMEOUT (10 * HZ)
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.
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)
38 EFX_MASK32(EFX_WIDTH(MCDI_HEADER_SEQ))
40 struct efx_mcdi_async_param {
41 struct list_head list;
45 efx_mcdi_async_completer *complete;
47 /* followed by request/response buffer */
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);
55 static inline struct efx_mcdi_iface *efx_mcdi(struct efx_nic *efx)
57 EFX_BUG_ON_PARANOID(!efx->mcdi);
58 return &efx->mcdi->iface;
61 int efx_mcdi_init(struct efx_nic *efx)
63 struct efx_mcdi_iface *mcdi;
64 bool already_attached;
67 efx->mcdi = kzalloc(sizeof(*efx->mcdi), GFP_KERNEL);
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,
82 (void) efx_mcdi_poll_reboot(efx);
83 mcdi->new_epoch = true;
85 /* Recover from a failed assertion before probing */
86 rc = efx_mcdi_handle_assertion(efx);
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.
93 rc = efx_mcdi_drv_attach(efx, true, &already_attached);
95 netif_err(efx, probe, efx->net_dev,
96 "Unable to register driver with MCPU\n");
100 /* Not a fatal error */
101 netif_err(efx, probe, efx->net_dev,
102 "Host already registered with MCPU\n");
107 void efx_mcdi_fini(struct efx_nic *efx)
112 BUG_ON(efx->mcdi->iface.state != MCDI_STATE_QUIESCENT);
114 /* Relinquish the device (back to the BMC, if this is a LOM) */
115 efx_mcdi_drv_attach(efx, false, NULL);
120 static void efx_mcdi_send_request(struct efx_nic *efx, unsigned cmd,
121 const efx_dword_t *inbuf, size_t inlen)
123 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
128 BUG_ON(mcdi->state == MCDI_STATE_QUIESCENT);
130 /* Serialise with efx_mcdi_ev_cpl() and efx_mcdi_ev_death() */
131 spin_lock_bh(&mcdi->iface_lock);
133 spin_unlock_bh(&mcdi->iface_lock);
135 seqno = mcdi->seqno & SEQ_MASK;
137 if (mcdi->mode == MCDI_MODE_EVENTS)
138 xflags |= MCDI_HEADER_XFLAGS_EVREQ;
140 if (efx->type->mcdi_max_ver == 1) {
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);
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);
168 efx->type->mcdi_request(efx, hdr, hdr_len, inbuf, inlen);
170 mcdi->new_epoch = false;
173 static int efx_mcdi_errno(unsigned int mcdi_err)
178 #define TRANSLATE_ERROR(name) \
179 case MC_CMD_ERR_ ## 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:
196 case MC_CMD_ERR_MAC_EXIST:
203 static void efx_mcdi_read_response_header(struct efx_nic *efx)
205 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
206 unsigned int respseq, respcmd, error;
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);
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);
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);
224 if (error && mcdi->resp_data_len == 0) {
225 netif_err(efx, hw, efx->net_dev, "MC rebooted\n");
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);
233 efx->type->mcdi_read_response(efx, &hdr, mcdi->resp_hdr_len, 4);
235 efx_mcdi_errno(EFX_DWORD_FIELD(hdr, EFX_DWORD_0));
241 static bool efx_mcdi_poll_once(struct efx_nic *efx)
243 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
246 if (!efx->type->mcdi_poll_response(efx))
249 spin_lock_bh(&mcdi->iface_lock);
250 efx_mcdi_read_response_header(efx);
251 spin_unlock_bh(&mcdi->iface_lock);
256 static int efx_mcdi_poll(struct efx_nic *efx)
258 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
259 unsigned long time, finish;
263 /* Check for a reboot atomically with respect to efx_mcdi_copyout() */
264 rc = efx_mcdi_poll_reboot(efx);
266 spin_lock_bh(&mcdi->iface_lock);
268 mcdi->resp_hdr_len = 0;
269 mcdi->resp_data_len = 0;
270 spin_unlock_bh(&mcdi->iface_lock);
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)
279 finish = jiffies + MCDI_RPC_TIMEOUT;
286 schedule_timeout_uninterruptible(1);
291 if (efx_mcdi_poll_once(efx))
294 if (time_after(time, finish))
298 /* Return rc=0 like wait_event_timeout() */
302 /* Test and clear MC-rebooted flag for this port/function; reset
303 * software state as necessary.
305 int efx_mcdi_poll_reboot(struct efx_nic *efx)
310 return efx->type->mcdi_poll_reboot(efx);
313 static bool efx_mcdi_acquire_async(struct efx_mcdi_iface *mcdi)
315 return cmpxchg(&mcdi->state,
316 MCDI_STATE_QUIESCENT, MCDI_STATE_RUNNING_ASYNC) ==
317 MCDI_STATE_QUIESCENT;
320 static void efx_mcdi_acquire_sync(struct efx_mcdi_iface *mcdi)
322 /* Wait until the interface becomes QUIESCENT and we win the race
323 * to mark it RUNNING_SYNC.
326 cmpxchg(&mcdi->state,
327 MCDI_STATE_QUIESCENT, MCDI_STATE_RUNNING_SYNC) ==
328 MCDI_STATE_QUIESCENT);
331 static int efx_mcdi_await_completion(struct efx_nic *efx)
333 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
335 if (wait_event_timeout(mcdi->wq, mcdi->state == MCDI_STATE_COMPLETED,
336 MCDI_RPC_TIMEOUT) == 0)
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.
344 * We need an smp_rmb() to synchronise with efx_mcdi_mode_poll(), which
345 * wait_event_timeout() implicitly provides.
347 if (mcdi->mode == MCDI_MODE_POLL)
348 return efx_mcdi_poll(efx);
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.
356 static bool efx_mcdi_complete_sync(struct efx_mcdi_iface *mcdi)
358 if (cmpxchg(&mcdi->state,
359 MCDI_STATE_RUNNING_SYNC, MCDI_STATE_COMPLETED) ==
360 MCDI_STATE_RUNNING_SYNC) {
368 static void efx_mcdi_release(struct efx_mcdi_iface *mcdi)
370 if (mcdi->mode == MCDI_MODE_EVENTS) {
371 struct efx_mcdi_async_param *async;
372 struct efx_nic *efx = mcdi->efx;
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);
379 mcdi->state = MCDI_STATE_RUNNING_ASYNC;
380 efx_mcdi_send_request(efx, async->cmd,
381 (const efx_dword_t *)(async + 1),
383 mod_timer(&mcdi->async_timer,
384 jiffies + MCDI_RPC_TIMEOUT);
386 spin_unlock_bh(&mcdi->async_lock);
392 mcdi->state = MCDI_STATE_QUIESCENT;
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.
401 static bool efx_mcdi_complete_async(struct efx_mcdi_iface *mcdi, bool timeout)
403 struct efx_nic *efx = mcdi->efx;
404 struct efx_mcdi_async_param *async;
405 size_t hdr_len, data_len;
409 if (cmpxchg(&mcdi->state,
410 MCDI_STATE_RUNNING_ASYNC, MCDI_STATE_COMPLETED) !=
411 MCDI_STATE_RUNNING_ASYNC)
414 spin_lock(&mcdi->iface_lock);
416 /* Ensure that if the completion event arrives later,
417 * the seqno check in efx_mcdi_ev_cpl() will fail
426 hdr_len = mcdi->resp_hdr_len;
427 data_len = mcdi->resp_data_len;
429 spin_unlock(&mcdi->iface_lock);
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.
436 del_timer_sync(&mcdi->async_timer);
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);
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);
450 efx_mcdi_release(mcdi);
455 static void efx_mcdi_ev_cpl(struct efx_nic *efx, unsigned int seqno,
456 unsigned int datalen, unsigned int mcdi_err)
458 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
461 spin_lock(&mcdi->iface_lock);
463 if ((seqno ^ mcdi->seqno) & SEQ_MASK) {
465 /* The request has been cancelled */
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);
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);
476 mcdi->resprc = efx_mcdi_errno(mcdi_err);
477 mcdi->resp_hdr_len = 4;
478 mcdi->resp_data_len = datalen;
484 spin_unlock(&mcdi->iface_lock);
487 if (!efx_mcdi_complete_async(mcdi, false))
488 (void) efx_mcdi_complete_sync(mcdi);
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].
499 static void efx_mcdi_timeout_async(unsigned long context)
501 struct efx_mcdi_iface *mcdi = (struct efx_mcdi_iface *)context;
503 efx_mcdi_complete_async(mcdi, true);
507 efx_mcdi_check_supported(struct efx_nic *efx, unsigned int cmd, size_t inlen)
509 if (efx->type->mcdi_max_ver < 0 ||
510 (efx->type->mcdi_max_ver < 2 &&
511 cmd > MC_CMD_CMD_SPACE_ESCAPE_7))
514 if (inlen > MCDI_CTL_SDU_LEN_MAX_V2 ||
515 (efx->type->mcdi_max_ver < 2 &&
516 inlen > MCDI_CTL_SDU_LEN_MAX_V1))
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)
529 rc = efx_mcdi_rpc_start(efx, cmd, inbuf, inlen);
532 return efx_mcdi_rpc_finish(efx, cmd, inlen,
533 outbuf, outlen, outlen_actual);
536 int efx_mcdi_rpc_start(struct efx_nic *efx, unsigned cmd,
537 const efx_dword_t *inbuf, size_t inlen)
539 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
542 rc = efx_mcdi_check_supported(efx, cmd, inlen);
546 efx_mcdi_acquire_sync(mcdi);
547 efx_mcdi_send_request(efx, cmd, inbuf, inlen);
552 * efx_mcdi_rpc_async - Schedule an MCDI command to run asynchronously
553 * @efx: NIC through which to issue the command
554 * @cmd: Command type number
555 * @inbuf: Command parameters
556 * @inlen: Length of command parameters, in bytes
557 * @outlen: Length to allocate for response buffer, in bytes
558 * @complete: Function to be called on completion or cancellation.
559 * @cookie: Arbitrary value to be passed to @complete.
561 * This function does not sleep and therefore may be called in atomic
562 * context. It will fail if event queues are disabled or if MCDI
563 * event completions have been disabled due to an error.
565 * If it succeeds, the @complete function will be called exactly once
566 * in atomic context, when one of the following occurs:
567 * (a) the completion event is received (in NAPI context)
568 * (b) event queues are disabled (in the process that disables them)
569 * (c) the request times-out (in timer context)
572 efx_mcdi_rpc_async(struct efx_nic *efx, unsigned int cmd,
573 const efx_dword_t *inbuf, size_t inlen, size_t outlen,
574 efx_mcdi_async_completer *complete, unsigned long cookie)
576 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
577 struct efx_mcdi_async_param *async;
580 rc = efx_mcdi_check_supported(efx, cmd, inlen);
584 async = kmalloc(sizeof(*async) + ALIGN(max(inlen, outlen), 4),
590 async->inlen = inlen;
591 async->outlen = outlen;
592 async->complete = complete;
593 async->cookie = cookie;
594 memcpy(async + 1, inbuf, inlen);
596 spin_lock_bh(&mcdi->async_lock);
598 if (mcdi->mode == MCDI_MODE_EVENTS) {
599 list_add_tail(&async->list, &mcdi->async_list);
601 /* If this is at the front of the queue, try to start it
604 if (mcdi->async_list.next == &async->list &&
605 efx_mcdi_acquire_async(mcdi)) {
606 efx_mcdi_send_request(efx, cmd, inbuf, inlen);
607 mod_timer(&mcdi->async_timer,
608 jiffies + MCDI_RPC_TIMEOUT);
615 spin_unlock_bh(&mcdi->async_lock);
620 int efx_mcdi_rpc_finish(struct efx_nic *efx, unsigned cmd, size_t inlen,
621 efx_dword_t *outbuf, size_t outlen,
622 size_t *outlen_actual)
624 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
627 if (mcdi->mode == MCDI_MODE_POLL)
628 rc = efx_mcdi_poll(efx);
630 rc = efx_mcdi_await_completion(efx);
633 netif_err(efx, hw, efx->net_dev,
634 "MC command 0x%x inlen %d mode %d timed out\n",
635 cmd, (int)inlen, mcdi->mode);
637 if (mcdi->mode == MCDI_MODE_EVENTS && efx_mcdi_poll_once(efx)) {
638 netif_err(efx, hw, efx->net_dev,
639 "MCDI request was completed without an event\n");
643 /* Close the race with efx_mcdi_ev_cpl() executing just too late
644 * and completing a request we've just cancelled, by ensuring
645 * that the seqno check therein fails.
647 spin_lock_bh(&mcdi->iface_lock);
650 spin_unlock_bh(&mcdi->iface_lock);
654 size_t hdr_len, data_len;
656 /* At the very least we need a memory barrier here to ensure
657 * we pick up changes from efx_mcdi_ev_cpl(). Protect against
658 * a spurious efx_mcdi_ev_cpl() running concurrently by
659 * acquiring the iface_lock. */
660 spin_lock_bh(&mcdi->iface_lock);
662 hdr_len = mcdi->resp_hdr_len;
663 data_len = mcdi->resp_data_len;
664 spin_unlock_bh(&mcdi->iface_lock);
669 efx->type->mcdi_read_response(efx, outbuf, hdr_len,
670 min(outlen, data_len));
671 if (outlen_actual != NULL)
672 *outlen_actual = data_len;
673 } else if (cmd == MC_CMD_REBOOT && rc == -EIO)
674 ; /* Don't reset if MC_CMD_REBOOT returns EIO */
675 else if (rc == -EIO || rc == -EINTR) {
676 netif_err(efx, hw, efx->net_dev, "MC fatal error %d\n",
678 efx_schedule_reset(efx, RESET_TYPE_MC_FAILURE);
680 netif_dbg(efx, hw, efx->net_dev,
681 "MC command 0x%x inlen %d failed rc=%d\n",
682 cmd, (int)inlen, -rc);
684 if (rc == -EIO || rc == -EINTR) {
685 msleep(MCDI_STATUS_SLEEP_MS);
686 efx_mcdi_poll_reboot(efx);
687 mcdi->new_epoch = true;
691 efx_mcdi_release(mcdi);
695 /* Switch to polled MCDI completions. This can be called in various
696 * error conditions with various locks held, so it must be lockless.
697 * Caller is responsible for flushing asynchronous requests later.
699 void efx_mcdi_mode_poll(struct efx_nic *efx)
701 struct efx_mcdi_iface *mcdi;
706 mcdi = efx_mcdi(efx);
707 if (mcdi->mode == MCDI_MODE_POLL)
710 /* We can switch from event completion to polled completion, because
711 * mcdi requests are always completed in shared memory. We do this by
712 * switching the mode to POLL'd then completing the request.
713 * efx_mcdi_await_completion() will then call efx_mcdi_poll().
715 * We need an smp_wmb() to synchronise with efx_mcdi_await_completion(),
716 * which efx_mcdi_complete_sync() provides for us.
718 mcdi->mode = MCDI_MODE_POLL;
720 efx_mcdi_complete_sync(mcdi);
723 /* Flush any running or queued asynchronous requests, after event processing
726 void efx_mcdi_flush_async(struct efx_nic *efx)
728 struct efx_mcdi_async_param *async, *next;
729 struct efx_mcdi_iface *mcdi;
734 mcdi = efx_mcdi(efx);
736 /* We must be in polling mode so no more requests can be queued */
737 BUG_ON(mcdi->mode != MCDI_MODE_POLL);
739 del_timer_sync(&mcdi->async_timer);
741 /* If a request is still running, make sure we give the MC
742 * time to complete it so that the response won't overwrite our
745 if (mcdi->state == MCDI_STATE_RUNNING_ASYNC) {
747 mcdi->state = MCDI_STATE_QUIESCENT;
750 /* Nothing else will access the async list now, so it is safe
751 * to walk it without holding async_lock. If we hold it while
752 * calling a completer then lockdep may warn that we have
753 * acquired locks in the wrong order.
755 list_for_each_entry_safe(async, next, &mcdi->async_list, list) {
756 async->complete(efx, async->cookie, -ENETDOWN, NULL, 0);
757 list_del(&async->list);
762 void efx_mcdi_mode_event(struct efx_nic *efx)
764 struct efx_mcdi_iface *mcdi;
769 mcdi = efx_mcdi(efx);
771 if (mcdi->mode == MCDI_MODE_EVENTS)
774 /* We can't switch from polled to event completion in the middle of a
775 * request, because the completion method is specified in the request.
776 * So acquire the interface to serialise the requestors. We don't need
777 * to acquire the iface_lock to change the mode here, but we do need a
778 * write memory barrier ensure that efx_mcdi_rpc() sees it, which
779 * efx_mcdi_acquire() provides.
781 efx_mcdi_acquire_sync(mcdi);
782 mcdi->mode = MCDI_MODE_EVENTS;
783 efx_mcdi_release(mcdi);
786 static void efx_mcdi_ev_death(struct efx_nic *efx, int rc)
788 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
790 /* If there is an outstanding MCDI request, it has been terminated
791 * either by a BADASSERT or REBOOT event. If the mcdi interface is
792 * in polled mode, then do nothing because the MC reboot handler will
793 * set the header correctly. However, if the mcdi interface is waiting
794 * for a CMDDONE event it won't receive it [and since all MCDI events
795 * are sent to the same queue, we can't be racing with
798 * If there is an outstanding asynchronous request, we can't
799 * complete it now (efx_mcdi_complete() would deadlock). The
800 * reset process will take care of this.
802 * There's a race here with efx_mcdi_send_request(), because
803 * we might receive a REBOOT event *before* the request has
804 * been copied out. In polled mode (during startup) this is
805 * irrelevant, because efx_mcdi_complete_sync() is ignored. In
806 * event mode, this condition is just an edge-case of
807 * receiving a REBOOT event after posting the MCDI
808 * request. Did the mc reboot before or after the copyout? The
809 * best we can do always is just return failure.
811 spin_lock(&mcdi->iface_lock);
812 if (efx_mcdi_complete_sync(mcdi)) {
813 if (mcdi->mode == MCDI_MODE_EVENTS) {
815 mcdi->resp_hdr_len = 0;
816 mcdi->resp_data_len = 0;
822 /* Consume the status word since efx_mcdi_rpc_finish() won't */
823 for (count = 0; count < MCDI_STATUS_DELAY_COUNT; ++count) {
824 if (efx_mcdi_poll_reboot(efx))
826 udelay(MCDI_STATUS_DELAY_US);
828 mcdi->new_epoch = true;
830 /* Nobody was waiting for an MCDI request, so trigger a reset */
831 efx_schedule_reset(efx, RESET_TYPE_MC_FAILURE);
834 spin_unlock(&mcdi->iface_lock);
837 /* Called from falcon_process_eventq for MCDI events */
838 void efx_mcdi_process_event(struct efx_channel *channel,
841 struct efx_nic *efx = channel->efx;
842 int code = EFX_QWORD_FIELD(*event, MCDI_EVENT_CODE);
843 u32 data = EFX_QWORD_FIELD(*event, MCDI_EVENT_DATA);
846 case MCDI_EVENT_CODE_BADSSERT:
847 netif_err(efx, hw, efx->net_dev,
848 "MC watchdog or assertion failure at 0x%x\n", data);
849 efx_mcdi_ev_death(efx, -EINTR);
852 case MCDI_EVENT_CODE_PMNOTICE:
853 netif_info(efx, wol, efx->net_dev, "MCDI PM event.\n");
856 case MCDI_EVENT_CODE_CMDDONE:
858 MCDI_EVENT_FIELD(*event, CMDDONE_SEQ),
859 MCDI_EVENT_FIELD(*event, CMDDONE_DATALEN),
860 MCDI_EVENT_FIELD(*event, CMDDONE_ERRNO));
863 case MCDI_EVENT_CODE_LINKCHANGE:
864 efx_mcdi_process_link_change(efx, event);
866 case MCDI_EVENT_CODE_SENSOREVT:
867 efx_mcdi_sensor_event(efx, event);
869 case MCDI_EVENT_CODE_SCHEDERR:
870 netif_info(efx, hw, efx->net_dev,
871 "MC Scheduler error address=0x%x\n", data);
873 case MCDI_EVENT_CODE_REBOOT:
874 case MCDI_EVENT_CODE_MC_REBOOT:
875 netif_info(efx, hw, efx->net_dev, "MC Reboot\n");
876 efx_mcdi_ev_death(efx, -EIO);
878 case MCDI_EVENT_CODE_MAC_STATS_DMA:
879 /* MAC stats are gather lazily. We can ignore this. */
881 case MCDI_EVENT_CODE_FLR:
882 efx_sriov_flr(efx, MCDI_EVENT_FIELD(*event, FLR_VF));
884 case MCDI_EVENT_CODE_PTP_RX:
885 case MCDI_EVENT_CODE_PTP_FAULT:
886 case MCDI_EVENT_CODE_PTP_PPS:
887 efx_ptp_event(efx, event);
889 case MCDI_EVENT_CODE_TX_FLUSH:
890 case MCDI_EVENT_CODE_RX_FLUSH:
891 /* Two flush events will be sent: one to the same event
892 * queue as completions, and one to event queue 0.
893 * In the latter case the {RX,TX}_FLUSH_TO_DRIVER
894 * flag will be set, and we should ignore the event
895 * because we want to wait for all completions.
897 BUILD_BUG_ON(MCDI_EVENT_TX_FLUSH_TO_DRIVER_LBN !=
898 MCDI_EVENT_RX_FLUSH_TO_DRIVER_LBN);
899 if (!MCDI_EVENT_FIELD(*event, TX_FLUSH_TO_DRIVER))
900 efx_ef10_handle_drain_event(efx);
902 case MCDI_EVENT_CODE_TX_ERR:
903 case MCDI_EVENT_CODE_RX_ERR:
904 netif_err(efx, hw, efx->net_dev,
905 "%s DMA error (event: "EFX_QWORD_FMT")\n",
906 code == MCDI_EVENT_CODE_TX_ERR ? "TX" : "RX",
907 EFX_QWORD_VAL(*event));
908 efx_schedule_reset(efx, RESET_TYPE_DMA_ERROR);
911 netif_err(efx, hw, efx->net_dev, "Unknown MCDI event 0x%x\n",
916 /**************************************************************************
918 * Specific request functions
920 **************************************************************************
923 void efx_mcdi_print_fwver(struct efx_nic *efx, char *buf, size_t len)
925 MCDI_DECLARE_BUF(outbuf,
926 max(MC_CMD_GET_VERSION_OUT_LEN,
927 MC_CMD_GET_CAPABILITIES_OUT_LEN));
929 const __le16 *ver_words;
933 BUILD_BUG_ON(MC_CMD_GET_VERSION_IN_LEN != 0);
934 rc = efx_mcdi_rpc(efx, MC_CMD_GET_VERSION, NULL, 0,
935 outbuf, sizeof(outbuf), &outlength);
938 if (outlength < MC_CMD_GET_VERSION_OUT_LEN) {
943 ver_words = (__le16 *)MCDI_PTR(outbuf, GET_VERSION_OUT_VERSION);
944 offset = snprintf(buf, len, "%u.%u.%u.%u",
945 le16_to_cpu(ver_words[0]), le16_to_cpu(ver_words[1]),
946 le16_to_cpu(ver_words[2]), le16_to_cpu(ver_words[3]));
948 /* EF10 may have multiple datapath firmware variants within a
949 * single version. Report which variants are running.
951 if (efx_nic_rev(efx) >= EFX_REV_HUNT_A0) {
952 BUILD_BUG_ON(MC_CMD_GET_CAPABILITIES_IN_LEN != 0);
953 rc = efx_mcdi_rpc(efx, MC_CMD_GET_CAPABILITIES, NULL, 0,
954 outbuf, sizeof(outbuf), &outlength);
955 if (rc || outlength < MC_CMD_GET_CAPABILITIES_OUT_LEN)
957 buf + offset, len - offset, " rx? tx?");
960 buf + offset, len - offset, " rx%x tx%x",
962 GET_CAPABILITIES_OUT_RX_DPCPU_FW_ID),
964 GET_CAPABILITIES_OUT_TX_DPCPU_FW_ID));
966 /* It's theoretically possible for the string to exceed 31
967 * characters, though in practice the first three version
968 * components are short enough that this doesn't happen.
970 if (WARN_ON(offset >= len))
977 netif_err(efx, probe, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
981 static int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
984 MCDI_DECLARE_BUF(inbuf, MC_CMD_DRV_ATTACH_IN_LEN);
985 MCDI_DECLARE_BUF(outbuf, MC_CMD_DRV_ATTACH_EXT_OUT_LEN);
989 MCDI_SET_DWORD(inbuf, DRV_ATTACH_IN_NEW_STATE,
990 driver_operating ? 1 : 0);
991 MCDI_SET_DWORD(inbuf, DRV_ATTACH_IN_UPDATE, 1);
992 MCDI_SET_DWORD(inbuf, DRV_ATTACH_IN_FIRMWARE_ID, MC_CMD_FW_LOW_LATENCY);
994 rc = efx_mcdi_rpc(efx, MC_CMD_DRV_ATTACH, inbuf, sizeof(inbuf),
995 outbuf, sizeof(outbuf), &outlen);
998 if (outlen < MC_CMD_DRV_ATTACH_OUT_LEN) {
1003 /* We currently assume we have control of the external link
1004 * and are completely trusted by firmware. Abort probing
1005 * if that's not true for this function.
1007 if (driver_operating &&
1008 outlen >= MC_CMD_DRV_ATTACH_EXT_OUT_LEN &&
1009 (MCDI_DWORD(outbuf, DRV_ATTACH_EXT_OUT_FUNC_FLAGS) &
1010 (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_LINKCTRL |
1011 1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_TRUSTED)) !=
1012 (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_LINKCTRL |
1013 1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_TRUSTED)) {
1014 netif_err(efx, probe, efx->net_dev,
1015 "This driver version only supports one function per port\n");
1019 if (was_attached != NULL)
1020 *was_attached = MCDI_DWORD(outbuf, DRV_ATTACH_OUT_OLD_STATE);
1024 netif_err(efx, probe, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1028 int efx_mcdi_get_board_cfg(struct efx_nic *efx, u8 *mac_address,
1029 u16 *fw_subtype_list, u32 *capabilities)
1031 MCDI_DECLARE_BUF(outbuf, MC_CMD_GET_BOARD_CFG_OUT_LENMAX);
1033 int port_num = efx_port_num(efx);
1036 BUILD_BUG_ON(MC_CMD_GET_BOARD_CFG_IN_LEN != 0);
1038 rc = efx_mcdi_rpc(efx, MC_CMD_GET_BOARD_CFG, NULL, 0,
1039 outbuf, sizeof(outbuf), &outlen);
1043 if (outlen < MC_CMD_GET_BOARD_CFG_OUT_LENMIN) {
1051 MCDI_PTR(outbuf, GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT1) :
1052 MCDI_PTR(outbuf, GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT0),
1054 if (fw_subtype_list) {
1056 i < MCDI_VAR_ARRAY_LEN(outlen,
1057 GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST);
1059 fw_subtype_list[i] = MCDI_ARRAY_WORD(
1060 outbuf, GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST, i);
1061 for (; i < MC_CMD_GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST_MAXNUM; i++)
1062 fw_subtype_list[i] = 0;
1066 *capabilities = MCDI_DWORD(outbuf,
1067 GET_BOARD_CFG_OUT_CAPABILITIES_PORT1);
1069 *capabilities = MCDI_DWORD(outbuf,
1070 GET_BOARD_CFG_OUT_CAPABILITIES_PORT0);
1076 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d len=%d\n",
1077 __func__, rc, (int)outlen);
1082 int efx_mcdi_log_ctrl(struct efx_nic *efx, bool evq, bool uart, u32 dest_evq)
1084 MCDI_DECLARE_BUF(inbuf, MC_CMD_LOG_CTRL_IN_LEN);
1089 dest |= MC_CMD_LOG_CTRL_IN_LOG_DEST_UART;
1091 dest |= MC_CMD_LOG_CTRL_IN_LOG_DEST_EVQ;
1093 MCDI_SET_DWORD(inbuf, LOG_CTRL_IN_LOG_DEST, dest);
1094 MCDI_SET_DWORD(inbuf, LOG_CTRL_IN_LOG_DEST_EVQ, dest_evq);
1096 BUILD_BUG_ON(MC_CMD_LOG_CTRL_OUT_LEN != 0);
1098 rc = efx_mcdi_rpc(efx, MC_CMD_LOG_CTRL, inbuf, sizeof(inbuf),
1106 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1110 int efx_mcdi_nvram_types(struct efx_nic *efx, u32 *nvram_types_out)
1112 MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_TYPES_OUT_LEN);
1116 BUILD_BUG_ON(MC_CMD_NVRAM_TYPES_IN_LEN != 0);
1118 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_TYPES, NULL, 0,
1119 outbuf, sizeof(outbuf), &outlen);
1122 if (outlen < MC_CMD_NVRAM_TYPES_OUT_LEN) {
1127 *nvram_types_out = MCDI_DWORD(outbuf, NVRAM_TYPES_OUT_TYPES);
1131 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
1136 int efx_mcdi_nvram_info(struct efx_nic *efx, unsigned int type,
1137 size_t *size_out, size_t *erase_size_out,
1138 bool *protected_out)
1140 MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_INFO_IN_LEN);
1141 MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_INFO_OUT_LEN);
1145 MCDI_SET_DWORD(inbuf, NVRAM_INFO_IN_TYPE, type);
1147 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_INFO, inbuf, sizeof(inbuf),
1148 outbuf, sizeof(outbuf), &outlen);
1151 if (outlen < MC_CMD_NVRAM_INFO_OUT_LEN) {
1156 *size_out = MCDI_DWORD(outbuf, NVRAM_INFO_OUT_SIZE);
1157 *erase_size_out = MCDI_DWORD(outbuf, NVRAM_INFO_OUT_ERASESIZE);
1158 *protected_out = !!(MCDI_DWORD(outbuf, NVRAM_INFO_OUT_FLAGS) &
1159 (1 << MC_CMD_NVRAM_INFO_OUT_PROTECTED_LBN));
1163 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1167 static int efx_mcdi_nvram_test(struct efx_nic *efx, unsigned int type)
1169 MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_TEST_IN_LEN);
1170 MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_TEST_OUT_LEN);
1173 MCDI_SET_DWORD(inbuf, NVRAM_TEST_IN_TYPE, type);
1175 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_TEST, inbuf, sizeof(inbuf),
1176 outbuf, sizeof(outbuf), NULL);
1180 switch (MCDI_DWORD(outbuf, NVRAM_TEST_OUT_RESULT)) {
1181 case MC_CMD_NVRAM_TEST_PASS:
1182 case MC_CMD_NVRAM_TEST_NOTSUPP:
1189 int efx_mcdi_nvram_test_all(struct efx_nic *efx)
1195 rc = efx_mcdi_nvram_types(efx, &nvram_types);
1200 while (nvram_types != 0) {
1201 if (nvram_types & 1) {
1202 rc = efx_mcdi_nvram_test(efx, type);
1213 netif_err(efx, hw, efx->net_dev, "%s: failed type=%u\n",
1216 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1220 static int efx_mcdi_read_assertion(struct efx_nic *efx)
1222 MCDI_DECLARE_BUF(inbuf, MC_CMD_GET_ASSERTS_IN_LEN);
1223 MCDI_DECLARE_BUF(outbuf, MC_CMD_GET_ASSERTS_OUT_LEN);
1224 unsigned int flags, index;
1230 /* Attempt to read any stored assertion state before we reboot
1231 * the mcfw out of the assertion handler. Retry twice, once
1232 * because a boot-time assertion might cause this command to fail
1233 * with EINTR. And once again because GET_ASSERTS can race with
1234 * MC_CMD_REBOOT running on the other port. */
1237 MCDI_SET_DWORD(inbuf, GET_ASSERTS_IN_CLEAR, 1);
1238 rc = efx_mcdi_rpc(efx, MC_CMD_GET_ASSERTS,
1239 inbuf, MC_CMD_GET_ASSERTS_IN_LEN,
1240 outbuf, sizeof(outbuf), &outlen);
1241 } while ((rc == -EINTR || rc == -EIO) && retry-- > 0);
1245 if (outlen < MC_CMD_GET_ASSERTS_OUT_LEN)
1248 /* Print out any recorded assertion state */
1249 flags = MCDI_DWORD(outbuf, GET_ASSERTS_OUT_GLOBAL_FLAGS);
1250 if (flags == MC_CMD_GET_ASSERTS_FLAGS_NO_FAILS)
1253 reason = (flags == MC_CMD_GET_ASSERTS_FLAGS_SYS_FAIL)
1254 ? "system-level assertion"
1255 : (flags == MC_CMD_GET_ASSERTS_FLAGS_THR_FAIL)
1256 ? "thread-level assertion"
1257 : (flags == MC_CMD_GET_ASSERTS_FLAGS_WDOG_FIRED)
1259 : "unknown assertion";
1260 netif_err(efx, hw, efx->net_dev,
1261 "MCPU %s at PC = 0x%.8x in thread 0x%.8x\n", reason,
1262 MCDI_DWORD(outbuf, GET_ASSERTS_OUT_SAVED_PC_OFFS),
1263 MCDI_DWORD(outbuf, GET_ASSERTS_OUT_THREAD_OFFS));
1265 /* Print out the registers */
1267 index < MC_CMD_GET_ASSERTS_OUT_GP_REGS_OFFS_NUM;
1269 netif_err(efx, hw, efx->net_dev, "R%.2d (?): 0x%.8x\n",
1271 MCDI_ARRAY_DWORD(outbuf, GET_ASSERTS_OUT_GP_REGS_OFFS,
1277 static void efx_mcdi_exit_assertion(struct efx_nic *efx)
1279 MCDI_DECLARE_BUF(inbuf, MC_CMD_REBOOT_IN_LEN);
1281 /* If the MC is running debug firmware, it might now be
1282 * waiting for a debugger to attach, but we just want it to
1283 * reboot. We set a flag that makes the command a no-op if it
1284 * has already done so. We don't know what return code to
1285 * expect (0 or -EIO), so ignore it.
1287 BUILD_BUG_ON(MC_CMD_REBOOT_OUT_LEN != 0);
1288 MCDI_SET_DWORD(inbuf, REBOOT_IN_FLAGS,
1289 MC_CMD_REBOOT_FLAGS_AFTER_ASSERTION);
1290 (void) efx_mcdi_rpc(efx, MC_CMD_REBOOT, inbuf, MC_CMD_REBOOT_IN_LEN,
1294 int efx_mcdi_handle_assertion(struct efx_nic *efx)
1298 rc = efx_mcdi_read_assertion(efx);
1302 efx_mcdi_exit_assertion(efx);
1307 void efx_mcdi_set_id_led(struct efx_nic *efx, enum efx_led_mode mode)
1309 MCDI_DECLARE_BUF(inbuf, MC_CMD_SET_ID_LED_IN_LEN);
1312 BUILD_BUG_ON(EFX_LED_OFF != MC_CMD_LED_OFF);
1313 BUILD_BUG_ON(EFX_LED_ON != MC_CMD_LED_ON);
1314 BUILD_BUG_ON(EFX_LED_DEFAULT != MC_CMD_LED_DEFAULT);
1316 BUILD_BUG_ON(MC_CMD_SET_ID_LED_OUT_LEN != 0);
1318 MCDI_SET_DWORD(inbuf, SET_ID_LED_IN_STATE, mode);
1320 rc = efx_mcdi_rpc(efx, MC_CMD_SET_ID_LED, inbuf, sizeof(inbuf),
1323 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
1327 static int efx_mcdi_reset_port(struct efx_nic *efx)
1329 int rc = efx_mcdi_rpc(efx, MC_CMD_ENTITY_RESET, NULL, 0, NULL, 0, NULL);
1331 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
1336 static int efx_mcdi_reset_mc(struct efx_nic *efx)
1338 MCDI_DECLARE_BUF(inbuf, MC_CMD_REBOOT_IN_LEN);
1341 BUILD_BUG_ON(MC_CMD_REBOOT_OUT_LEN != 0);
1342 MCDI_SET_DWORD(inbuf, REBOOT_IN_FLAGS, 0);
1343 rc = efx_mcdi_rpc(efx, MC_CMD_REBOOT, inbuf, sizeof(inbuf),
1345 /* White is black, and up is down */
1350 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1354 enum reset_type efx_mcdi_map_reset_reason(enum reset_type reason)
1356 return RESET_TYPE_RECOVER_OR_ALL;
1359 int efx_mcdi_reset(struct efx_nic *efx, enum reset_type method)
1363 /* Recover from a failed assertion pre-reset */
1364 rc = efx_mcdi_handle_assertion(efx);
1368 if (method == RESET_TYPE_WORLD)
1369 return efx_mcdi_reset_mc(efx);
1371 return efx_mcdi_reset_port(efx);
1374 static int efx_mcdi_wol_filter_set(struct efx_nic *efx, u32 type,
1375 const u8 *mac, int *id_out)
1377 MCDI_DECLARE_BUF(inbuf, MC_CMD_WOL_FILTER_SET_IN_LEN);
1378 MCDI_DECLARE_BUF(outbuf, MC_CMD_WOL_FILTER_SET_OUT_LEN);
1382 MCDI_SET_DWORD(inbuf, WOL_FILTER_SET_IN_WOL_TYPE, type);
1383 MCDI_SET_DWORD(inbuf, WOL_FILTER_SET_IN_FILTER_MODE,
1384 MC_CMD_FILTER_MODE_SIMPLE);
1385 memcpy(MCDI_PTR(inbuf, WOL_FILTER_SET_IN_MAGIC_MAC), mac, ETH_ALEN);
1387 rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_SET, inbuf, sizeof(inbuf),
1388 outbuf, sizeof(outbuf), &outlen);
1392 if (outlen < MC_CMD_WOL_FILTER_SET_OUT_LEN) {
1397 *id_out = (int)MCDI_DWORD(outbuf, WOL_FILTER_SET_OUT_FILTER_ID);
1403 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1410 efx_mcdi_wol_filter_set_magic(struct efx_nic *efx, const u8 *mac, int *id_out)
1412 return efx_mcdi_wol_filter_set(efx, MC_CMD_WOL_TYPE_MAGIC, mac, id_out);
1416 int efx_mcdi_wol_filter_get_magic(struct efx_nic *efx, int *id_out)
1418 MCDI_DECLARE_BUF(outbuf, MC_CMD_WOL_FILTER_GET_OUT_LEN);
1422 rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_GET, NULL, 0,
1423 outbuf, sizeof(outbuf), &outlen);
1427 if (outlen < MC_CMD_WOL_FILTER_GET_OUT_LEN) {
1432 *id_out = (int)MCDI_DWORD(outbuf, WOL_FILTER_GET_OUT_FILTER_ID);
1438 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1443 int efx_mcdi_wol_filter_remove(struct efx_nic *efx, int id)
1445 MCDI_DECLARE_BUF(inbuf, MC_CMD_WOL_FILTER_REMOVE_IN_LEN);
1448 MCDI_SET_DWORD(inbuf, WOL_FILTER_REMOVE_IN_FILTER_ID, (u32)id);
1450 rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_REMOVE, inbuf, sizeof(inbuf),
1458 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1462 int efx_mcdi_flush_rxqs(struct efx_nic *efx)
1464 struct efx_channel *channel;
1465 struct efx_rx_queue *rx_queue;
1466 MCDI_DECLARE_BUF(inbuf,
1467 MC_CMD_FLUSH_RX_QUEUES_IN_LEN(EFX_MAX_CHANNELS));
1470 BUILD_BUG_ON(EFX_MAX_CHANNELS >
1471 MC_CMD_FLUSH_RX_QUEUES_IN_QID_OFST_MAXNUM);
1474 efx_for_each_channel(channel, efx) {
1475 efx_for_each_channel_rx_queue(rx_queue, channel) {
1476 if (rx_queue->flush_pending) {
1477 rx_queue->flush_pending = false;
1478 atomic_dec(&efx->rxq_flush_pending);
1479 MCDI_SET_ARRAY_DWORD(
1480 inbuf, FLUSH_RX_QUEUES_IN_QID_OFST,
1481 count, efx_rx_queue_index(rx_queue));
1487 rc = efx_mcdi_rpc(efx, MC_CMD_FLUSH_RX_QUEUES, inbuf,
1488 MC_CMD_FLUSH_RX_QUEUES_IN_LEN(count), NULL, 0, NULL);
1494 int efx_mcdi_wol_filter_reset(struct efx_nic *efx)
1498 rc = efx_mcdi_rpc(efx, MC_CMD_WOL_FILTER_RESET, NULL, 0, NULL, 0, NULL);
1505 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1509 int efx_mcdi_set_workaround(struct efx_nic *efx, u32 type, bool enabled)
1511 MCDI_DECLARE_BUF(inbuf, MC_CMD_WORKAROUND_IN_LEN);
1513 BUILD_BUG_ON(MC_CMD_WORKAROUND_OUT_LEN != 0);
1514 MCDI_SET_DWORD(inbuf, WORKAROUND_IN_TYPE, type);
1515 MCDI_SET_DWORD(inbuf, WORKAROUND_IN_ENABLED, enabled);
1516 return efx_mcdi_rpc(efx, MC_CMD_WORKAROUND, inbuf, sizeof(inbuf),
1520 #ifdef CONFIG_SFC_MTD
1522 #define EFX_MCDI_NVRAM_LEN_MAX 128
1524 static int efx_mcdi_nvram_update_start(struct efx_nic *efx, unsigned int type)
1526 MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_START_IN_LEN);
1529 MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_START_IN_TYPE, type);
1531 BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_START_OUT_LEN != 0);
1533 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_START, inbuf, sizeof(inbuf),
1541 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1545 static int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,
1546 loff_t offset, u8 *buffer, size_t length)
1548 MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_READ_IN_LEN);
1549 MCDI_DECLARE_BUF(outbuf,
1550 MC_CMD_NVRAM_READ_OUT_LEN(EFX_MCDI_NVRAM_LEN_MAX));
1554 MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_TYPE, type);
1555 MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_OFFSET, offset);
1556 MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_LENGTH, length);
1558 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_READ, inbuf, sizeof(inbuf),
1559 outbuf, sizeof(outbuf), &outlen);
1563 memcpy(buffer, MCDI_PTR(outbuf, NVRAM_READ_OUT_READ_BUFFER), length);
1567 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1571 static int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,
1572 loff_t offset, const u8 *buffer, size_t length)
1574 MCDI_DECLARE_BUF(inbuf,
1575 MC_CMD_NVRAM_WRITE_IN_LEN(EFX_MCDI_NVRAM_LEN_MAX));
1578 MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_TYPE, type);
1579 MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_OFFSET, offset);
1580 MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_LENGTH, length);
1581 memcpy(MCDI_PTR(inbuf, NVRAM_WRITE_IN_WRITE_BUFFER), buffer, length);
1583 BUILD_BUG_ON(MC_CMD_NVRAM_WRITE_OUT_LEN != 0);
1585 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_WRITE, inbuf,
1586 ALIGN(MC_CMD_NVRAM_WRITE_IN_LEN(length), 4),
1594 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1598 static int efx_mcdi_nvram_erase(struct efx_nic *efx, unsigned int type,
1599 loff_t offset, size_t length)
1601 MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_ERASE_IN_LEN);
1604 MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_TYPE, type);
1605 MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_OFFSET, offset);
1606 MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_LENGTH, length);
1608 BUILD_BUG_ON(MC_CMD_NVRAM_ERASE_OUT_LEN != 0);
1610 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_ERASE, inbuf, sizeof(inbuf),
1618 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1622 static int efx_mcdi_nvram_update_finish(struct efx_nic *efx, unsigned int type)
1624 MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_FINISH_IN_LEN);
1627 MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_FINISH_IN_TYPE, type);
1629 BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_FINISH_OUT_LEN != 0);
1631 rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_FINISH, inbuf, sizeof(inbuf),
1639 netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
1643 int efx_mcdi_mtd_read(struct mtd_info *mtd, loff_t start,
1644 size_t len, size_t *retlen, u8 *buffer)
1646 struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1647 struct efx_nic *efx = mtd->priv;
1648 loff_t offset = start;
1649 loff_t end = min_t(loff_t, start + len, mtd->size);
1653 while (offset < end) {
1654 chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);
1655 rc = efx_mcdi_nvram_read(efx, part->nvram_type, offset,
1663 *retlen = offset - start;
1667 int efx_mcdi_mtd_erase(struct mtd_info *mtd, loff_t start, size_t len)
1669 struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1670 struct efx_nic *efx = mtd->priv;
1671 loff_t offset = start & ~((loff_t)(mtd->erasesize - 1));
1672 loff_t end = min_t(loff_t, start + len, mtd->size);
1673 size_t chunk = part->common.mtd.erasesize;
1676 if (!part->updating) {
1677 rc = efx_mcdi_nvram_update_start(efx, part->nvram_type);
1680 part->updating = true;
1683 /* The MCDI interface can in fact do multiple erase blocks at once;
1684 * but erasing may be slow, so we make multiple calls here to avoid
1685 * tripping the MCDI RPC timeout. */
1686 while (offset < end) {
1687 rc = efx_mcdi_nvram_erase(efx, part->nvram_type, offset,
1697 int efx_mcdi_mtd_write(struct mtd_info *mtd, loff_t start,
1698 size_t len, size_t *retlen, const u8 *buffer)
1700 struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1701 struct efx_nic *efx = mtd->priv;
1702 loff_t offset = start;
1703 loff_t end = min_t(loff_t, start + len, mtd->size);
1707 if (!part->updating) {
1708 rc = efx_mcdi_nvram_update_start(efx, part->nvram_type);
1711 part->updating = true;
1714 while (offset < end) {
1715 chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);
1716 rc = efx_mcdi_nvram_write(efx, part->nvram_type, offset,
1724 *retlen = offset - start;
1728 int efx_mcdi_mtd_sync(struct mtd_info *mtd)
1730 struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);
1731 struct efx_nic *efx = mtd->priv;
1734 if (part->updating) {
1735 part->updating = false;
1736 rc = efx_mcdi_nvram_update_finish(efx, part->nvram_type);
1742 void efx_mcdi_mtd_rename(struct efx_mtd_partition *part)
1744 struct efx_mcdi_mtd_partition *mcdi_part =
1745 container_of(part, struct efx_mcdi_mtd_partition, common);
1746 struct efx_nic *efx = part->mtd.priv;
1748 snprintf(part->name, sizeof(part->name), "%s %s:%02x",
1749 efx->name, part->type_name, mcdi_part->fw_subtype);
1752 #endif /* CONFIG_SFC_MTD */