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 <linux/moduleparam.h>
12 #include <linux/atomic.h>
13 #include "net_driver.h"
16 #include "farch_regs.h"
17 #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
;
46 efx_mcdi_async_completer
*complete
;
48 /* followed by request/response buffer */
51 static void efx_mcdi_timeout_async(unsigned long context
);
52 static int efx_mcdi_drv_attach(struct efx_nic
*efx
, bool driver_operating
,
53 bool *was_attached_out
);
54 static bool efx_mcdi_poll_once(struct efx_nic
*efx
);
55 static void efx_mcdi_abandon(struct efx_nic
*efx
);
57 #ifdef CONFIG_SFC_MCDI_LOGGING
58 static bool mcdi_logging_default
;
59 module_param(mcdi_logging_default
, bool, 0644);
60 MODULE_PARM_DESC(mcdi_logging_default
,
61 "Enable MCDI logging on newly-probed functions");
64 int efx_mcdi_init(struct efx_nic
*efx
)
66 struct efx_mcdi_iface
*mcdi
;
67 bool already_attached
;
70 efx
->mcdi
= kzalloc(sizeof(*efx
->mcdi
), GFP_KERNEL
);
76 #ifdef CONFIG_SFC_MCDI_LOGGING
77 /* consuming code assumes buffer is page-sized */
78 mcdi
->logging_buffer
= (char *)__get_free_page(GFP_KERNEL
);
79 if (!mcdi
->logging_buffer
)
81 mcdi
->logging_enabled
= mcdi_logging_default
;
83 init_waitqueue_head(&mcdi
->wq
);
84 init_waitqueue_head(&mcdi
->proxy_rx_wq
);
85 spin_lock_init(&mcdi
->iface_lock
);
86 mcdi
->state
= MCDI_STATE_QUIESCENT
;
87 mcdi
->mode
= MCDI_MODE_POLL
;
88 spin_lock_init(&mcdi
->async_lock
);
89 INIT_LIST_HEAD(&mcdi
->async_list
);
90 setup_timer(&mcdi
->async_timer
, efx_mcdi_timeout_async
,
93 (void) efx_mcdi_poll_reboot(efx
);
94 mcdi
->new_epoch
= true;
96 /* Recover from a failed assertion before probing */
97 rc
= efx_mcdi_handle_assertion(efx
);
101 /* Let the MC (and BMC, if this is a LOM) know that the driver
102 * is loaded. We should do this before we reset the NIC.
104 rc
= efx_mcdi_drv_attach(efx
, true, &already_attached
);
106 netif_err(efx
, probe
, efx
->net_dev
,
107 "Unable to register driver with MCPU\n");
110 if (already_attached
)
111 /* Not a fatal error */
112 netif_err(efx
, probe
, efx
->net_dev
,
113 "Host already registered with MCPU\n");
115 if (efx
->mcdi
->fn_flags
&
116 (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_PRIMARY
))
121 #ifdef CONFIG_SFC_MCDI_LOGGING
122 free_page((unsigned long)mcdi
->logging_buffer
);
131 void efx_mcdi_detach(struct efx_nic
*efx
)
136 BUG_ON(efx
->mcdi
->iface
.state
!= MCDI_STATE_QUIESCENT
);
138 /* Relinquish the device (back to the BMC, if this is a LOM) */
139 efx_mcdi_drv_attach(efx
, false, NULL
);
142 void efx_mcdi_fini(struct efx_nic
*efx
)
147 #ifdef CONFIG_SFC_MCDI_LOGGING
148 free_page((unsigned long)efx
->mcdi
->iface
.logging_buffer
);
154 static void efx_mcdi_send_request(struct efx_nic
*efx
, unsigned cmd
,
155 const efx_dword_t
*inbuf
, size_t inlen
)
157 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
158 #ifdef CONFIG_SFC_MCDI_LOGGING
159 char *buf
= mcdi
->logging_buffer
; /* page-sized */
165 BUG_ON(mcdi
->state
== MCDI_STATE_QUIESCENT
);
167 /* Serialise with efx_mcdi_ev_cpl() and efx_mcdi_ev_death() */
168 spin_lock_bh(&mcdi
->iface_lock
);
170 spin_unlock_bh(&mcdi
->iface_lock
);
172 seqno
= mcdi
->seqno
& SEQ_MASK
;
174 if (mcdi
->mode
== MCDI_MODE_EVENTS
)
175 xflags
|= MCDI_HEADER_XFLAGS_EVREQ
;
177 if (efx
->type
->mcdi_max_ver
== 1) {
179 EFX_POPULATE_DWORD_7(hdr
[0],
180 MCDI_HEADER_RESPONSE
, 0,
181 MCDI_HEADER_RESYNC
, 1,
182 MCDI_HEADER_CODE
, cmd
,
183 MCDI_HEADER_DATALEN
, inlen
,
184 MCDI_HEADER_SEQ
, seqno
,
185 MCDI_HEADER_XFLAGS
, xflags
,
186 MCDI_HEADER_NOT_EPOCH
, !mcdi
->new_epoch
);
190 BUG_ON(inlen
> MCDI_CTL_SDU_LEN_MAX_V2
);
191 EFX_POPULATE_DWORD_7(hdr
[0],
192 MCDI_HEADER_RESPONSE
, 0,
193 MCDI_HEADER_RESYNC
, 1,
194 MCDI_HEADER_CODE
, MC_CMD_V2_EXTN
,
195 MCDI_HEADER_DATALEN
, 0,
196 MCDI_HEADER_SEQ
, seqno
,
197 MCDI_HEADER_XFLAGS
, xflags
,
198 MCDI_HEADER_NOT_EPOCH
, !mcdi
->new_epoch
);
199 EFX_POPULATE_DWORD_2(hdr
[1],
200 MC_CMD_V2_EXTN_IN_EXTENDED_CMD
, cmd
,
201 MC_CMD_V2_EXTN_IN_ACTUAL_LEN
, inlen
);
205 #ifdef CONFIG_SFC_MCDI_LOGGING
206 if (mcdi
->logging_enabled
&& !WARN_ON_ONCE(!buf
)) {
209 /* Lengths should always be a whole number of dwords, so scream
212 WARN_ON_ONCE(hdr_len
% 4);
213 WARN_ON_ONCE(inlen
% 4);
215 /* We own the logging buffer, as only one MCDI can be in
216 * progress on a NIC at any one time. So no need for locking.
218 for (i
= 0; i
< hdr_len
/ 4 && bytes
< PAGE_SIZE
; i
++)
219 bytes
+= snprintf(buf
+ bytes
, PAGE_SIZE
- bytes
,
220 " %08x", le32_to_cpu(hdr
[i
].u32
[0]));
222 for (i
= 0; i
< inlen
/ 4 && bytes
< PAGE_SIZE
; i
++)
223 bytes
+= snprintf(buf
+ bytes
, PAGE_SIZE
- bytes
,
224 " %08x", le32_to_cpu(inbuf
[i
].u32
[0]));
226 netif_info(efx
, hw
, efx
->net_dev
, "MCDI RPC REQ:%s\n", buf
);
230 efx
->type
->mcdi_request(efx
, hdr
, hdr_len
, inbuf
, inlen
);
232 mcdi
->new_epoch
= false;
235 static int efx_mcdi_errno(unsigned int mcdi_err
)
240 #define TRANSLATE_ERROR(name) \
241 case MC_CMD_ERR_ ## name: \
243 TRANSLATE_ERROR(EPERM
);
244 TRANSLATE_ERROR(ENOENT
);
245 TRANSLATE_ERROR(EINTR
);
246 TRANSLATE_ERROR(EAGAIN
);
247 TRANSLATE_ERROR(EACCES
);
248 TRANSLATE_ERROR(EBUSY
);
249 TRANSLATE_ERROR(EINVAL
);
250 TRANSLATE_ERROR(EDEADLK
);
251 TRANSLATE_ERROR(ENOSYS
);
252 TRANSLATE_ERROR(ETIME
);
253 TRANSLATE_ERROR(EALREADY
);
254 TRANSLATE_ERROR(ENOSPC
);
255 #undef TRANSLATE_ERROR
256 case MC_CMD_ERR_ENOTSUP
:
258 case MC_CMD_ERR_ALLOC_FAIL
:
260 case MC_CMD_ERR_MAC_EXIST
:
267 static void efx_mcdi_read_response_header(struct efx_nic
*efx
)
269 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
270 unsigned int respseq
, respcmd
, error
;
271 #ifdef CONFIG_SFC_MCDI_LOGGING
272 char *buf
= mcdi
->logging_buffer
; /* page-sized */
276 efx
->type
->mcdi_read_response(efx
, &hdr
, 0, 4);
277 respseq
= EFX_DWORD_FIELD(hdr
, MCDI_HEADER_SEQ
);
278 respcmd
= EFX_DWORD_FIELD(hdr
, MCDI_HEADER_CODE
);
279 error
= EFX_DWORD_FIELD(hdr
, MCDI_HEADER_ERROR
);
281 if (respcmd
!= MC_CMD_V2_EXTN
) {
282 mcdi
->resp_hdr_len
= 4;
283 mcdi
->resp_data_len
= EFX_DWORD_FIELD(hdr
, MCDI_HEADER_DATALEN
);
285 efx
->type
->mcdi_read_response(efx
, &hdr
, 4, 4);
286 mcdi
->resp_hdr_len
= 8;
287 mcdi
->resp_data_len
=
288 EFX_DWORD_FIELD(hdr
, MC_CMD_V2_EXTN_IN_ACTUAL_LEN
);
291 #ifdef CONFIG_SFC_MCDI_LOGGING
292 if (mcdi
->logging_enabled
&& !WARN_ON_ONCE(!buf
)) {
293 size_t hdr_len
, data_len
;
297 WARN_ON_ONCE(mcdi
->resp_hdr_len
% 4);
298 hdr_len
= mcdi
->resp_hdr_len
/ 4;
299 /* MCDI_DECLARE_BUF ensures that underlying buffer is padded
300 * to dword size, and the MCDI buffer is always dword size
302 data_len
= DIV_ROUND_UP(mcdi
->resp_data_len
, 4);
304 /* We own the logging buffer, as only one MCDI can be in
305 * progress on a NIC at any one time. So no need for locking.
307 for (i
= 0; i
< hdr_len
&& bytes
< PAGE_SIZE
; i
++) {
308 efx
->type
->mcdi_read_response(efx
, &hdr
, (i
* 4), 4);
309 bytes
+= snprintf(buf
+ bytes
, PAGE_SIZE
- bytes
,
310 " %08x", le32_to_cpu(hdr
.u32
[0]));
313 for (i
= 0; i
< data_len
&& bytes
< PAGE_SIZE
; i
++) {
314 efx
->type
->mcdi_read_response(efx
, &hdr
,
315 mcdi
->resp_hdr_len
+ (i
* 4), 4);
316 bytes
+= snprintf(buf
+ bytes
, PAGE_SIZE
- bytes
,
317 " %08x", le32_to_cpu(hdr
.u32
[0]));
320 netif_info(efx
, hw
, efx
->net_dev
, "MCDI RPC RESP:%s\n", buf
);
324 mcdi
->resprc_raw
= 0;
325 if (error
&& mcdi
->resp_data_len
== 0) {
326 netif_err(efx
, hw
, efx
->net_dev
, "MC rebooted\n");
328 } else if ((respseq
^ mcdi
->seqno
) & SEQ_MASK
) {
329 netif_err(efx
, hw
, efx
->net_dev
,
330 "MC response mismatch tx seq 0x%x rx seq 0x%x\n",
331 respseq
, mcdi
->seqno
);
334 efx
->type
->mcdi_read_response(efx
, &hdr
, mcdi
->resp_hdr_len
, 4);
335 mcdi
->resprc_raw
= EFX_DWORD_FIELD(hdr
, EFX_DWORD_0
);
336 mcdi
->resprc
= efx_mcdi_errno(mcdi
->resprc_raw
);
342 static bool efx_mcdi_poll_once(struct efx_nic
*efx
)
344 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
347 if (!efx
->type
->mcdi_poll_response(efx
))
350 spin_lock_bh(&mcdi
->iface_lock
);
351 efx_mcdi_read_response_header(efx
);
352 spin_unlock_bh(&mcdi
->iface_lock
);
357 static int efx_mcdi_poll(struct efx_nic
*efx
)
359 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
360 unsigned long time
, finish
;
364 /* Check for a reboot atomically with respect to efx_mcdi_copyout() */
365 rc
= efx_mcdi_poll_reboot(efx
);
367 spin_lock_bh(&mcdi
->iface_lock
);
369 mcdi
->resp_hdr_len
= 0;
370 mcdi
->resp_data_len
= 0;
371 spin_unlock_bh(&mcdi
->iface_lock
);
375 /* Poll for completion. Poll quickly (once a us) for the 1st jiffy,
376 * because generally mcdi responses are fast. After that, back off
377 * and poll once a jiffy (approximately)
380 finish
= jiffies
+ MCDI_RPC_TIMEOUT
;
387 schedule_timeout_uninterruptible(1);
392 if (efx_mcdi_poll_once(efx
))
395 if (time_after(time
, finish
))
399 /* Return rc=0 like wait_event_timeout() */
403 /* Test and clear MC-rebooted flag for this port/function; reset
404 * software state as necessary.
406 int efx_mcdi_poll_reboot(struct efx_nic
*efx
)
411 return efx
->type
->mcdi_poll_reboot(efx
);
414 static bool efx_mcdi_acquire_async(struct efx_mcdi_iface
*mcdi
)
416 return cmpxchg(&mcdi
->state
,
417 MCDI_STATE_QUIESCENT
, MCDI_STATE_RUNNING_ASYNC
) ==
418 MCDI_STATE_QUIESCENT
;
421 static void efx_mcdi_acquire_sync(struct efx_mcdi_iface
*mcdi
)
423 /* Wait until the interface becomes QUIESCENT and we win the race
424 * to mark it RUNNING_SYNC.
427 cmpxchg(&mcdi
->state
,
428 MCDI_STATE_QUIESCENT
, MCDI_STATE_RUNNING_SYNC
) ==
429 MCDI_STATE_QUIESCENT
);
432 static int efx_mcdi_await_completion(struct efx_nic
*efx
)
434 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
436 if (wait_event_timeout(mcdi
->wq
, mcdi
->state
== MCDI_STATE_COMPLETED
,
437 MCDI_RPC_TIMEOUT
) == 0)
440 /* Check if efx_mcdi_set_mode() switched us back to polled completions.
441 * In which case, poll for completions directly. If efx_mcdi_ev_cpl()
442 * completed the request first, then we'll just end up completing the
443 * request again, which is safe.
445 * We need an smp_rmb() to synchronise with efx_mcdi_mode_poll(), which
446 * wait_event_timeout() implicitly provides.
448 if (mcdi
->mode
== MCDI_MODE_POLL
)
449 return efx_mcdi_poll(efx
);
454 /* If the interface is RUNNING_SYNC, switch to COMPLETED and wake the
455 * requester. Return whether this was done. Does not take any locks.
457 static bool efx_mcdi_complete_sync(struct efx_mcdi_iface
*mcdi
)
459 if (cmpxchg(&mcdi
->state
,
460 MCDI_STATE_RUNNING_SYNC
, MCDI_STATE_COMPLETED
) ==
461 MCDI_STATE_RUNNING_SYNC
) {
469 static void efx_mcdi_release(struct efx_mcdi_iface
*mcdi
)
471 if (mcdi
->mode
== MCDI_MODE_EVENTS
) {
472 struct efx_mcdi_async_param
*async
;
473 struct efx_nic
*efx
= mcdi
->efx
;
475 /* Process the asynchronous request queue */
476 spin_lock_bh(&mcdi
->async_lock
);
477 async
= list_first_entry_or_null(
478 &mcdi
->async_list
, struct efx_mcdi_async_param
, list
);
480 mcdi
->state
= MCDI_STATE_RUNNING_ASYNC
;
481 efx_mcdi_send_request(efx
, async
->cmd
,
482 (const efx_dword_t
*)(async
+ 1),
484 mod_timer(&mcdi
->async_timer
,
485 jiffies
+ MCDI_RPC_TIMEOUT
);
487 spin_unlock_bh(&mcdi
->async_lock
);
493 mcdi
->state
= MCDI_STATE_QUIESCENT
;
497 /* If the interface is RUNNING_ASYNC, switch to COMPLETED, call the
498 * asynchronous completion function, and release the interface.
499 * Return whether this was done. Must be called in bh-disabled
500 * context. Will take iface_lock and async_lock.
502 static bool efx_mcdi_complete_async(struct efx_mcdi_iface
*mcdi
, bool timeout
)
504 struct efx_nic
*efx
= mcdi
->efx
;
505 struct efx_mcdi_async_param
*async
;
506 size_t hdr_len
, data_len
, err_len
;
508 MCDI_DECLARE_BUF_ERR(errbuf
);
511 if (cmpxchg(&mcdi
->state
,
512 MCDI_STATE_RUNNING_ASYNC
, MCDI_STATE_COMPLETED
) !=
513 MCDI_STATE_RUNNING_ASYNC
)
516 spin_lock(&mcdi
->iface_lock
);
518 /* Ensure that if the completion event arrives later,
519 * the seqno check in efx_mcdi_ev_cpl() will fail
528 hdr_len
= mcdi
->resp_hdr_len
;
529 data_len
= mcdi
->resp_data_len
;
531 spin_unlock(&mcdi
->iface_lock
);
533 /* Stop the timer. In case the timer function is running, we
534 * must wait for it to return so that there is no possibility
535 * of it aborting the next request.
538 del_timer_sync(&mcdi
->async_timer
);
540 spin_lock(&mcdi
->async_lock
);
541 async
= list_first_entry(&mcdi
->async_list
,
542 struct efx_mcdi_async_param
, list
);
543 list_del(&async
->list
);
544 spin_unlock(&mcdi
->async_lock
);
546 outbuf
= (efx_dword_t
*)(async
+ 1);
547 efx
->type
->mcdi_read_response(efx
, outbuf
, hdr_len
,
548 min(async
->outlen
, data_len
));
549 if (!timeout
&& rc
&& !async
->quiet
) {
550 err_len
= min(sizeof(errbuf
), data_len
);
551 efx
->type
->mcdi_read_response(efx
, errbuf
, hdr_len
,
553 efx_mcdi_display_error(efx
, async
->cmd
, async
->inlen
, errbuf
,
558 async
->complete(efx
, async
->cookie
, rc
, outbuf
,
559 min(async
->outlen
, data_len
));
562 efx_mcdi_release(mcdi
);
567 static void efx_mcdi_ev_cpl(struct efx_nic
*efx
, unsigned int seqno
,
568 unsigned int datalen
, unsigned int mcdi_err
)
570 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
573 spin_lock(&mcdi
->iface_lock
);
575 if ((seqno
^ mcdi
->seqno
) & SEQ_MASK
) {
577 /* The request has been cancelled */
580 netif_err(efx
, hw
, efx
->net_dev
,
581 "MC response mismatch tx seq 0x%x rx "
582 "seq 0x%x\n", seqno
, mcdi
->seqno
);
584 if (efx
->type
->mcdi_max_ver
>= 2) {
585 /* MCDI v2 responses don't fit in an event */
586 efx_mcdi_read_response_header(efx
);
588 mcdi
->resprc
= efx_mcdi_errno(mcdi_err
);
589 mcdi
->resp_hdr_len
= 4;
590 mcdi
->resp_data_len
= datalen
;
596 spin_unlock(&mcdi
->iface_lock
);
599 if (!efx_mcdi_complete_async(mcdi
, false))
600 (void) efx_mcdi_complete_sync(mcdi
);
602 /* If the interface isn't RUNNING_ASYNC or
603 * RUNNING_SYNC then we've received a duplicate
604 * completion after we've already transitioned back to
605 * QUIESCENT. [A subsequent invocation would increment
606 * seqno, so would have failed the seqno check].
611 static void efx_mcdi_timeout_async(unsigned long context
)
613 struct efx_mcdi_iface
*mcdi
= (struct efx_mcdi_iface
*)context
;
615 efx_mcdi_complete_async(mcdi
, true);
619 efx_mcdi_check_supported(struct efx_nic
*efx
, unsigned int cmd
, size_t inlen
)
621 if (efx
->type
->mcdi_max_ver
< 0 ||
622 (efx
->type
->mcdi_max_ver
< 2 &&
623 cmd
> MC_CMD_CMD_SPACE_ESCAPE_7
))
626 if (inlen
> MCDI_CTL_SDU_LEN_MAX_V2
||
627 (efx
->type
->mcdi_max_ver
< 2 &&
628 inlen
> MCDI_CTL_SDU_LEN_MAX_V1
))
634 static bool efx_mcdi_get_proxy_handle(struct efx_nic
*efx
,
635 size_t hdr_len
, size_t data_len
,
638 MCDI_DECLARE_BUF_ERR(testbuf
);
639 const size_t buflen
= sizeof(testbuf
);
641 if (!proxy_handle
|| data_len
< buflen
)
644 efx
->type
->mcdi_read_response(efx
, testbuf
, hdr_len
, buflen
);
645 if (MCDI_DWORD(testbuf
, ERR_CODE
) == MC_CMD_ERR_PROXY_PENDING
) {
646 *proxy_handle
= MCDI_DWORD(testbuf
, ERR_PROXY_PENDING_HANDLE
);
653 static int _efx_mcdi_rpc_finish(struct efx_nic
*efx
, unsigned int cmd
,
655 efx_dword_t
*outbuf
, size_t outlen
,
656 size_t *outlen_actual
, bool quiet
,
657 u32
*proxy_handle
, int *raw_rc
)
659 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
660 MCDI_DECLARE_BUF_ERR(errbuf
);
663 if (mcdi
->mode
== MCDI_MODE_POLL
)
664 rc
= efx_mcdi_poll(efx
);
666 rc
= efx_mcdi_await_completion(efx
);
669 netif_err(efx
, hw
, efx
->net_dev
,
670 "MC command 0x%x inlen %d mode %d timed out\n",
671 cmd
, (int)inlen
, mcdi
->mode
);
673 if (mcdi
->mode
== MCDI_MODE_EVENTS
&& efx_mcdi_poll_once(efx
)) {
674 netif_err(efx
, hw
, efx
->net_dev
,
675 "MCDI request was completed without an event\n");
679 efx_mcdi_abandon(efx
);
681 /* Close the race with efx_mcdi_ev_cpl() executing just too late
682 * and completing a request we've just cancelled, by ensuring
683 * that the seqno check therein fails.
685 spin_lock_bh(&mcdi
->iface_lock
);
688 spin_unlock_bh(&mcdi
->iface_lock
);
698 size_t hdr_len
, data_len
, err_len
;
700 /* At the very least we need a memory barrier here to ensure
701 * we pick up changes from efx_mcdi_ev_cpl(). Protect against
702 * a spurious efx_mcdi_ev_cpl() running concurrently by
703 * acquiring the iface_lock. */
704 spin_lock_bh(&mcdi
->iface_lock
);
707 *raw_rc
= mcdi
->resprc_raw
;
708 hdr_len
= mcdi
->resp_hdr_len
;
709 data_len
= mcdi
->resp_data_len
;
710 err_len
= min(sizeof(errbuf
), data_len
);
711 spin_unlock_bh(&mcdi
->iface_lock
);
715 efx
->type
->mcdi_read_response(efx
, outbuf
, hdr_len
,
716 min(outlen
, data_len
));
718 *outlen_actual
= data_len
;
720 efx
->type
->mcdi_read_response(efx
, errbuf
, hdr_len
, err_len
);
722 if (cmd
== MC_CMD_REBOOT
&& rc
== -EIO
) {
723 /* Don't reset if MC_CMD_REBOOT returns EIO */
724 } else if (rc
== -EIO
|| rc
== -EINTR
) {
725 netif_err(efx
, hw
, efx
->net_dev
, "MC reboot detected\n");
726 netif_dbg(efx
, hw
, efx
->net_dev
, "MC rebooted during command %d rc %d\n",
728 if (efx
->type
->mcdi_reboot_detected
)
729 efx
->type
->mcdi_reboot_detected(efx
);
730 efx_schedule_reset(efx
, RESET_TYPE_MC_FAILURE
);
731 } else if (proxy_handle
&& (rc
== -EPROTO
) &&
732 efx_mcdi_get_proxy_handle(efx
, hdr_len
, data_len
,
734 mcdi
->proxy_rx_status
= 0;
735 mcdi
->proxy_rx_handle
= 0;
736 mcdi
->state
= MCDI_STATE_PROXY_WAIT
;
737 } else if (rc
&& !quiet
) {
738 efx_mcdi_display_error(efx
, cmd
, inlen
, errbuf
, err_len
,
742 if (rc
== -EIO
|| rc
== -EINTR
) {
743 msleep(MCDI_STATUS_SLEEP_MS
);
744 efx_mcdi_poll_reboot(efx
);
745 mcdi
->new_epoch
= true;
749 if (!proxy_handle
|| !*proxy_handle
)
750 efx_mcdi_release(mcdi
);
754 static void efx_mcdi_proxy_abort(struct efx_mcdi_iface
*mcdi
)
756 if (mcdi
->state
== MCDI_STATE_PROXY_WAIT
) {
757 /* Interrupt the proxy wait. */
758 mcdi
->proxy_rx_status
= -EINTR
;
759 wake_up(&mcdi
->proxy_rx_wq
);
763 static void efx_mcdi_ev_proxy_response(struct efx_nic
*efx
,
764 u32 handle
, int status
)
766 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
768 WARN_ON(mcdi
->state
!= MCDI_STATE_PROXY_WAIT
);
770 mcdi
->proxy_rx_status
= efx_mcdi_errno(status
);
771 /* Ensure the status is written before we update the handle, since the
772 * latter is used to check if we've finished.
775 mcdi
->proxy_rx_handle
= handle
;
776 wake_up(&mcdi
->proxy_rx_wq
);
779 static int efx_mcdi_proxy_wait(struct efx_nic
*efx
, u32 handle
, bool quiet
)
781 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
784 /* Wait for a proxy event, or timeout. */
785 rc
= wait_event_timeout(mcdi
->proxy_rx_wq
,
786 mcdi
->proxy_rx_handle
!= 0 ||
787 mcdi
->proxy_rx_status
== -EINTR
,
791 netif_dbg(efx
, hw
, efx
->net_dev
,
792 "MCDI proxy timeout %d\n", handle
);
794 } else if (mcdi
->proxy_rx_handle
!= handle
) {
795 netif_warn(efx
, hw
, efx
->net_dev
,
796 "MCDI proxy unexpected handle %d (expected %d)\n",
797 mcdi
->proxy_rx_handle
, handle
);
801 return mcdi
->proxy_rx_status
;
804 static int _efx_mcdi_rpc(struct efx_nic
*efx
, unsigned int cmd
,
805 const efx_dword_t
*inbuf
, size_t inlen
,
806 efx_dword_t
*outbuf
, size_t outlen
,
807 size_t *outlen_actual
, bool quiet
, int *raw_rc
)
809 u32 proxy_handle
= 0; /* Zero is an invalid proxy handle. */
812 if (inbuf
&& inlen
&& (inbuf
== outbuf
)) {
813 /* The input buffer can't be aliased with the output. */
818 rc
= efx_mcdi_rpc_start(efx
, cmd
, inbuf
, inlen
);
822 rc
= _efx_mcdi_rpc_finish(efx
, cmd
, inlen
, outbuf
, outlen
,
823 outlen_actual
, quiet
, &proxy_handle
, raw_rc
);
826 /* Handle proxy authorisation. This allows approval of MCDI
827 * operations to be delegated to the admin function, allowing
828 * fine control over (eg) multicast subscriptions.
830 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
832 netif_dbg(efx
, hw
, efx
->net_dev
,
833 "MCDI waiting for proxy auth %d\n",
835 rc
= efx_mcdi_proxy_wait(efx
, proxy_handle
, quiet
);
838 netif_dbg(efx
, hw
, efx
->net_dev
,
839 "MCDI proxy retry %d\n", proxy_handle
);
841 /* We now retry the original request. */
842 mcdi
->state
= MCDI_STATE_RUNNING_SYNC
;
843 efx_mcdi_send_request(efx
, cmd
, inbuf
, inlen
);
845 rc
= _efx_mcdi_rpc_finish(efx
, cmd
, inlen
,
846 outbuf
, outlen
, outlen_actual
,
847 quiet
, NULL
, raw_rc
);
849 netif_cond_dbg(efx
, hw
, efx
->net_dev
, rc
== -EPERM
, err
,
850 "MC command 0x%x failed after proxy auth rc=%d\n",
853 if (rc
== -EINTR
|| rc
== -EIO
)
854 efx_schedule_reset(efx
, RESET_TYPE_MC_FAILURE
);
855 efx_mcdi_release(mcdi
);
862 static int _efx_mcdi_rpc_evb_retry(struct efx_nic
*efx
, unsigned cmd
,
863 const efx_dword_t
*inbuf
, size_t inlen
,
864 efx_dword_t
*outbuf
, size_t outlen
,
865 size_t *outlen_actual
, bool quiet
)
870 rc
= _efx_mcdi_rpc(efx
, cmd
, inbuf
, inlen
,
871 outbuf
, outlen
, outlen_actual
, true, &raw_rc
);
873 if ((rc
== -EPROTO
) && (raw_rc
== MC_CMD_ERR_NO_EVB_PORT
) &&
875 /* If the EVB port isn't available within a VF this may
876 * mean the PF is still bringing the switch up. We should
877 * retry our request shortly.
879 unsigned long abort_time
= jiffies
+ MCDI_RPC_TIMEOUT
;
880 unsigned int delay_us
= 10000;
882 netif_dbg(efx
, hw
, efx
->net_dev
,
883 "%s: NO_EVB_PORT; will retry request\n",
887 usleep_range(delay_us
, delay_us
+ 10000);
888 rc
= _efx_mcdi_rpc(efx
, cmd
, inbuf
, inlen
,
889 outbuf
, outlen
, outlen_actual
,
891 if (delay_us
< 100000)
893 } while ((rc
== -EPROTO
) &&
894 (raw_rc
== MC_CMD_ERR_NO_EVB_PORT
) &&
895 time_before(jiffies
, abort_time
));
898 if (rc
&& !quiet
&& !(cmd
== MC_CMD_REBOOT
&& rc
== -EIO
))
899 efx_mcdi_display_error(efx
, cmd
, inlen
,
906 * efx_mcdi_rpc - Issue an MCDI command and wait for completion
907 * @efx: NIC through which to issue the command
908 * @cmd: Command type number
909 * @inbuf: Command parameters
910 * @inlen: Length of command parameters, in bytes. Must be a multiple
911 * of 4 and no greater than %MCDI_CTL_SDU_LEN_MAX_V1.
912 * @outbuf: Response buffer. May be %NULL if @outlen is 0.
913 * @outlen: Length of response buffer, in bytes. If the actual
914 * response is longer than @outlen & ~3, it will be truncated
916 * @outlen_actual: Pointer through which to return the actual response
917 * length. May be %NULL if this is not needed.
919 * This function may sleep and therefore must be called in an appropriate
922 * Return: A negative error code, or zero if successful. The error
923 * code may come from the MCDI response or may indicate a failure
924 * to communicate with the MC. In the former case, the response
925 * will still be copied to @outbuf and *@outlen_actual will be
926 * set accordingly. In the latter case, *@outlen_actual will be
929 int efx_mcdi_rpc(struct efx_nic
*efx
, unsigned cmd
,
930 const efx_dword_t
*inbuf
, size_t inlen
,
931 efx_dword_t
*outbuf
, size_t outlen
,
932 size_t *outlen_actual
)
934 return _efx_mcdi_rpc_evb_retry(efx
, cmd
, inbuf
, inlen
, outbuf
, outlen
,
935 outlen_actual
, false);
938 /* Normally, on receiving an error code in the MCDI response,
939 * efx_mcdi_rpc will log an error message containing (among other
940 * things) the raw error code, by means of efx_mcdi_display_error.
941 * This _quiet version suppresses that; if the caller wishes to log
942 * the error conditionally on the return code, it should call this
943 * function and is then responsible for calling efx_mcdi_display_error
946 int efx_mcdi_rpc_quiet(struct efx_nic
*efx
, unsigned cmd
,
947 const efx_dword_t
*inbuf
, size_t inlen
,
948 efx_dword_t
*outbuf
, size_t outlen
,
949 size_t *outlen_actual
)
951 return _efx_mcdi_rpc_evb_retry(efx
, cmd
, inbuf
, inlen
, outbuf
, outlen
,
952 outlen_actual
, true);
955 int efx_mcdi_rpc_start(struct efx_nic
*efx
, unsigned cmd
,
956 const efx_dword_t
*inbuf
, size_t inlen
)
958 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
961 rc
= efx_mcdi_check_supported(efx
, cmd
, inlen
);
965 if (efx
->mc_bist_for_other_fn
)
968 if (mcdi
->mode
== MCDI_MODE_FAIL
)
971 efx_mcdi_acquire_sync(mcdi
);
972 efx_mcdi_send_request(efx
, cmd
, inbuf
, inlen
);
976 static int _efx_mcdi_rpc_async(struct efx_nic
*efx
, unsigned int cmd
,
977 const efx_dword_t
*inbuf
, size_t inlen
,
979 efx_mcdi_async_completer
*complete
,
980 unsigned long cookie
, bool quiet
)
982 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
983 struct efx_mcdi_async_param
*async
;
986 rc
= efx_mcdi_check_supported(efx
, cmd
, inlen
);
990 if (efx
->mc_bist_for_other_fn
)
993 async
= kmalloc(sizeof(*async
) + ALIGN(max(inlen
, outlen
), 4),
999 async
->inlen
= inlen
;
1000 async
->outlen
= outlen
;
1001 async
->quiet
= quiet
;
1002 async
->complete
= complete
;
1003 async
->cookie
= cookie
;
1004 memcpy(async
+ 1, inbuf
, inlen
);
1006 spin_lock_bh(&mcdi
->async_lock
);
1008 if (mcdi
->mode
== MCDI_MODE_EVENTS
) {
1009 list_add_tail(&async
->list
, &mcdi
->async_list
);
1011 /* If this is at the front of the queue, try to start it
1014 if (mcdi
->async_list
.next
== &async
->list
&&
1015 efx_mcdi_acquire_async(mcdi
)) {
1016 efx_mcdi_send_request(efx
, cmd
, inbuf
, inlen
);
1017 mod_timer(&mcdi
->async_timer
,
1018 jiffies
+ MCDI_RPC_TIMEOUT
);
1025 spin_unlock_bh(&mcdi
->async_lock
);
1031 * efx_mcdi_rpc_async - Schedule an MCDI command to run asynchronously
1032 * @efx: NIC through which to issue the command
1033 * @cmd: Command type number
1034 * @inbuf: Command parameters
1035 * @inlen: Length of command parameters, in bytes
1036 * @outlen: Length to allocate for response buffer, in bytes
1037 * @complete: Function to be called on completion or cancellation.
1038 * @cookie: Arbitrary value to be passed to @complete.
1040 * This function does not sleep and therefore may be called in atomic
1041 * context. It will fail if event queues are disabled or if MCDI
1042 * event completions have been disabled due to an error.
1044 * If it succeeds, the @complete function will be called exactly once
1045 * in atomic context, when one of the following occurs:
1046 * (a) the completion event is received (in NAPI context)
1047 * (b) event queues are disabled (in the process that disables them)
1048 * (c) the request times-out (in timer context)
1051 efx_mcdi_rpc_async(struct efx_nic
*efx
, unsigned int cmd
,
1052 const efx_dword_t
*inbuf
, size_t inlen
, size_t outlen
,
1053 efx_mcdi_async_completer
*complete
, unsigned long cookie
)
1055 return _efx_mcdi_rpc_async(efx
, cmd
, inbuf
, inlen
, outlen
, complete
,
1059 int efx_mcdi_rpc_async_quiet(struct efx_nic
*efx
, unsigned int cmd
,
1060 const efx_dword_t
*inbuf
, size_t inlen
,
1061 size_t outlen
, efx_mcdi_async_completer
*complete
,
1062 unsigned long cookie
)
1064 return _efx_mcdi_rpc_async(efx
, cmd
, inbuf
, inlen
, outlen
, complete
,
1068 int efx_mcdi_rpc_finish(struct efx_nic
*efx
, unsigned cmd
, size_t inlen
,
1069 efx_dword_t
*outbuf
, size_t outlen
,
1070 size_t *outlen_actual
)
1072 return _efx_mcdi_rpc_finish(efx
, cmd
, inlen
, outbuf
, outlen
,
1073 outlen_actual
, false, NULL
, NULL
);
1076 int efx_mcdi_rpc_finish_quiet(struct efx_nic
*efx
, unsigned cmd
, size_t inlen
,
1077 efx_dword_t
*outbuf
, size_t outlen
,
1078 size_t *outlen_actual
)
1080 return _efx_mcdi_rpc_finish(efx
, cmd
, inlen
, outbuf
, outlen
,
1081 outlen_actual
, true, NULL
, NULL
);
1084 void efx_mcdi_display_error(struct efx_nic
*efx
, unsigned cmd
,
1085 size_t inlen
, efx_dword_t
*outbuf
,
1086 size_t outlen
, int rc
)
1088 int code
= 0, err_arg
= 0;
1090 if (outlen
>= MC_CMD_ERR_CODE_OFST
+ 4)
1091 code
= MCDI_DWORD(outbuf
, ERR_CODE
);
1092 if (outlen
>= MC_CMD_ERR_ARG_OFST
+ 4)
1093 err_arg
= MCDI_DWORD(outbuf
, ERR_ARG
);
1094 netif_cond_dbg(efx
, hw
, efx
->net_dev
, rc
== -EPERM
, err
,
1095 "MC command 0x%x inlen %zu failed rc=%d (raw=%d) arg=%d\n",
1096 cmd
, inlen
, rc
, code
, err_arg
);
1099 /* Switch to polled MCDI completions. This can be called in various
1100 * error conditions with various locks held, so it must be lockless.
1101 * Caller is responsible for flushing asynchronous requests later.
1103 void efx_mcdi_mode_poll(struct efx_nic
*efx
)
1105 struct efx_mcdi_iface
*mcdi
;
1110 mcdi
= efx_mcdi(efx
);
1111 /* If already in polling mode, nothing to do.
1112 * If in fail-fast state, don't switch to polled completion.
1113 * FLR recovery will do that later.
1115 if (mcdi
->mode
== MCDI_MODE_POLL
|| mcdi
->mode
== MCDI_MODE_FAIL
)
1118 /* We can switch from event completion to polled completion, because
1119 * mcdi requests are always completed in shared memory. We do this by
1120 * switching the mode to POLL'd then completing the request.
1121 * efx_mcdi_await_completion() will then call efx_mcdi_poll().
1123 * We need an smp_wmb() to synchronise with efx_mcdi_await_completion(),
1124 * which efx_mcdi_complete_sync() provides for us.
1126 mcdi
->mode
= MCDI_MODE_POLL
;
1128 efx_mcdi_complete_sync(mcdi
);
1131 /* Flush any running or queued asynchronous requests, after event processing
1134 void efx_mcdi_flush_async(struct efx_nic
*efx
)
1136 struct efx_mcdi_async_param
*async
, *next
;
1137 struct efx_mcdi_iface
*mcdi
;
1142 mcdi
= efx_mcdi(efx
);
1144 /* We must be in poll or fail mode so no more requests can be queued */
1145 BUG_ON(mcdi
->mode
== MCDI_MODE_EVENTS
);
1147 del_timer_sync(&mcdi
->async_timer
);
1149 /* If a request is still running, make sure we give the MC
1150 * time to complete it so that the response won't overwrite our
1153 if (mcdi
->state
== MCDI_STATE_RUNNING_ASYNC
) {
1155 mcdi
->state
= MCDI_STATE_QUIESCENT
;
1158 /* Nothing else will access the async list now, so it is safe
1159 * to walk it without holding async_lock. If we hold it while
1160 * calling a completer then lockdep may warn that we have
1161 * acquired locks in the wrong order.
1163 list_for_each_entry_safe(async
, next
, &mcdi
->async_list
, list
) {
1164 if (async
->complete
)
1165 async
->complete(efx
, async
->cookie
, -ENETDOWN
, NULL
, 0);
1166 list_del(&async
->list
);
1171 void efx_mcdi_mode_event(struct efx_nic
*efx
)
1173 struct efx_mcdi_iface
*mcdi
;
1178 mcdi
= efx_mcdi(efx
);
1179 /* If already in event completion mode, nothing to do.
1180 * If in fail-fast state, don't switch to event completion. FLR
1181 * recovery will do that later.
1183 if (mcdi
->mode
== MCDI_MODE_EVENTS
|| mcdi
->mode
== MCDI_MODE_FAIL
)
1186 /* We can't switch from polled to event completion in the middle of a
1187 * request, because the completion method is specified in the request.
1188 * So acquire the interface to serialise the requestors. We don't need
1189 * to acquire the iface_lock to change the mode here, but we do need a
1190 * write memory barrier ensure that efx_mcdi_rpc() sees it, which
1191 * efx_mcdi_acquire() provides.
1193 efx_mcdi_acquire_sync(mcdi
);
1194 mcdi
->mode
= MCDI_MODE_EVENTS
;
1195 efx_mcdi_release(mcdi
);
1198 static void efx_mcdi_ev_death(struct efx_nic
*efx
, int rc
)
1200 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
1202 /* If there is an outstanding MCDI request, it has been terminated
1203 * either by a BADASSERT or REBOOT event. If the mcdi interface is
1204 * in polled mode, then do nothing because the MC reboot handler will
1205 * set the header correctly. However, if the mcdi interface is waiting
1206 * for a CMDDONE event it won't receive it [and since all MCDI events
1207 * are sent to the same queue, we can't be racing with
1208 * efx_mcdi_ev_cpl()]
1210 * If there is an outstanding asynchronous request, we can't
1211 * complete it now (efx_mcdi_complete() would deadlock). The
1212 * reset process will take care of this.
1214 * There's a race here with efx_mcdi_send_request(), because
1215 * we might receive a REBOOT event *before* the request has
1216 * been copied out. In polled mode (during startup) this is
1217 * irrelevant, because efx_mcdi_complete_sync() is ignored. In
1218 * event mode, this condition is just an edge-case of
1219 * receiving a REBOOT event after posting the MCDI
1220 * request. Did the mc reboot before or after the copyout? The
1221 * best we can do always is just return failure.
1223 * If there is an outstanding proxy response expected it is not going
1224 * to arrive. We should thus abort it.
1226 spin_lock(&mcdi
->iface_lock
);
1227 efx_mcdi_proxy_abort(mcdi
);
1229 if (efx_mcdi_complete_sync(mcdi
)) {
1230 if (mcdi
->mode
== MCDI_MODE_EVENTS
) {
1232 mcdi
->resp_hdr_len
= 0;
1233 mcdi
->resp_data_len
= 0;
1239 /* Consume the status word since efx_mcdi_rpc_finish() won't */
1240 for (count
= 0; count
< MCDI_STATUS_DELAY_COUNT
; ++count
) {
1241 rc
= efx_mcdi_poll_reboot(efx
);
1244 udelay(MCDI_STATUS_DELAY_US
);
1247 /* On EF10, a CODE_MC_REBOOT event can be received without the
1248 * reboot detection in efx_mcdi_poll_reboot() being triggered.
1249 * If zero was returned from the final call to
1250 * efx_mcdi_poll_reboot(), the MC reboot wasn't noticed but the
1251 * MC has definitely rebooted so prepare for the reset.
1253 if (!rc
&& efx
->type
->mcdi_reboot_detected
)
1254 efx
->type
->mcdi_reboot_detected(efx
);
1256 mcdi
->new_epoch
= true;
1258 /* Nobody was waiting for an MCDI request, so trigger a reset */
1259 efx_schedule_reset(efx
, RESET_TYPE_MC_FAILURE
);
1262 spin_unlock(&mcdi
->iface_lock
);
1265 /* The MC is going down in to BIST mode. set the BIST flag to block
1266 * new MCDI, cancel any outstanding MCDI and and schedule a BIST-type reset
1267 * (which doesn't actually execute a reset, it waits for the controlling
1268 * function to reset it).
1270 static void efx_mcdi_ev_bist(struct efx_nic
*efx
)
1272 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
1274 spin_lock(&mcdi
->iface_lock
);
1275 efx
->mc_bist_for_other_fn
= true;
1276 efx_mcdi_proxy_abort(mcdi
);
1278 if (efx_mcdi_complete_sync(mcdi
)) {
1279 if (mcdi
->mode
== MCDI_MODE_EVENTS
) {
1280 mcdi
->resprc
= -EIO
;
1281 mcdi
->resp_hdr_len
= 0;
1282 mcdi
->resp_data_len
= 0;
1286 mcdi
->new_epoch
= true;
1287 efx_schedule_reset(efx
, RESET_TYPE_MC_BIST
);
1288 spin_unlock(&mcdi
->iface_lock
);
1291 /* MCDI timeouts seen, so make all MCDI calls fail-fast and issue an FLR to try
1294 static void efx_mcdi_abandon(struct efx_nic
*efx
)
1296 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
1298 if (xchg(&mcdi
->mode
, MCDI_MODE_FAIL
) == MCDI_MODE_FAIL
)
1299 return; /* it had already been done */
1300 netif_dbg(efx
, hw
, efx
->net_dev
, "MCDI is timing out; trying to recover\n");
1301 efx_schedule_reset(efx
, RESET_TYPE_MCDI_TIMEOUT
);
1304 /* Called from efx_farch_ev_process and efx_ef10_ev_process for MCDI events */
1305 void efx_mcdi_process_event(struct efx_channel
*channel
,
1308 struct efx_nic
*efx
= channel
->efx
;
1309 int code
= EFX_QWORD_FIELD(*event
, MCDI_EVENT_CODE
);
1310 u32 data
= EFX_QWORD_FIELD(*event
, MCDI_EVENT_DATA
);
1313 case MCDI_EVENT_CODE_BADSSERT
:
1314 netif_err(efx
, hw
, efx
->net_dev
,
1315 "MC watchdog or assertion failure at 0x%x\n", data
);
1316 efx_mcdi_ev_death(efx
, -EINTR
);
1319 case MCDI_EVENT_CODE_PMNOTICE
:
1320 netif_info(efx
, wol
, efx
->net_dev
, "MCDI PM event.\n");
1323 case MCDI_EVENT_CODE_CMDDONE
:
1324 efx_mcdi_ev_cpl(efx
,
1325 MCDI_EVENT_FIELD(*event
, CMDDONE_SEQ
),
1326 MCDI_EVENT_FIELD(*event
, CMDDONE_DATALEN
),
1327 MCDI_EVENT_FIELD(*event
, CMDDONE_ERRNO
));
1330 case MCDI_EVENT_CODE_LINKCHANGE
:
1331 efx_mcdi_process_link_change(efx
, event
);
1333 case MCDI_EVENT_CODE_SENSOREVT
:
1334 efx_mcdi_sensor_event(efx
, event
);
1336 case MCDI_EVENT_CODE_SCHEDERR
:
1337 netif_dbg(efx
, hw
, efx
->net_dev
,
1338 "MC Scheduler alert (0x%x)\n", data
);
1340 case MCDI_EVENT_CODE_REBOOT
:
1341 case MCDI_EVENT_CODE_MC_REBOOT
:
1342 netif_info(efx
, hw
, efx
->net_dev
, "MC Reboot\n");
1343 efx_mcdi_ev_death(efx
, -EIO
);
1345 case MCDI_EVENT_CODE_MC_BIST
:
1346 netif_info(efx
, hw
, efx
->net_dev
, "MC entered BIST mode\n");
1347 efx_mcdi_ev_bist(efx
);
1349 case MCDI_EVENT_CODE_MAC_STATS_DMA
:
1350 /* MAC stats are gather lazily. We can ignore this. */
1352 case MCDI_EVENT_CODE_FLR
:
1353 if (efx
->type
->sriov_flr
)
1354 efx
->type
->sriov_flr(efx
,
1355 MCDI_EVENT_FIELD(*event
, FLR_VF
));
1357 case MCDI_EVENT_CODE_PTP_RX
:
1358 case MCDI_EVENT_CODE_PTP_FAULT
:
1359 case MCDI_EVENT_CODE_PTP_PPS
:
1360 efx_ptp_event(efx
, event
);
1362 case MCDI_EVENT_CODE_PTP_TIME
:
1363 efx_time_sync_event(channel
, event
);
1365 case MCDI_EVENT_CODE_TX_FLUSH
:
1366 case MCDI_EVENT_CODE_RX_FLUSH
:
1367 /* Two flush events will be sent: one to the same event
1368 * queue as completions, and one to event queue 0.
1369 * In the latter case the {RX,TX}_FLUSH_TO_DRIVER
1370 * flag will be set, and we should ignore the event
1371 * because we want to wait for all completions.
1373 BUILD_BUG_ON(MCDI_EVENT_TX_FLUSH_TO_DRIVER_LBN
!=
1374 MCDI_EVENT_RX_FLUSH_TO_DRIVER_LBN
);
1375 if (!MCDI_EVENT_FIELD(*event
, TX_FLUSH_TO_DRIVER
))
1376 efx_ef10_handle_drain_event(efx
);
1378 case MCDI_EVENT_CODE_TX_ERR
:
1379 case MCDI_EVENT_CODE_RX_ERR
:
1380 netif_err(efx
, hw
, efx
->net_dev
,
1381 "%s DMA error (event: "EFX_QWORD_FMT
")\n",
1382 code
== MCDI_EVENT_CODE_TX_ERR
? "TX" : "RX",
1383 EFX_QWORD_VAL(*event
));
1384 efx_schedule_reset(efx
, RESET_TYPE_DMA_ERROR
);
1386 case MCDI_EVENT_CODE_PROXY_RESPONSE
:
1387 efx_mcdi_ev_proxy_response(efx
,
1388 MCDI_EVENT_FIELD(*event
, PROXY_RESPONSE_HANDLE
),
1389 MCDI_EVENT_FIELD(*event
, PROXY_RESPONSE_RC
));
1392 netif_err(efx
, hw
, efx
->net_dev
,
1393 "Unknown MCDI event " EFX_QWORD_FMT
"\n",
1394 EFX_QWORD_VAL(*event
));
1398 /**************************************************************************
1400 * Specific request functions
1402 **************************************************************************
1405 void efx_mcdi_print_fwver(struct efx_nic
*efx
, char *buf
, size_t len
)
1407 MCDI_DECLARE_BUF(outbuf
, MC_CMD_GET_VERSION_OUT_LEN
);
1409 const __le16
*ver_words
;
1413 BUILD_BUG_ON(MC_CMD_GET_VERSION_IN_LEN
!= 0);
1414 rc
= efx_mcdi_rpc(efx
, MC_CMD_GET_VERSION
, NULL
, 0,
1415 outbuf
, sizeof(outbuf
), &outlength
);
1418 if (outlength
< MC_CMD_GET_VERSION_OUT_LEN
) {
1423 ver_words
= (__le16
*)MCDI_PTR(outbuf
, GET_VERSION_OUT_VERSION
);
1424 offset
= snprintf(buf
, len
, "%u.%u.%u.%u",
1425 le16_to_cpu(ver_words
[0]), le16_to_cpu(ver_words
[1]),
1426 le16_to_cpu(ver_words
[2]), le16_to_cpu(ver_words
[3]));
1428 /* EF10 may have multiple datapath firmware variants within a
1429 * single version. Report which variants are running.
1431 if (efx_nic_rev(efx
) >= EFX_REV_HUNT_A0
) {
1432 struct efx_ef10_nic_data
*nic_data
= efx
->nic_data
;
1434 offset
+= snprintf(buf
+ offset
, len
- offset
, " rx%x tx%x",
1435 nic_data
->rx_dpcpu_fw_id
,
1436 nic_data
->tx_dpcpu_fw_id
);
1438 /* It's theoretically possible for the string to exceed 31
1439 * characters, though in practice the first three version
1440 * components are short enough that this doesn't happen.
1442 if (WARN_ON(offset
>= len
))
1449 netif_err(efx
, probe
, efx
->net_dev
, "%s: failed rc=%d\n", __func__
, rc
);
1453 static int efx_mcdi_drv_attach(struct efx_nic
*efx
, bool driver_operating
,
1456 MCDI_DECLARE_BUF(inbuf
, MC_CMD_DRV_ATTACH_IN_LEN
);
1457 MCDI_DECLARE_BUF(outbuf
, MC_CMD_DRV_ATTACH_EXT_OUT_LEN
);
1461 MCDI_SET_DWORD(inbuf
, DRV_ATTACH_IN_NEW_STATE
,
1462 driver_operating
? 1 : 0);
1463 MCDI_SET_DWORD(inbuf
, DRV_ATTACH_IN_UPDATE
, 1);
1464 MCDI_SET_DWORD(inbuf
, DRV_ATTACH_IN_FIRMWARE_ID
, MC_CMD_FW_LOW_LATENCY
);
1466 rc
= efx_mcdi_rpc_quiet(efx
, MC_CMD_DRV_ATTACH
, inbuf
, sizeof(inbuf
),
1467 outbuf
, sizeof(outbuf
), &outlen
);
1468 /* If we're not the primary PF, trying to ATTACH with a FIRMWARE_ID
1469 * specified will fail with EPERM, and we have to tell the MC we don't
1470 * care what firmware we get.
1473 netif_dbg(efx
, probe
, efx
->net_dev
,
1474 "efx_mcdi_drv_attach with fw-variant setting failed EPERM, trying without it\n");
1475 MCDI_SET_DWORD(inbuf
, DRV_ATTACH_IN_FIRMWARE_ID
,
1476 MC_CMD_FW_DONT_CARE
);
1477 rc
= efx_mcdi_rpc_quiet(efx
, MC_CMD_DRV_ATTACH
, inbuf
,
1478 sizeof(inbuf
), outbuf
, sizeof(outbuf
),
1482 efx_mcdi_display_error(efx
, MC_CMD_DRV_ATTACH
, sizeof(inbuf
),
1483 outbuf
, outlen
, rc
);
1486 if (outlen
< MC_CMD_DRV_ATTACH_OUT_LEN
) {
1491 if (driver_operating
) {
1492 if (outlen
>= MC_CMD_DRV_ATTACH_EXT_OUT_LEN
) {
1493 efx
->mcdi
->fn_flags
=
1495 DRV_ATTACH_EXT_OUT_FUNC_FLAGS
);
1497 /* Synthesise flags for Siena */
1498 efx
->mcdi
->fn_flags
=
1499 1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_LINKCTRL
|
1500 1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_TRUSTED
|
1501 (efx_port_num(efx
) == 0) <<
1502 MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_PRIMARY
;
1506 /* We currently assume we have control of the external link
1507 * and are completely trusted by firmware. Abort probing
1508 * if that's not true for this function.
1511 if (was_attached
!= NULL
)
1512 *was_attached
= MCDI_DWORD(outbuf
, DRV_ATTACH_OUT_OLD_STATE
);
1516 netif_err(efx
, probe
, efx
->net_dev
, "%s: failed rc=%d\n", __func__
, rc
);
1520 int efx_mcdi_get_board_cfg(struct efx_nic
*efx
, u8
*mac_address
,
1521 u16
*fw_subtype_list
, u32
*capabilities
)
1523 MCDI_DECLARE_BUF(outbuf
, MC_CMD_GET_BOARD_CFG_OUT_LENMAX
);
1525 int port_num
= efx_port_num(efx
);
1528 BUILD_BUG_ON(MC_CMD_GET_BOARD_CFG_IN_LEN
!= 0);
1529 /* we need __aligned(2) for ether_addr_copy */
1530 BUILD_BUG_ON(MC_CMD_GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT0_OFST
& 1);
1531 BUILD_BUG_ON(MC_CMD_GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT1_OFST
& 1);
1533 rc
= efx_mcdi_rpc(efx
, MC_CMD_GET_BOARD_CFG
, NULL
, 0,
1534 outbuf
, sizeof(outbuf
), &outlen
);
1538 if (outlen
< MC_CMD_GET_BOARD_CFG_OUT_LENMIN
) {
1544 ether_addr_copy(mac_address
,
1546 MCDI_PTR(outbuf
, GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT1
) :
1547 MCDI_PTR(outbuf
, GET_BOARD_CFG_OUT_MAC_ADDR_BASE_PORT0
));
1548 if (fw_subtype_list
) {
1550 i
< MCDI_VAR_ARRAY_LEN(outlen
,
1551 GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST
);
1553 fw_subtype_list
[i
] = MCDI_ARRAY_WORD(
1554 outbuf
, GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST
, i
);
1555 for (; i
< MC_CMD_GET_BOARD_CFG_OUT_FW_SUBTYPE_LIST_MAXNUM
; i
++)
1556 fw_subtype_list
[i
] = 0;
1560 *capabilities
= MCDI_DWORD(outbuf
,
1561 GET_BOARD_CFG_OUT_CAPABILITIES_PORT1
);
1563 *capabilities
= MCDI_DWORD(outbuf
,
1564 GET_BOARD_CFG_OUT_CAPABILITIES_PORT0
);
1570 netif_err(efx
, hw
, efx
->net_dev
, "%s: failed rc=%d len=%d\n",
1571 __func__
, rc
, (int)outlen
);
1576 int efx_mcdi_log_ctrl(struct efx_nic
*efx
, bool evq
, bool uart
, u32 dest_evq
)
1578 MCDI_DECLARE_BUF(inbuf
, MC_CMD_LOG_CTRL_IN_LEN
);
1583 dest
|= MC_CMD_LOG_CTRL_IN_LOG_DEST_UART
;
1585 dest
|= MC_CMD_LOG_CTRL_IN_LOG_DEST_EVQ
;
1587 MCDI_SET_DWORD(inbuf
, LOG_CTRL_IN_LOG_DEST
, dest
);
1588 MCDI_SET_DWORD(inbuf
, LOG_CTRL_IN_LOG_DEST_EVQ
, dest_evq
);
1590 BUILD_BUG_ON(MC_CMD_LOG_CTRL_OUT_LEN
!= 0);
1592 rc
= efx_mcdi_rpc(efx
, MC_CMD_LOG_CTRL
, inbuf
, sizeof(inbuf
),
1597 int efx_mcdi_nvram_types(struct efx_nic
*efx
, u32
*nvram_types_out
)
1599 MCDI_DECLARE_BUF(outbuf
, MC_CMD_NVRAM_TYPES_OUT_LEN
);
1603 BUILD_BUG_ON(MC_CMD_NVRAM_TYPES_IN_LEN
!= 0);
1605 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_TYPES
, NULL
, 0,
1606 outbuf
, sizeof(outbuf
), &outlen
);
1609 if (outlen
< MC_CMD_NVRAM_TYPES_OUT_LEN
) {
1614 *nvram_types_out
= MCDI_DWORD(outbuf
, NVRAM_TYPES_OUT_TYPES
);
1618 netif_err(efx
, hw
, efx
->net_dev
, "%s: failed rc=%d\n",
1623 int efx_mcdi_nvram_info(struct efx_nic
*efx
, unsigned int type
,
1624 size_t *size_out
, size_t *erase_size_out
,
1625 bool *protected_out
)
1627 MCDI_DECLARE_BUF(inbuf
, MC_CMD_NVRAM_INFO_IN_LEN
);
1628 MCDI_DECLARE_BUF(outbuf
, MC_CMD_NVRAM_INFO_OUT_LEN
);
1632 MCDI_SET_DWORD(inbuf
, NVRAM_INFO_IN_TYPE
, type
);
1634 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_INFO
, inbuf
, sizeof(inbuf
),
1635 outbuf
, sizeof(outbuf
), &outlen
);
1638 if (outlen
< MC_CMD_NVRAM_INFO_OUT_LEN
) {
1643 *size_out
= MCDI_DWORD(outbuf
, NVRAM_INFO_OUT_SIZE
);
1644 *erase_size_out
= MCDI_DWORD(outbuf
, NVRAM_INFO_OUT_ERASESIZE
);
1645 *protected_out
= !!(MCDI_DWORD(outbuf
, NVRAM_INFO_OUT_FLAGS
) &
1646 (1 << MC_CMD_NVRAM_INFO_OUT_PROTECTED_LBN
));
1650 netif_err(efx
, hw
, efx
->net_dev
, "%s: failed rc=%d\n", __func__
, rc
);
1654 static int efx_mcdi_nvram_test(struct efx_nic
*efx
, unsigned int type
)
1656 MCDI_DECLARE_BUF(inbuf
, MC_CMD_NVRAM_TEST_IN_LEN
);
1657 MCDI_DECLARE_BUF(outbuf
, MC_CMD_NVRAM_TEST_OUT_LEN
);
1660 MCDI_SET_DWORD(inbuf
, NVRAM_TEST_IN_TYPE
, type
);
1662 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_TEST
, inbuf
, sizeof(inbuf
),
1663 outbuf
, sizeof(outbuf
), NULL
);
1667 switch (MCDI_DWORD(outbuf
, NVRAM_TEST_OUT_RESULT
)) {
1668 case MC_CMD_NVRAM_TEST_PASS
:
1669 case MC_CMD_NVRAM_TEST_NOTSUPP
:
1676 int efx_mcdi_nvram_test_all(struct efx_nic
*efx
)
1682 rc
= efx_mcdi_nvram_types(efx
, &nvram_types
);
1687 while (nvram_types
!= 0) {
1688 if (nvram_types
& 1) {
1689 rc
= efx_mcdi_nvram_test(efx
, type
);
1700 netif_err(efx
, hw
, efx
->net_dev
, "%s: failed type=%u\n",
1703 netif_err(efx
, hw
, efx
->net_dev
, "%s: failed rc=%d\n", __func__
, rc
);
1707 /* Returns 1 if an assertion was read, 0 if no assertion had fired,
1708 * negative on error.
1710 static int efx_mcdi_read_assertion(struct efx_nic
*efx
)
1712 MCDI_DECLARE_BUF(inbuf
, MC_CMD_GET_ASSERTS_IN_LEN
);
1713 MCDI_DECLARE_BUF(outbuf
, MC_CMD_GET_ASSERTS_OUT_LEN
);
1714 unsigned int flags
, index
;
1720 /* Attempt to read any stored assertion state before we reboot
1721 * the mcfw out of the assertion handler. Retry twice, once
1722 * because a boot-time assertion might cause this command to fail
1723 * with EINTR. And once again because GET_ASSERTS can race with
1724 * MC_CMD_REBOOT running on the other port. */
1727 MCDI_SET_DWORD(inbuf
, GET_ASSERTS_IN_CLEAR
, 1);
1728 rc
= efx_mcdi_rpc_quiet(efx
, MC_CMD_GET_ASSERTS
,
1729 inbuf
, MC_CMD_GET_ASSERTS_IN_LEN
,
1730 outbuf
, sizeof(outbuf
), &outlen
);
1733 } while ((rc
== -EINTR
|| rc
== -EIO
) && retry
-- > 0);
1736 efx_mcdi_display_error(efx
, MC_CMD_GET_ASSERTS
,
1737 MC_CMD_GET_ASSERTS_IN_LEN
, outbuf
,
1741 if (outlen
< MC_CMD_GET_ASSERTS_OUT_LEN
)
1744 /* Print out any recorded assertion state */
1745 flags
= MCDI_DWORD(outbuf
, GET_ASSERTS_OUT_GLOBAL_FLAGS
);
1746 if (flags
== MC_CMD_GET_ASSERTS_FLAGS_NO_FAILS
)
1749 reason
= (flags
== MC_CMD_GET_ASSERTS_FLAGS_SYS_FAIL
)
1750 ? "system-level assertion"
1751 : (flags
== MC_CMD_GET_ASSERTS_FLAGS_THR_FAIL
)
1752 ? "thread-level assertion"
1753 : (flags
== MC_CMD_GET_ASSERTS_FLAGS_WDOG_FIRED
)
1755 : "unknown assertion";
1756 netif_err(efx
, hw
, efx
->net_dev
,
1757 "MCPU %s at PC = 0x%.8x in thread 0x%.8x\n", reason
,
1758 MCDI_DWORD(outbuf
, GET_ASSERTS_OUT_SAVED_PC_OFFS
),
1759 MCDI_DWORD(outbuf
, GET_ASSERTS_OUT_THREAD_OFFS
));
1761 /* Print out the registers */
1763 index
< MC_CMD_GET_ASSERTS_OUT_GP_REGS_OFFS_NUM
;
1765 netif_err(efx
, hw
, efx
->net_dev
, "R%.2d (?): 0x%.8x\n",
1767 MCDI_ARRAY_DWORD(outbuf
, GET_ASSERTS_OUT_GP_REGS_OFFS
,
1773 static int efx_mcdi_exit_assertion(struct efx_nic
*efx
)
1775 MCDI_DECLARE_BUF(inbuf
, MC_CMD_REBOOT_IN_LEN
);
1778 /* If the MC is running debug firmware, it might now be
1779 * waiting for a debugger to attach, but we just want it to
1780 * reboot. We set a flag that makes the command a no-op if it
1781 * has already done so.
1782 * The MCDI will thus return either 0 or -EIO.
1784 BUILD_BUG_ON(MC_CMD_REBOOT_OUT_LEN
!= 0);
1785 MCDI_SET_DWORD(inbuf
, REBOOT_IN_FLAGS
,
1786 MC_CMD_REBOOT_FLAGS_AFTER_ASSERTION
);
1787 rc
= efx_mcdi_rpc_quiet(efx
, MC_CMD_REBOOT
, inbuf
, MC_CMD_REBOOT_IN_LEN
,
1792 efx_mcdi_display_error(efx
, MC_CMD_REBOOT
, MC_CMD_REBOOT_IN_LEN
,
1797 int efx_mcdi_handle_assertion(struct efx_nic
*efx
)
1801 rc
= efx_mcdi_read_assertion(efx
);
1805 return efx_mcdi_exit_assertion(efx
);
1808 void efx_mcdi_set_id_led(struct efx_nic
*efx
, enum efx_led_mode mode
)
1810 MCDI_DECLARE_BUF(inbuf
, MC_CMD_SET_ID_LED_IN_LEN
);
1813 BUILD_BUG_ON(EFX_LED_OFF
!= MC_CMD_LED_OFF
);
1814 BUILD_BUG_ON(EFX_LED_ON
!= MC_CMD_LED_ON
);
1815 BUILD_BUG_ON(EFX_LED_DEFAULT
!= MC_CMD_LED_DEFAULT
);
1817 BUILD_BUG_ON(MC_CMD_SET_ID_LED_OUT_LEN
!= 0);
1819 MCDI_SET_DWORD(inbuf
, SET_ID_LED_IN_STATE
, mode
);
1821 rc
= efx_mcdi_rpc(efx
, MC_CMD_SET_ID_LED
, inbuf
, sizeof(inbuf
),
1825 static int efx_mcdi_reset_func(struct efx_nic
*efx
)
1827 MCDI_DECLARE_BUF(inbuf
, MC_CMD_ENTITY_RESET_IN_LEN
);
1830 BUILD_BUG_ON(MC_CMD_ENTITY_RESET_OUT_LEN
!= 0);
1831 MCDI_POPULATE_DWORD_1(inbuf
, ENTITY_RESET_IN_FLAG
,
1832 ENTITY_RESET_IN_FUNCTION_RESOURCE_RESET
, 1);
1833 rc
= efx_mcdi_rpc(efx
, MC_CMD_ENTITY_RESET
, inbuf
, sizeof(inbuf
),
1838 static int efx_mcdi_reset_mc(struct efx_nic
*efx
)
1840 MCDI_DECLARE_BUF(inbuf
, MC_CMD_REBOOT_IN_LEN
);
1843 BUILD_BUG_ON(MC_CMD_REBOOT_OUT_LEN
!= 0);
1844 MCDI_SET_DWORD(inbuf
, REBOOT_IN_FLAGS
, 0);
1845 rc
= efx_mcdi_rpc(efx
, MC_CMD_REBOOT
, inbuf
, sizeof(inbuf
),
1847 /* White is black, and up is down */
1855 enum reset_type
efx_mcdi_map_reset_reason(enum reset_type reason
)
1857 return RESET_TYPE_RECOVER_OR_ALL
;
1860 int efx_mcdi_reset(struct efx_nic
*efx
, enum reset_type method
)
1864 /* If MCDI is down, we can't handle_assertion */
1865 if (method
== RESET_TYPE_MCDI_TIMEOUT
) {
1866 rc
= pci_reset_function(efx
->pci_dev
);
1869 /* Re-enable polled MCDI completion */
1871 struct efx_mcdi_iface
*mcdi
= efx_mcdi(efx
);
1872 mcdi
->mode
= MCDI_MODE_POLL
;
1877 /* Recover from a failed assertion pre-reset */
1878 rc
= efx_mcdi_handle_assertion(efx
);
1882 if (method
== RESET_TYPE_DATAPATH
)
1884 else if (method
== RESET_TYPE_WORLD
)
1885 return efx_mcdi_reset_mc(efx
);
1887 return efx_mcdi_reset_func(efx
);
1890 static int efx_mcdi_wol_filter_set(struct efx_nic
*efx
, u32 type
,
1891 const u8
*mac
, int *id_out
)
1893 MCDI_DECLARE_BUF(inbuf
, MC_CMD_WOL_FILTER_SET_IN_LEN
);
1894 MCDI_DECLARE_BUF(outbuf
, MC_CMD_WOL_FILTER_SET_OUT_LEN
);
1898 MCDI_SET_DWORD(inbuf
, WOL_FILTER_SET_IN_WOL_TYPE
, type
);
1899 MCDI_SET_DWORD(inbuf
, WOL_FILTER_SET_IN_FILTER_MODE
,
1900 MC_CMD_FILTER_MODE_SIMPLE
);
1901 ether_addr_copy(MCDI_PTR(inbuf
, WOL_FILTER_SET_IN_MAGIC_MAC
), mac
);
1903 rc
= efx_mcdi_rpc(efx
, MC_CMD_WOL_FILTER_SET
, inbuf
, sizeof(inbuf
),
1904 outbuf
, sizeof(outbuf
), &outlen
);
1908 if (outlen
< MC_CMD_WOL_FILTER_SET_OUT_LEN
) {
1913 *id_out
= (int)MCDI_DWORD(outbuf
, WOL_FILTER_SET_OUT_FILTER_ID
);
1919 netif_err(efx
, hw
, efx
->net_dev
, "%s: failed rc=%d\n", __func__
, rc
);
1926 efx_mcdi_wol_filter_set_magic(struct efx_nic
*efx
, const u8
*mac
, int *id_out
)
1928 return efx_mcdi_wol_filter_set(efx
, MC_CMD_WOL_TYPE_MAGIC
, mac
, id_out
);
1932 int efx_mcdi_wol_filter_get_magic(struct efx_nic
*efx
, int *id_out
)
1934 MCDI_DECLARE_BUF(outbuf
, MC_CMD_WOL_FILTER_GET_OUT_LEN
);
1938 rc
= efx_mcdi_rpc(efx
, MC_CMD_WOL_FILTER_GET
, NULL
, 0,
1939 outbuf
, sizeof(outbuf
), &outlen
);
1943 if (outlen
< MC_CMD_WOL_FILTER_GET_OUT_LEN
) {
1948 *id_out
= (int)MCDI_DWORD(outbuf
, WOL_FILTER_GET_OUT_FILTER_ID
);
1954 netif_err(efx
, hw
, efx
->net_dev
, "%s: failed rc=%d\n", __func__
, rc
);
1959 int efx_mcdi_wol_filter_remove(struct efx_nic
*efx
, int id
)
1961 MCDI_DECLARE_BUF(inbuf
, MC_CMD_WOL_FILTER_REMOVE_IN_LEN
);
1964 MCDI_SET_DWORD(inbuf
, WOL_FILTER_REMOVE_IN_FILTER_ID
, (u32
)id
);
1966 rc
= efx_mcdi_rpc(efx
, MC_CMD_WOL_FILTER_REMOVE
, inbuf
, sizeof(inbuf
),
1971 int efx_mcdi_flush_rxqs(struct efx_nic
*efx
)
1973 struct efx_channel
*channel
;
1974 struct efx_rx_queue
*rx_queue
;
1975 MCDI_DECLARE_BUF(inbuf
,
1976 MC_CMD_FLUSH_RX_QUEUES_IN_LEN(EFX_MAX_CHANNELS
));
1979 BUILD_BUG_ON(EFX_MAX_CHANNELS
>
1980 MC_CMD_FLUSH_RX_QUEUES_IN_QID_OFST_MAXNUM
);
1983 efx_for_each_channel(channel
, efx
) {
1984 efx_for_each_channel_rx_queue(rx_queue
, channel
) {
1985 if (rx_queue
->flush_pending
) {
1986 rx_queue
->flush_pending
= false;
1987 atomic_dec(&efx
->rxq_flush_pending
);
1988 MCDI_SET_ARRAY_DWORD(
1989 inbuf
, FLUSH_RX_QUEUES_IN_QID_OFST
,
1990 count
, efx_rx_queue_index(rx_queue
));
1996 rc
= efx_mcdi_rpc(efx
, MC_CMD_FLUSH_RX_QUEUES
, inbuf
,
1997 MC_CMD_FLUSH_RX_QUEUES_IN_LEN(count
), NULL
, 0, NULL
);
2003 int efx_mcdi_wol_filter_reset(struct efx_nic
*efx
)
2007 rc
= efx_mcdi_rpc(efx
, MC_CMD_WOL_FILTER_RESET
, NULL
, 0, NULL
, 0, NULL
);
2011 int efx_mcdi_set_workaround(struct efx_nic
*efx
, u32 type
, bool enabled
,
2012 unsigned int *flags
)
2014 MCDI_DECLARE_BUF(inbuf
, MC_CMD_WORKAROUND_IN_LEN
);
2015 MCDI_DECLARE_BUF(outbuf
, MC_CMD_WORKAROUND_EXT_OUT_LEN
);
2019 BUILD_BUG_ON(MC_CMD_WORKAROUND_OUT_LEN
!= 0);
2020 MCDI_SET_DWORD(inbuf
, WORKAROUND_IN_TYPE
, type
);
2021 MCDI_SET_DWORD(inbuf
, WORKAROUND_IN_ENABLED
, enabled
);
2022 rc
= efx_mcdi_rpc(efx
, MC_CMD_WORKAROUND
, inbuf
, sizeof(inbuf
),
2023 outbuf
, sizeof(outbuf
), &outlen
);
2030 if (outlen
>= MC_CMD_WORKAROUND_EXT_OUT_LEN
)
2031 *flags
= MCDI_DWORD(outbuf
, WORKAROUND_EXT_OUT_FLAGS
);
2038 int efx_mcdi_get_workarounds(struct efx_nic
*efx
, unsigned int *impl_out
,
2039 unsigned int *enabled_out
)
2041 MCDI_DECLARE_BUF(outbuf
, MC_CMD_GET_WORKAROUNDS_OUT_LEN
);
2045 rc
= efx_mcdi_rpc(efx
, MC_CMD_GET_WORKAROUNDS
, NULL
, 0,
2046 outbuf
, sizeof(outbuf
), &outlen
);
2050 if (outlen
< MC_CMD_GET_WORKAROUNDS_OUT_LEN
) {
2056 *impl_out
= MCDI_DWORD(outbuf
, GET_WORKAROUNDS_OUT_IMPLEMENTED
);
2059 *enabled_out
= MCDI_DWORD(outbuf
, GET_WORKAROUNDS_OUT_ENABLED
);
2064 /* Older firmware lacks GET_WORKAROUNDS and this isn't especially
2065 * terrifying. The call site will have to deal with it though.
2067 netif_cond_dbg(efx
, hw
, efx
->net_dev
, rc
== -ENOSYS
, err
,
2068 "%s: failed rc=%d\n", __func__
, rc
);
2072 #ifdef CONFIG_SFC_MTD
2074 #define EFX_MCDI_NVRAM_LEN_MAX 128
2076 static int efx_mcdi_nvram_update_start(struct efx_nic
*efx
, unsigned int type
)
2078 MCDI_DECLARE_BUF(inbuf
, MC_CMD_NVRAM_UPDATE_START_IN_LEN
);
2081 MCDI_SET_DWORD(inbuf
, NVRAM_UPDATE_START_IN_TYPE
, type
);
2083 BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_START_OUT_LEN
!= 0);
2085 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_UPDATE_START
, inbuf
, sizeof(inbuf
),
2090 static int efx_mcdi_nvram_read(struct efx_nic
*efx
, unsigned int type
,
2091 loff_t offset
, u8
*buffer
, size_t length
)
2093 MCDI_DECLARE_BUF(inbuf
, MC_CMD_NVRAM_READ_IN_LEN
);
2094 MCDI_DECLARE_BUF(outbuf
,
2095 MC_CMD_NVRAM_READ_OUT_LEN(EFX_MCDI_NVRAM_LEN_MAX
));
2099 MCDI_SET_DWORD(inbuf
, NVRAM_READ_IN_TYPE
, type
);
2100 MCDI_SET_DWORD(inbuf
, NVRAM_READ_IN_OFFSET
, offset
);
2101 MCDI_SET_DWORD(inbuf
, NVRAM_READ_IN_LENGTH
, length
);
2103 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_READ
, inbuf
, sizeof(inbuf
),
2104 outbuf
, sizeof(outbuf
), &outlen
);
2108 memcpy(buffer
, MCDI_PTR(outbuf
, NVRAM_READ_OUT_READ_BUFFER
), length
);
2112 static int efx_mcdi_nvram_write(struct efx_nic
*efx
, unsigned int type
,
2113 loff_t offset
, const u8
*buffer
, size_t length
)
2115 MCDI_DECLARE_BUF(inbuf
,
2116 MC_CMD_NVRAM_WRITE_IN_LEN(EFX_MCDI_NVRAM_LEN_MAX
));
2119 MCDI_SET_DWORD(inbuf
, NVRAM_WRITE_IN_TYPE
, type
);
2120 MCDI_SET_DWORD(inbuf
, NVRAM_WRITE_IN_OFFSET
, offset
);
2121 MCDI_SET_DWORD(inbuf
, NVRAM_WRITE_IN_LENGTH
, length
);
2122 memcpy(MCDI_PTR(inbuf
, NVRAM_WRITE_IN_WRITE_BUFFER
), buffer
, length
);
2124 BUILD_BUG_ON(MC_CMD_NVRAM_WRITE_OUT_LEN
!= 0);
2126 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_WRITE
, inbuf
,
2127 ALIGN(MC_CMD_NVRAM_WRITE_IN_LEN(length
), 4),
2132 static int efx_mcdi_nvram_erase(struct efx_nic
*efx
, unsigned int type
,
2133 loff_t offset
, size_t length
)
2135 MCDI_DECLARE_BUF(inbuf
, MC_CMD_NVRAM_ERASE_IN_LEN
);
2138 MCDI_SET_DWORD(inbuf
, NVRAM_ERASE_IN_TYPE
, type
);
2139 MCDI_SET_DWORD(inbuf
, NVRAM_ERASE_IN_OFFSET
, offset
);
2140 MCDI_SET_DWORD(inbuf
, NVRAM_ERASE_IN_LENGTH
, length
);
2142 BUILD_BUG_ON(MC_CMD_NVRAM_ERASE_OUT_LEN
!= 0);
2144 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_ERASE
, inbuf
, sizeof(inbuf
),
2149 static int efx_mcdi_nvram_update_finish(struct efx_nic
*efx
, unsigned int type
)
2151 MCDI_DECLARE_BUF(inbuf
, MC_CMD_NVRAM_UPDATE_FINISH_IN_LEN
);
2154 MCDI_SET_DWORD(inbuf
, NVRAM_UPDATE_FINISH_IN_TYPE
, type
);
2156 BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_FINISH_OUT_LEN
!= 0);
2158 rc
= efx_mcdi_rpc(efx
, MC_CMD_NVRAM_UPDATE_FINISH
, inbuf
, sizeof(inbuf
),
2163 int efx_mcdi_mtd_read(struct mtd_info
*mtd
, loff_t start
,
2164 size_t len
, size_t *retlen
, u8
*buffer
)
2166 struct efx_mcdi_mtd_partition
*part
= to_efx_mcdi_mtd_partition(mtd
);
2167 struct efx_nic
*efx
= mtd
->priv
;
2168 loff_t offset
= start
;
2169 loff_t end
= min_t(loff_t
, start
+ len
, mtd
->size
);
2173 while (offset
< end
) {
2174 chunk
= min_t(size_t, end
- offset
, EFX_MCDI_NVRAM_LEN_MAX
);
2175 rc
= efx_mcdi_nvram_read(efx
, part
->nvram_type
, offset
,
2183 *retlen
= offset
- start
;
2187 int efx_mcdi_mtd_erase(struct mtd_info
*mtd
, loff_t start
, size_t len
)
2189 struct efx_mcdi_mtd_partition
*part
= to_efx_mcdi_mtd_partition(mtd
);
2190 struct efx_nic
*efx
= mtd
->priv
;
2191 loff_t offset
= start
& ~((loff_t
)(mtd
->erasesize
- 1));
2192 loff_t end
= min_t(loff_t
, start
+ len
, mtd
->size
);
2193 size_t chunk
= part
->common
.mtd
.erasesize
;
2196 if (!part
->updating
) {
2197 rc
= efx_mcdi_nvram_update_start(efx
, part
->nvram_type
);
2200 part
->updating
= true;
2203 /* The MCDI interface can in fact do multiple erase blocks at once;
2204 * but erasing may be slow, so we make multiple calls here to avoid
2205 * tripping the MCDI RPC timeout. */
2206 while (offset
< end
) {
2207 rc
= efx_mcdi_nvram_erase(efx
, part
->nvram_type
, offset
,
2217 int efx_mcdi_mtd_write(struct mtd_info
*mtd
, loff_t start
,
2218 size_t len
, size_t *retlen
, const u8
*buffer
)
2220 struct efx_mcdi_mtd_partition
*part
= to_efx_mcdi_mtd_partition(mtd
);
2221 struct efx_nic
*efx
= mtd
->priv
;
2222 loff_t offset
= start
;
2223 loff_t end
= min_t(loff_t
, start
+ len
, mtd
->size
);
2227 if (!part
->updating
) {
2228 rc
= efx_mcdi_nvram_update_start(efx
, part
->nvram_type
);
2231 part
->updating
= true;
2234 while (offset
< end
) {
2235 chunk
= min_t(size_t, end
- offset
, EFX_MCDI_NVRAM_LEN_MAX
);
2236 rc
= efx_mcdi_nvram_write(efx
, part
->nvram_type
, offset
,
2244 *retlen
= offset
- start
;
2248 int efx_mcdi_mtd_sync(struct mtd_info
*mtd
)
2250 struct efx_mcdi_mtd_partition
*part
= to_efx_mcdi_mtd_partition(mtd
);
2251 struct efx_nic
*efx
= mtd
->priv
;
2254 if (part
->updating
) {
2255 part
->updating
= false;
2256 rc
= efx_mcdi_nvram_update_finish(efx
, part
->nvram_type
);
2262 void efx_mcdi_mtd_rename(struct efx_mtd_partition
*part
)
2264 struct efx_mcdi_mtd_partition
*mcdi_part
=
2265 container_of(part
, struct efx_mcdi_mtd_partition
, common
);
2266 struct efx_nic
*efx
= part
->mtd
.priv
;
2268 snprintf(part
->name
, sizeof(part
->name
), "%s %s:%02x",
2269 efx
->name
, part
->type_name
, mcdi_part
->fw_subtype
);
2272 #endif /* CONFIG_SFC_MTD */