2 * Copyright (c) 2017-2018 Cavium, Inc.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 * POSSIBILITY OF SUCH DAMAGE.
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
36 #include "ecore_status.h"
39 #include "ecore_mcp.h"
40 #include "mcp_public.h"
43 #include "ecore_init_fw_funcs.h"
44 #include "ecore_sriov.h"
46 #include "ecore_iov_api.h"
47 #include "ecore_gtt_reg_addr.h"
48 #include "ecore_iro.h"
49 #include "ecore_dcbx.h"
51 #define CHIP_MCP_RESP_ITER_US 10
52 #define EMUL_MCP_RESP_ITER_US 1000 * 1000
54 #define ECORE_DRV_MB_MAX_RETRIES (500 * 1000) /* Account for 5 sec */
55 #define ECORE_MCP_RESET_RETRIES (50 * 1000) /* Account for 500 msec */
57 #define DRV_INNER_WR(_p_hwfn, _p_ptt, _ptr, _offset, _val) \
58 ecore_wr(_p_hwfn, _p_ptt, (_p_hwfn->mcp_info->_ptr + _offset), \
61 #define DRV_INNER_RD(_p_hwfn, _p_ptt, _ptr, _offset) \
62 ecore_rd(_p_hwfn, _p_ptt, (_p_hwfn->mcp_info->_ptr + _offset))
64 #define DRV_MB_WR(_p_hwfn, _p_ptt, _field, _val) \
65 DRV_INNER_WR(p_hwfn, _p_ptt, drv_mb_addr, \
66 OFFSETOF(struct public_drv_mb, _field), _val)
68 #define DRV_MB_RD(_p_hwfn, _p_ptt, _field) \
69 DRV_INNER_RD(_p_hwfn, _p_ptt, drv_mb_addr, \
70 OFFSETOF(struct public_drv_mb, _field))
72 #define PDA_COMP (((FW_MAJOR_VERSION) + (FW_MINOR_VERSION << 8)) << \
73 DRV_ID_PDA_COMP_VER_SHIFT)
75 #define MCP_BYTES_PER_MBIT_SHIFT 17
79 static int loaded_port[MAX_NUM_PORTS] = { 0 };
82 bool ecore_mcp_is_init(struct ecore_hwfn *p_hwfn)
84 if (!p_hwfn->mcp_info || !p_hwfn->mcp_info->public_base)
89 void ecore_mcp_cmd_port_init(struct ecore_hwfn *p_hwfn,
90 struct ecore_ptt *p_ptt)
92 u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
94 u32 mfw_mb_offsize = ecore_rd(p_hwfn, p_ptt, addr);
96 p_hwfn->mcp_info->port_addr = SECTION_ADDR(mfw_mb_offsize,
98 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
99 "port_addr = 0x%x, port_id 0x%02x\n",
100 p_hwfn->mcp_info->port_addr, MFW_PORT(p_hwfn));
103 void ecore_mcp_read_mb(struct ecore_hwfn *p_hwfn,
104 struct ecore_ptt *p_ptt)
106 u32 length = MFW_DRV_MSG_MAX_DWORDS(p_hwfn->mcp_info->mfw_mb_length);
111 if (CHIP_REV_IS_TEDIBEAR(p_hwfn->p_dev))
115 if (!p_hwfn->mcp_info->public_base)
118 for (i = 0; i < length; i++) {
119 tmp = ecore_rd(p_hwfn, p_ptt,
120 p_hwfn->mcp_info->mfw_mb_addr +
121 (i << 2) + sizeof(u32));
123 ((u32 *)p_hwfn->mcp_info->mfw_mb_cur)[i] =
124 OSAL_BE32_TO_CPU(tmp);
128 enum _ecore_status_t ecore_mcp_free(struct ecore_hwfn *p_hwfn)
130 if (p_hwfn->mcp_info) {
131 OSAL_FREE(p_hwfn->p_dev, p_hwfn->mcp_info->mfw_mb_cur);
132 OSAL_FREE(p_hwfn->p_dev, p_hwfn->mcp_info->mfw_mb_shadow);
133 #ifdef CONFIG_ECORE_LOCK_ALLOC
134 OSAL_SPIN_LOCK_DEALLOC(&p_hwfn->mcp_info->lock);
135 OSAL_SPIN_LOCK_DEALLOC(&p_hwfn->mcp_info->link_lock);
138 OSAL_FREE(p_hwfn->p_dev, p_hwfn->mcp_info);
139 p_hwfn->mcp_info = OSAL_NULL;
141 return ECORE_SUCCESS;
144 enum _ecore_status_t ecore_load_mcp_offsets(struct ecore_hwfn *p_hwfn,
145 struct ecore_ptt *p_ptt)
147 struct ecore_mcp_info *p_info = p_hwfn->mcp_info;
148 u32 drv_mb_offsize, mfw_mb_offsize;
149 u32 mcp_pf_id = MCP_PF_ID(p_hwfn);
152 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
153 DP_NOTICE(p_hwfn, false, "Emulation - assume no MFW\n");
154 p_info->public_base = 0;
159 p_info->public_base = ecore_rd(p_hwfn, p_ptt, MISC_REG_SHARED_MEM_ADDR);
160 if (!p_info->public_base)
163 p_info->public_base |= GRCBASE_MCP;
165 /* Calculate the driver and MFW mailbox address */
166 drv_mb_offsize = ecore_rd(p_hwfn, p_ptt,
167 SECTION_OFFSIZE_ADDR(p_info->public_base,
169 p_info->drv_mb_addr = SECTION_ADDR(drv_mb_offsize, mcp_pf_id);
170 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
171 "drv_mb_offsiz = 0x%x, drv_mb_addr = 0x%x mcp_pf_id = 0x%x\n",
172 drv_mb_offsize, p_info->drv_mb_addr, mcp_pf_id);
174 /* Set the MFW MB address */
175 mfw_mb_offsize = ecore_rd(p_hwfn, p_ptt,
176 SECTION_OFFSIZE_ADDR(p_info->public_base,
178 p_info->mfw_mb_addr = SECTION_ADDR(mfw_mb_offsize, mcp_pf_id);
179 p_info->mfw_mb_length = (u16)ecore_rd(p_hwfn, p_ptt,
180 p_info->mfw_mb_addr);
182 /* Get the current driver mailbox sequence before sending
185 p_info->drv_mb_seq = DRV_MB_RD(p_hwfn, p_ptt, drv_mb_header) &
186 DRV_MSG_SEQ_NUMBER_MASK;
188 /* Get current FW pulse sequence */
189 p_info->drv_pulse_seq = DRV_MB_RD(p_hwfn, p_ptt, drv_pulse_mb) &
192 p_info->mcp_hist = (u16)ecore_rd(p_hwfn, p_ptt,
193 MISCS_REG_GENERIC_POR_0);
195 return ECORE_SUCCESS;
198 enum _ecore_status_t ecore_mcp_cmd_init(struct ecore_hwfn *p_hwfn,
199 struct ecore_ptt *p_ptt)
201 struct ecore_mcp_info *p_info;
204 /* Allocate mcp_info structure */
205 p_hwfn->mcp_info = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL,
206 sizeof(*p_hwfn->mcp_info));
207 if (!p_hwfn->mcp_info)
209 p_info = p_hwfn->mcp_info;
211 if (ecore_load_mcp_offsets(p_hwfn, p_ptt) != ECORE_SUCCESS) {
212 DP_NOTICE(p_hwfn, false, "MCP is not initialized\n");
213 /* Do not free mcp_info here, since public_base indicate that
214 * the MCP is not initialized
216 return ECORE_SUCCESS;
219 size = MFW_DRV_MSG_MAX_DWORDS(p_info->mfw_mb_length) * sizeof(u32);
220 p_info->mfw_mb_cur = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL, size);
221 p_info->mfw_mb_shadow = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL, size);
222 if (!p_info->mfw_mb_shadow || !p_info->mfw_mb_addr)
225 /* Initialize the MFW spinlock */
226 #ifdef CONFIG_ECORE_LOCK_ALLOC
227 OSAL_SPIN_LOCK_ALLOC(p_hwfn, &p_info->lock);
228 OSAL_SPIN_LOCK_ALLOC(p_hwfn, &p_info->link_lock);
230 OSAL_SPIN_LOCK_INIT(&p_info->lock);
231 OSAL_SPIN_LOCK_INIT(&p_info->link_lock);
233 return ECORE_SUCCESS;
236 DP_NOTICE(p_hwfn, true, "Failed to allocate mcp memory\n");
237 ecore_mcp_free(p_hwfn);
242 /* Locks the MFW mailbox of a PF to ensure a single access.
243 * The lock is achieved in most cases by holding a spinlock, causing other
244 * threads to wait till a previous access is done.
245 * In some cases (currently when a [UN]LOAD_REQ commands are sent), the single
246 * access is achieved by setting a blocking flag, which will fail other
247 * competing contexts to send their mailboxes.
249 static enum _ecore_status_t ecore_mcp_mb_lock(struct ecore_hwfn *p_hwfn,
252 OSAL_SPIN_LOCK(&p_hwfn->mcp_info->lock);
254 /* The spinlock shouldn't be acquired when the mailbox command is
255 * [UN]LOAD_REQ, since the engine is locked by the MFW, and a parallel
256 * pending [UN]LOAD_REQ command of another PF together with a spinlock
257 * (i.e. interrupts are disabled) - can lead to a deadlock.
258 * It is assumed that for a single PF, no other mailbox commands can be
259 * sent from another context while sending LOAD_REQ, and that any
260 * parallel commands to UNLOAD_REQ can be cancelled.
262 if (cmd == DRV_MSG_CODE_LOAD_DONE || cmd == DRV_MSG_CODE_UNLOAD_DONE)
263 p_hwfn->mcp_info->block_mb_sending = false;
265 /* There's at least a single command that is sent by ecore during the
266 * load sequence [expectation of MFW].
268 if ((p_hwfn->mcp_info->block_mb_sending) &&
269 (cmd != DRV_MSG_CODE_FEATURE_SUPPORT)) {
270 DP_NOTICE(p_hwfn, false,
271 "Trying to send a MFW mailbox command [0x%x] in parallel to [UN]LOAD_REQ. Aborting.\n",
273 OSAL_SPIN_UNLOCK(&p_hwfn->mcp_info->lock);
277 if (cmd == DRV_MSG_CODE_LOAD_REQ || cmd == DRV_MSG_CODE_UNLOAD_REQ) {
278 p_hwfn->mcp_info->block_mb_sending = true;
279 OSAL_SPIN_UNLOCK(&p_hwfn->mcp_info->lock);
282 return ECORE_SUCCESS;
285 static void ecore_mcp_mb_unlock(struct ecore_hwfn *p_hwfn, u32 cmd)
287 if (cmd != DRV_MSG_CODE_LOAD_REQ && cmd != DRV_MSG_CODE_UNLOAD_REQ)
288 OSAL_SPIN_UNLOCK(&p_hwfn->mcp_info->lock);
291 enum _ecore_status_t ecore_mcp_reset(struct ecore_hwfn *p_hwfn,
292 struct ecore_ptt *p_ptt)
294 u32 seq = ++p_hwfn->mcp_info->drv_mb_seq;
295 u32 delay = CHIP_MCP_RESP_ITER_US;
296 u32 org_mcp_reset_seq, cnt = 0;
297 enum _ecore_status_t rc = ECORE_SUCCESS;
300 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev))
301 delay = EMUL_MCP_RESP_ITER_US;
304 /* Ensure that only a single thread is accessing the mailbox at a
307 rc = ecore_mcp_mb_lock(p_hwfn, DRV_MSG_CODE_MCP_RESET);
308 if (rc != ECORE_SUCCESS)
311 /* Set drv command along with the updated sequence */
312 org_mcp_reset_seq = ecore_rd(p_hwfn, p_ptt, MISCS_REG_GENERIC_POR_0);
313 DRV_MB_WR(p_hwfn, p_ptt, drv_mb_header, (DRV_MSG_CODE_MCP_RESET | seq));
316 /* Wait for MFW response */
318 /* Give the FW up to 500 second (50*1000*10usec) */
319 } while ((org_mcp_reset_seq == ecore_rd(p_hwfn, p_ptt,
320 MISCS_REG_GENERIC_POR_0)) &&
321 (cnt++ < ECORE_MCP_RESET_RETRIES));
323 if (org_mcp_reset_seq !=
324 ecore_rd(p_hwfn, p_ptt, MISCS_REG_GENERIC_POR_0)) {
325 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
326 "MCP was reset after %d usec\n", cnt * delay);
328 DP_ERR(p_hwfn, "Failed to reset MCP\n");
332 ecore_mcp_mb_unlock(p_hwfn, DRV_MSG_CODE_MCP_RESET);
337 static enum _ecore_status_t ecore_do_mcp_cmd(struct ecore_hwfn *p_hwfn,
338 struct ecore_ptt *p_ptt,
340 u32 *o_mcp_resp, u32 *o_mcp_param)
342 u32 delay = CHIP_MCP_RESP_ITER_US;
343 u32 max_retries = ECORE_DRV_MB_MAX_RETRIES;
344 u32 seq, cnt = 1, actual_mb_seq;
345 enum _ecore_status_t rc = ECORE_SUCCESS;
348 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev))
349 delay = EMUL_MCP_RESP_ITER_US;
350 /* There is a built-in delay of 100usec in each MFW response read */
351 if (CHIP_REV_IS_FPGA(p_hwfn->p_dev))
355 /* Get actual driver mailbox sequence */
356 actual_mb_seq = DRV_MB_RD(p_hwfn, p_ptt, drv_mb_header) &
357 DRV_MSG_SEQ_NUMBER_MASK;
359 /* Use MCP history register to check if MCP reset occurred between
362 if (p_hwfn->mcp_info->mcp_hist !=
363 ecore_rd(p_hwfn, p_ptt, MISCS_REG_GENERIC_POR_0)) {
364 DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "Rereading MCP offsets\n");
365 ecore_load_mcp_offsets(p_hwfn, p_ptt);
366 ecore_mcp_cmd_port_init(p_hwfn, p_ptt);
368 seq = ++p_hwfn->mcp_info->drv_mb_seq;
371 DRV_MB_WR(p_hwfn, p_ptt, drv_mb_param, param);
373 /* Set drv command along with the updated sequence */
374 DRV_MB_WR(p_hwfn, p_ptt, drv_mb_header, (cmd | seq));
376 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
377 "wrote command (%x) to MFW MB param 0x%08x\n",
381 /* Wait for MFW response */
383 *o_mcp_resp = DRV_MB_RD(p_hwfn, p_ptt, fw_mb_header);
385 /* Give the FW up to 5 second (500*10ms) */
386 } while ((seq != (*o_mcp_resp & FW_MSG_SEQ_NUMBER_MASK)) &&
387 (cnt++ < max_retries));
389 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
390 "[after %d ms] read (%x) seq is (%x) from FW MB\n",
391 cnt * delay, *o_mcp_resp, seq);
393 /* Is this a reply to our command? */
394 if (seq == (*o_mcp_resp & FW_MSG_SEQ_NUMBER_MASK)) {
395 *o_mcp_resp &= FW_MSG_CODE_MASK;
396 /* Get the MCP param */
397 *o_mcp_param = DRV_MB_RD(p_hwfn, p_ptt, fw_mb_param);
400 DP_ERR(p_hwfn, "MFW failed to respond [cmd 0x%x param 0x%x]\n",
404 ecore_hw_err_notify(p_hwfn, ECORE_HW_ERR_MFW_RESP_FAIL);
409 static enum _ecore_status_t ecore_mcp_cmd_and_union(struct ecore_hwfn *p_hwfn,
410 struct ecore_ptt *p_ptt,
411 struct ecore_mcp_mb_params *p_mb_params)
413 union drv_union_data union_data;
415 enum _ecore_status_t rc;
417 /* MCP not initialized */
418 if (!ecore_mcp_is_init(p_hwfn)) {
419 DP_NOTICE(p_hwfn, true, "MFW is not initialized!\n");
423 if (p_mb_params->data_src_size > sizeof(union_data) ||
424 p_mb_params->data_dst_size > sizeof(union_data)) {
426 "The provided size is larger than the union data size [src_size %u, dst_size %u, union_data_size %zu]\n",
427 p_mb_params->data_src_size, p_mb_params->data_dst_size,
432 union_data_addr = p_hwfn->mcp_info->drv_mb_addr +
433 OFFSETOF(struct public_drv_mb, union_data);
435 /* Ensure that only a single thread is accessing the mailbox at a
438 rc = ecore_mcp_mb_lock(p_hwfn, p_mb_params->cmd);
439 if (rc != ECORE_SUCCESS)
442 OSAL_MEM_ZERO(&union_data, sizeof(union_data));
443 if (p_mb_params->p_data_src != OSAL_NULL && p_mb_params->data_src_size)
444 OSAL_MEMCPY(&union_data, p_mb_params->p_data_src,
445 p_mb_params->data_src_size);
446 ecore_memcpy_to(p_hwfn, p_ptt, union_data_addr, &union_data,
449 rc = ecore_do_mcp_cmd(p_hwfn, p_ptt, p_mb_params->cmd,
450 p_mb_params->param, &p_mb_params->mcp_resp,
451 &p_mb_params->mcp_param);
453 if (p_mb_params->p_data_dst != OSAL_NULL &&
454 p_mb_params->data_dst_size)
455 ecore_memcpy_from(p_hwfn, p_ptt, p_mb_params->p_data_dst,
456 union_data_addr, p_mb_params->data_dst_size);
458 ecore_mcp_mb_unlock(p_hwfn, p_mb_params->cmd);
463 enum _ecore_status_t ecore_mcp_cmd(struct ecore_hwfn *p_hwfn,
464 struct ecore_ptt *p_ptt, u32 cmd, u32 param,
465 u32 *o_mcp_resp, u32 *o_mcp_param)
467 struct ecore_mcp_mb_params mb_params;
468 enum _ecore_status_t rc;
471 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
472 if (cmd == DRV_MSG_CODE_UNLOAD_REQ) {
474 loaded_port[p_hwfn->port_id]--;
475 DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "Unload cnt: 0x%x\n",
478 return ECORE_SUCCESS;
482 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
484 mb_params.param = param;
485 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
486 if (rc != ECORE_SUCCESS)
489 *o_mcp_resp = mb_params.mcp_resp;
490 *o_mcp_param = mb_params.mcp_param;
492 return ECORE_SUCCESS;
495 enum _ecore_status_t ecore_mcp_nvm_wr_cmd(struct ecore_hwfn *p_hwfn,
496 struct ecore_ptt *p_ptt,
504 struct ecore_mcp_mb_params mb_params;
505 enum _ecore_status_t rc;
507 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
509 mb_params.param = param;
510 mb_params.p_data_src = i_buf;
511 mb_params.data_src_size = (u8) i_txn_size;
512 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
513 if (rc != ECORE_SUCCESS)
516 *o_mcp_resp = mb_params.mcp_resp;
517 *o_mcp_param = mb_params.mcp_param;
519 return ECORE_SUCCESS;
522 enum _ecore_status_t ecore_mcp_nvm_rd_cmd(struct ecore_hwfn *p_hwfn,
523 struct ecore_ptt *p_ptt,
531 struct ecore_mcp_mb_params mb_params;
532 u8 raw_data[MCP_DRV_NVM_BUF_LEN];
533 enum _ecore_status_t rc;
535 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
537 mb_params.param = param;
538 mb_params.p_data_dst = raw_data;
540 /* Use the maximal value since the actual one is part of the response */
541 mb_params.data_dst_size = MCP_DRV_NVM_BUF_LEN;
543 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
544 if (rc != ECORE_SUCCESS)
547 *o_mcp_resp = mb_params.mcp_resp;
548 *o_mcp_param = mb_params.mcp_param;
550 *o_txn_size = *o_mcp_param;
551 OSAL_MEMCPY(o_buf, raw_data, *o_txn_size);
553 return ECORE_SUCCESS;
557 static void ecore_mcp_mf_workaround(struct ecore_hwfn *p_hwfn,
560 static int load_phase = FW_MSG_CODE_DRV_LOAD_ENGINE;
563 load_phase = FW_MSG_CODE_DRV_LOAD_ENGINE;
564 } else if (!loaded_port[p_hwfn->port_id]) {
565 load_phase = FW_MSG_CODE_DRV_LOAD_PORT;
567 load_phase = FW_MSG_CODE_DRV_LOAD_FUNCTION;
570 /* On CMT, always tell that it's engine */
571 if (p_hwfn->p_dev->num_hwfns > 1)
572 load_phase = FW_MSG_CODE_DRV_LOAD_ENGINE;
574 *p_load_code = load_phase;
576 loaded_port[p_hwfn->port_id]++;
578 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
579 "Load phase: %x load cnt: 0x%x port id=%d port_load=%d\n",
580 *p_load_code, loaded, p_hwfn->port_id,
581 loaded_port[p_hwfn->port_id]);
586 ecore_mcp_can_force_load(u8 drv_role, u8 exist_drv_role,
587 enum ecore_override_force_load override_force_load)
589 bool can_force_load = false;
591 switch (override_force_load) {
592 case ECORE_OVERRIDE_FORCE_LOAD_ALWAYS:
593 can_force_load = true;
595 case ECORE_OVERRIDE_FORCE_LOAD_NEVER:
596 can_force_load = false;
599 can_force_load = (drv_role == DRV_ROLE_OS &&
600 exist_drv_role == DRV_ROLE_PREBOOT) ||
601 (drv_role == DRV_ROLE_KDUMP &&
602 exist_drv_role == DRV_ROLE_OS);
606 return can_force_load;
609 static enum _ecore_status_t ecore_mcp_cancel_load_req(struct ecore_hwfn *p_hwfn,
610 struct ecore_ptt *p_ptt)
612 u32 resp = 0, param = 0;
613 enum _ecore_status_t rc;
615 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_CANCEL_LOAD_REQ, 0,
617 if (rc != ECORE_SUCCESS)
618 DP_NOTICE(p_hwfn, false,
619 "Failed to send cancel load request, rc = %d\n", rc);
624 #define CONFIG_ECORE_L2_BITMAP_IDX (0x1 << 0)
625 #define CONFIG_ECORE_SRIOV_BITMAP_IDX (0x1 << 1)
626 #define CONFIG_ECORE_ROCE_BITMAP_IDX (0x1 << 2)
627 #define CONFIG_ECORE_IWARP_BITMAP_IDX (0x1 << 3)
628 #define CONFIG_ECORE_FCOE_BITMAP_IDX (0x1 << 4)
629 #define CONFIG_ECORE_ISCSI_BITMAP_IDX (0x1 << 5)
630 #define CONFIG_ECORE_LL2_BITMAP_IDX (0x1 << 6)
632 static u32 ecore_get_config_bitmap(void)
634 u32 config_bitmap = 0x0;
636 #ifdef CONFIG_ECORE_L2
637 config_bitmap |= CONFIG_ECORE_L2_BITMAP_IDX;
639 #ifdef CONFIG_ECORE_SRIOV
640 config_bitmap |= CONFIG_ECORE_SRIOV_BITMAP_IDX;
642 #ifdef CONFIG_ECORE_ROCE
643 config_bitmap |= CONFIG_ECORE_ROCE_BITMAP_IDX;
645 #ifdef CONFIG_ECORE_IWARP
646 config_bitmap |= CONFIG_ECORE_IWARP_BITMAP_IDX;
648 #ifdef CONFIG_ECORE_FCOE
649 config_bitmap |= CONFIG_ECORE_FCOE_BITMAP_IDX;
651 #ifdef CONFIG_ECORE_ISCSI
652 config_bitmap |= CONFIG_ECORE_ISCSI_BITMAP_IDX;
654 #ifdef CONFIG_ECORE_LL2
655 config_bitmap |= CONFIG_ECORE_LL2_BITMAP_IDX;
658 return config_bitmap;
661 struct ecore_load_req_in_params {
663 #define ECORE_LOAD_REQ_HSI_VER_DEFAULT 0
664 #define ECORE_LOAD_REQ_HSI_VER_1 1
671 bool avoid_eng_reset;
674 struct ecore_load_req_out_params {
684 static enum _ecore_status_t
685 __ecore_mcp_load_req(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
686 struct ecore_load_req_in_params *p_in_params,
687 struct ecore_load_req_out_params *p_out_params)
689 struct ecore_mcp_mb_params mb_params;
690 struct load_req_stc load_req;
691 struct load_rsp_stc load_rsp;
693 enum _ecore_status_t rc;
695 OSAL_MEM_ZERO(&load_req, sizeof(load_req));
696 load_req.drv_ver_0 = p_in_params->drv_ver_0;
697 load_req.drv_ver_1 = p_in_params->drv_ver_1;
698 load_req.fw_ver = p_in_params->fw_ver;
699 ECORE_MFW_SET_FIELD(load_req.misc0, LOAD_REQ_ROLE,
700 p_in_params->drv_role);
701 ECORE_MFW_SET_FIELD(load_req.misc0, LOAD_REQ_LOCK_TO,
702 p_in_params->timeout_val);
703 ECORE_MFW_SET_FIELD(load_req.misc0, (u64)LOAD_REQ_FORCE,
704 p_in_params->force_cmd);
705 ECORE_MFW_SET_FIELD(load_req.misc0, (u64)LOAD_REQ_FLAGS0,
706 p_in_params->avoid_eng_reset);
708 hsi_ver = (p_in_params->hsi_ver == ECORE_LOAD_REQ_HSI_VER_DEFAULT) ?
709 DRV_ID_MCP_HSI_VER_CURRENT :
710 (p_in_params->hsi_ver << DRV_ID_MCP_HSI_VER_SHIFT);
712 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
713 mb_params.cmd = DRV_MSG_CODE_LOAD_REQ;
714 mb_params.param = PDA_COMP | hsi_ver | p_hwfn->p_dev->drv_type;
715 mb_params.p_data_src = &load_req;
716 mb_params.data_src_size = sizeof(load_req);
717 mb_params.p_data_dst = &load_rsp;
718 mb_params.data_dst_size = sizeof(load_rsp);
720 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
721 "Load Request: param 0x%08x [init_hw %d, drv_type %d, hsi_ver %d, pda 0x%04x]\n",
723 ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_DRV_INIT_HW),
724 ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_DRV_TYPE),
725 ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_MCP_HSI_VER),
726 ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_PDA_COMP_VER));
728 if (p_in_params->hsi_ver != ECORE_LOAD_REQ_HSI_VER_1)
729 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
730 "Load Request: drv_ver 0x%08x_0x%08x, fw_ver 0x%08x, misc0 0x%08x [role %d, timeout %d, force %d, flags0 0x%x]\n",
731 load_req.drv_ver_0, load_req.drv_ver_1,
732 load_req.fw_ver, load_req.misc0,
733 ECORE_MFW_GET_FIELD(load_req.misc0, LOAD_REQ_ROLE),
734 ECORE_MFW_GET_FIELD(load_req.misc0,
736 ECORE_MFW_GET_FIELD(load_req.misc0, LOAD_REQ_FORCE),
737 ECORE_MFW_GET_FIELD(load_req.misc0,
740 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
741 if (rc != ECORE_SUCCESS) {
742 DP_NOTICE(p_hwfn, false,
743 "Failed to send load request, rc = %d\n", rc);
747 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
748 "Load Response: resp 0x%08x\n", mb_params.mcp_resp);
749 p_out_params->load_code = mb_params.mcp_resp;
751 if (p_in_params->hsi_ver != ECORE_LOAD_REQ_HSI_VER_1 &&
752 p_out_params->load_code != FW_MSG_CODE_DRV_LOAD_REFUSED_HSI_1) {
753 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
754 "Load Response: exist_drv_ver 0x%08x_0x%08x, exist_fw_ver 0x%08x, misc0 0x%08x [exist_role %d, mfw_hsi %d, flags0 0x%x]\n",
755 load_rsp.drv_ver_0, load_rsp.drv_ver_1,
756 load_rsp.fw_ver, load_rsp.misc0,
757 ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_ROLE),
758 ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_HSI),
759 ECORE_MFW_GET_FIELD(load_rsp.misc0,
762 p_out_params->exist_drv_ver_0 = load_rsp.drv_ver_0;
763 p_out_params->exist_drv_ver_1 = load_rsp.drv_ver_1;
764 p_out_params->exist_fw_ver = load_rsp.fw_ver;
765 p_out_params->exist_drv_role =
766 ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_ROLE);
767 p_out_params->mfw_hsi_ver =
768 ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_HSI);
769 p_out_params->drv_exists =
770 ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_FLAGS0) &
771 LOAD_RSP_FLAGS0_DRV_EXISTS;
774 return ECORE_SUCCESS;
777 static enum _ecore_status_t eocre_get_mfw_drv_role(struct ecore_hwfn *p_hwfn,
778 enum ecore_drv_role drv_role,
783 case ECORE_DRV_ROLE_OS:
784 *p_mfw_drv_role = DRV_ROLE_OS;
786 case ECORE_DRV_ROLE_KDUMP:
787 *p_mfw_drv_role = DRV_ROLE_KDUMP;
790 DP_ERR(p_hwfn, "Unexpected driver role %d\n", drv_role);
794 return ECORE_SUCCESS;
797 enum ecore_load_req_force {
798 ECORE_LOAD_REQ_FORCE_NONE,
799 ECORE_LOAD_REQ_FORCE_PF,
800 ECORE_LOAD_REQ_FORCE_ALL,
803 static enum _ecore_status_t
804 ecore_get_mfw_force_cmd(struct ecore_hwfn *p_hwfn,
805 enum ecore_load_req_force force_cmd,
809 case ECORE_LOAD_REQ_FORCE_NONE:
810 *p_mfw_force_cmd = LOAD_REQ_FORCE_NONE;
812 case ECORE_LOAD_REQ_FORCE_PF:
813 *p_mfw_force_cmd = LOAD_REQ_FORCE_PF;
815 case ECORE_LOAD_REQ_FORCE_ALL:
816 *p_mfw_force_cmd = LOAD_REQ_FORCE_ALL;
819 DP_ERR(p_hwfn, "Unexpected force value %d\n", force_cmd);
823 return ECORE_SUCCESS;
826 enum _ecore_status_t ecore_mcp_load_req(struct ecore_hwfn *p_hwfn,
827 struct ecore_ptt *p_ptt,
828 struct ecore_load_req_params *p_params)
830 struct ecore_load_req_out_params out_params;
831 struct ecore_load_req_in_params in_params;
832 u8 mfw_drv_role, mfw_force_cmd;
833 enum _ecore_status_t rc;
836 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
837 ecore_mcp_mf_workaround(p_hwfn, &p_params->load_code);
838 return ECORE_SUCCESS;
842 OSAL_MEM_ZERO(&in_params, sizeof(in_params));
843 in_params.hsi_ver = ECORE_LOAD_REQ_HSI_VER_DEFAULT;
844 in_params.drv_ver_0 = ECORE_VERSION;
845 in_params.drv_ver_1 = ecore_get_config_bitmap();
846 in_params.fw_ver = STORM_FW_VERSION;
847 rc = eocre_get_mfw_drv_role(p_hwfn, p_params->drv_role, &mfw_drv_role);
848 if (rc != ECORE_SUCCESS)
851 in_params.drv_role = mfw_drv_role;
852 in_params.timeout_val = p_params->timeout_val;
853 rc = ecore_get_mfw_force_cmd(p_hwfn, ECORE_LOAD_REQ_FORCE_NONE,
855 if (rc != ECORE_SUCCESS)
858 in_params.force_cmd = mfw_force_cmd;
859 in_params.avoid_eng_reset = p_params->avoid_eng_reset;
861 OSAL_MEM_ZERO(&out_params, sizeof(out_params));
862 rc = __ecore_mcp_load_req(p_hwfn, p_ptt, &in_params, &out_params);
863 if (rc != ECORE_SUCCESS)
866 /* First handle cases where another load request should/might be sent:
867 * - MFW expects the old interface [HSI version = 1]
868 * - MFW responds that a force load request is required
870 if (out_params.load_code == FW_MSG_CODE_DRV_LOAD_REFUSED_HSI_1) {
872 "MFW refused a load request due to HSI > 1. Resending with HSI = 1.\n");
874 /* The previous load request set the mailbox blocking */
875 p_hwfn->mcp_info->block_mb_sending = false;
877 in_params.hsi_ver = ECORE_LOAD_REQ_HSI_VER_1;
878 OSAL_MEM_ZERO(&out_params, sizeof(out_params));
879 rc = __ecore_mcp_load_req(p_hwfn, p_ptt, &in_params,
881 if (rc != ECORE_SUCCESS)
883 } else if (out_params.load_code ==
884 FW_MSG_CODE_DRV_LOAD_REFUSED_REQUIRES_FORCE) {
885 /* The previous load request set the mailbox blocking */
886 p_hwfn->mcp_info->block_mb_sending = false;
888 if (ecore_mcp_can_force_load(in_params.drv_role,
889 out_params.exist_drv_role,
890 p_params->override_force_load)) {
892 "A force load is required [{role, fw_ver, drv_ver}: loading={%d, 0x%08x, x%08x_0x%08x}, existing={%d, 0x%08x, 0x%08x_0x%08x}]\n",
893 in_params.drv_role, in_params.fw_ver,
894 in_params.drv_ver_0, in_params.drv_ver_1,
895 out_params.exist_drv_role,
896 out_params.exist_fw_ver,
897 out_params.exist_drv_ver_0,
898 out_params.exist_drv_ver_1);
899 DP_INFO(p_hwfn, "Sending a force load request\n");
901 rc = ecore_get_mfw_force_cmd(p_hwfn,
902 ECORE_LOAD_REQ_FORCE_ALL,
904 if (rc != ECORE_SUCCESS)
907 in_params.force_cmd = mfw_force_cmd;
908 OSAL_MEM_ZERO(&out_params, sizeof(out_params));
909 rc = __ecore_mcp_load_req(p_hwfn, p_ptt, &in_params,
911 if (rc != ECORE_SUCCESS)
914 DP_NOTICE(p_hwfn, false,
915 "A force load is required [{role, fw_ver, drv_ver}: loading={%d, 0x%08x, x%08x_0x%08x}, existing={%d, 0x%08x, 0x%08x_0x%08x}]\n",
916 in_params.drv_role, in_params.fw_ver,
917 in_params.drv_ver_0, in_params.drv_ver_1,
918 out_params.exist_drv_role,
919 out_params.exist_fw_ver,
920 out_params.exist_drv_ver_0,
921 out_params.exist_drv_ver_1);
922 DP_NOTICE(p_hwfn, false,
923 "Avoid sending a force load request to prevent disruption of active PFs\n");
925 ecore_mcp_cancel_load_req(p_hwfn, p_ptt);
930 /* Now handle the other types of responses.
931 * The "REFUSED_HSI_1" and "REFUSED_REQUIRES_FORCE" responses are not
932 * expected here after the additional revised load requests were sent.
934 switch (out_params.load_code) {
935 case FW_MSG_CODE_DRV_LOAD_ENGINE:
936 case FW_MSG_CODE_DRV_LOAD_PORT:
937 case FW_MSG_CODE_DRV_LOAD_FUNCTION:
938 if (out_params.mfw_hsi_ver != ECORE_LOAD_REQ_HSI_VER_1 &&
939 out_params.drv_exists) {
940 /* The role and fw/driver version match, but the PF is
941 * already loaded and has not been unloaded gracefully.
942 * This is unexpected since a quasi-FLR request was
943 * previously sent as part of ecore_hw_prepare().
945 DP_NOTICE(p_hwfn, false,
946 "PF is already loaded - shouldn't have got here since a quasi-FLR request was previously sent!\n");
950 case FW_MSG_CODE_DRV_LOAD_REFUSED_PDA:
951 case FW_MSG_CODE_DRV_LOAD_REFUSED_DIAG:
952 case FW_MSG_CODE_DRV_LOAD_REFUSED_HSI:
953 case FW_MSG_CODE_DRV_LOAD_REFUSED_REJECT:
954 DP_NOTICE(p_hwfn, false,
955 "MFW refused a load request [resp 0x%08x]. Aborting.\n",
956 out_params.load_code);
959 DP_NOTICE(p_hwfn, false,
960 "Unexpected response to load request [resp 0x%08x]. Aborting.\n",
961 out_params.load_code);
965 p_params->load_code = out_params.load_code;
967 return ECORE_SUCCESS;
970 enum _ecore_status_t ecore_mcp_unload_req(struct ecore_hwfn *p_hwfn,
971 struct ecore_ptt *p_ptt)
973 u32 wol_param, mcp_resp, mcp_param;
975 switch (p_hwfn->p_dev->wol_config) {
976 case ECORE_OV_WOL_DISABLED:
977 wol_param = DRV_MB_PARAM_UNLOAD_WOL_DISABLED;
979 case ECORE_OV_WOL_ENABLED:
980 wol_param = DRV_MB_PARAM_UNLOAD_WOL_ENABLED;
983 DP_NOTICE(p_hwfn, true,
984 "Unknown WoL configuration %02x\n",
985 p_hwfn->p_dev->wol_config);
987 case ECORE_OV_WOL_DEFAULT:
988 wol_param = DRV_MB_PARAM_UNLOAD_WOL_MCP;
991 return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_UNLOAD_REQ, wol_param,
992 &mcp_resp, &mcp_param);
995 enum _ecore_status_t ecore_mcp_unload_done(struct ecore_hwfn *p_hwfn,
996 struct ecore_ptt *p_ptt)
998 struct ecore_mcp_mb_params mb_params;
999 struct mcp_mac wol_mac;
1001 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1002 mb_params.cmd = DRV_MSG_CODE_UNLOAD_DONE;
1004 /* Set the primary MAC if WoL is enabled */
1005 if (p_hwfn->p_dev->wol_config == ECORE_OV_WOL_ENABLED) {
1006 u8 *p_mac = p_hwfn->p_dev->wol_mac;
1008 OSAL_MEM_ZERO(&wol_mac, sizeof(wol_mac));
1009 wol_mac.mac_upper = p_mac[0] << 8 | p_mac[1];
1010 wol_mac.mac_lower = p_mac[2] << 24 | p_mac[3] << 16 |
1011 p_mac[4] << 8 | p_mac[5];
1013 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_IFDOWN),
1014 "Setting WoL MAC: %02x:%02x:%02x:%02x:%02x:%02x --> [%08x,%08x]\n",
1015 p_mac[0], p_mac[1], p_mac[2], p_mac[3], p_mac[4],
1016 p_mac[5], wol_mac.mac_upper, wol_mac.mac_lower);
1018 mb_params.p_data_src = &wol_mac;
1019 mb_params.data_src_size = sizeof(wol_mac);
1022 return ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1025 static void ecore_mcp_handle_vf_flr(struct ecore_hwfn *p_hwfn,
1026 struct ecore_ptt *p_ptt)
1028 u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1030 u32 mfw_path_offsize = ecore_rd(p_hwfn, p_ptt, addr);
1031 u32 path_addr = SECTION_ADDR(mfw_path_offsize,
1032 ECORE_PATH_ID(p_hwfn));
1033 u32 disabled_vfs[VF_MAX_STATIC / 32];
1036 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1037 "Reading Disabled VF information from [offset %08x], path_addr %08x\n",
1038 mfw_path_offsize, path_addr);
1040 for (i = 0; i < (VF_MAX_STATIC / 32); i++) {
1041 disabled_vfs[i] = ecore_rd(p_hwfn, p_ptt,
1043 OFFSETOF(struct public_path,
1046 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_IOV),
1047 "FLR-ed VFs [%08x,...,%08x] - %08x\n",
1048 i * 32, (i + 1) * 32 - 1, disabled_vfs[i]);
1051 if (ecore_iov_mark_vf_flr(p_hwfn, disabled_vfs))
1052 OSAL_VF_FLR_UPDATE(p_hwfn);
1055 enum _ecore_status_t ecore_mcp_ack_vf_flr(struct ecore_hwfn *p_hwfn,
1056 struct ecore_ptt *p_ptt,
1059 u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1061 u32 mfw_func_offsize = ecore_rd(p_hwfn, p_ptt, addr);
1062 u32 func_addr = SECTION_ADDR(mfw_func_offsize,
1064 struct ecore_mcp_mb_params mb_params;
1065 enum _ecore_status_t rc;
1068 for (i = 0; i < (VF_MAX_STATIC / 32); i++)
1069 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_IOV),
1070 "Acking VFs [%08x,...,%08x] - %08x\n",
1071 i * 32, (i + 1) * 32 - 1, vfs_to_ack[i]);
1073 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1074 mb_params.cmd = DRV_MSG_CODE_VF_DISABLED_DONE;
1075 mb_params.p_data_src = vfs_to_ack;
1076 mb_params.data_src_size = VF_MAX_STATIC / 8;
1077 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1078 if (rc != ECORE_SUCCESS) {
1079 DP_NOTICE(p_hwfn, false,
1080 "Failed to pass ACK for VF flr to MFW\n");
1081 return ECORE_TIMEOUT;
1084 /* TMP - clear the ACK bits; should be done by MFW */
1085 for (i = 0; i < (VF_MAX_STATIC / 32); i++)
1086 ecore_wr(p_hwfn, p_ptt,
1088 OFFSETOF(struct public_func, drv_ack_vf_disabled) +
1089 i * sizeof(u32), 0);
1094 static void ecore_mcp_handle_transceiver_change(struct ecore_hwfn *p_hwfn,
1095 struct ecore_ptt *p_ptt)
1097 u32 transceiver_state;
1099 transceiver_state = ecore_rd(p_hwfn, p_ptt,
1100 p_hwfn->mcp_info->port_addr +
1101 OFFSETOF(struct public_port,
1104 DP_VERBOSE(p_hwfn, (ECORE_MSG_HW | ECORE_MSG_SP),
1105 "Received transceiver state update [0x%08x] from mfw [Addr 0x%x]\n",
1106 transceiver_state, (u32)(p_hwfn->mcp_info->port_addr +
1107 OFFSETOF(struct public_port,
1108 transceiver_data)));
1110 transceiver_state = GET_FIELD(transceiver_state, ETH_TRANSCEIVER_STATE);
1112 if (transceiver_state == ETH_TRANSCEIVER_STATE_PRESENT)
1113 DP_NOTICE(p_hwfn, false, "Transceiver is present.\n");
1115 DP_NOTICE(p_hwfn, false, "Transceiver is unplugged.\n");
1118 static void ecore_mcp_read_eee_config(struct ecore_hwfn *p_hwfn,
1119 struct ecore_ptt *p_ptt,
1120 struct ecore_mcp_link_state *p_link)
1122 u32 eee_status, val;
1124 p_link->eee_adv_caps = 0;
1125 p_link->eee_lp_adv_caps = 0;
1126 eee_status = ecore_rd(p_hwfn, p_ptt, p_hwfn->mcp_info->port_addr +
1127 OFFSETOF(struct public_port, eee_status));
1128 p_link->eee_active = !!(eee_status & EEE_ACTIVE_BIT);
1129 val = (eee_status & EEE_LD_ADV_STATUS_MASK) >> EEE_LD_ADV_STATUS_SHIFT;
1130 if (val & EEE_1G_ADV)
1131 p_link->eee_adv_caps |= ECORE_EEE_1G_ADV;
1132 if (val & EEE_10G_ADV)
1133 p_link->eee_adv_caps |= ECORE_EEE_10G_ADV;
1134 val = (eee_status & EEE_LP_ADV_STATUS_MASK) >> EEE_LP_ADV_STATUS_SHIFT;
1135 if (val & EEE_1G_ADV)
1136 p_link->eee_lp_adv_caps |= ECORE_EEE_1G_ADV;
1137 if (val & EEE_10G_ADV)
1138 p_link->eee_lp_adv_caps |= ECORE_EEE_10G_ADV;
1141 static void ecore_mcp_handle_link_change(struct ecore_hwfn *p_hwfn,
1142 struct ecore_ptt *p_ptt,
1145 struct ecore_mcp_link_state *p_link;
1149 /* Prevent SW/attentions from doing this at the same time */
1150 OSAL_SPIN_LOCK(&p_hwfn->mcp_info->link_lock);
1152 p_link = &p_hwfn->mcp_info->link_output;
1153 OSAL_MEMSET(p_link, 0, sizeof(*p_link));
1155 status = ecore_rd(p_hwfn, p_ptt,
1156 p_hwfn->mcp_info->port_addr +
1157 OFFSETOF(struct public_port, link_status));
1158 DP_VERBOSE(p_hwfn, (ECORE_MSG_LINK | ECORE_MSG_SP),
1159 "Received link update [0x%08x] from mfw [Addr 0x%x]\n",
1160 status, (u32)(p_hwfn->mcp_info->port_addr +
1161 OFFSETOF(struct public_port, link_status)));
1163 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK,
1164 "Resetting link indications\n");
1168 if (p_hwfn->b_drv_link_init)
1169 p_link->link_up = !!(status & LINK_STATUS_LINK_UP);
1171 p_link->link_up = false;
1173 p_link->full_duplex = true;
1174 switch ((status & LINK_STATUS_SPEED_AND_DUPLEX_MASK)) {
1175 case LINK_STATUS_SPEED_AND_DUPLEX_100G:
1176 p_link->speed = 100000;
1178 case LINK_STATUS_SPEED_AND_DUPLEX_50G:
1179 p_link->speed = 50000;
1181 case LINK_STATUS_SPEED_AND_DUPLEX_40G:
1182 p_link->speed = 40000;
1184 case LINK_STATUS_SPEED_AND_DUPLEX_25G:
1185 p_link->speed = 25000;
1187 case LINK_STATUS_SPEED_AND_DUPLEX_20G:
1188 p_link->speed = 20000;
1190 case LINK_STATUS_SPEED_AND_DUPLEX_10G:
1191 p_link->speed = 10000;
1193 case LINK_STATUS_SPEED_AND_DUPLEX_1000THD:
1194 p_link->full_duplex = false;
1196 case LINK_STATUS_SPEED_AND_DUPLEX_1000TFD:
1197 p_link->speed = 1000;
1203 /* We never store total line speed as p_link->speed is
1204 * again changes according to bandwidth allocation.
1206 if (p_link->link_up && p_link->speed)
1207 p_link->line_speed = p_link->speed;
1209 p_link->line_speed = 0;
1211 max_bw = p_hwfn->mcp_info->func_info.bandwidth_max;
1212 min_bw = p_hwfn->mcp_info->func_info.bandwidth_min;
1214 /* Max bandwidth configuration */
1215 __ecore_configure_pf_max_bandwidth(p_hwfn, p_ptt, p_link, max_bw);
1217 /* Mintz bandwidth configuration */
1218 __ecore_configure_pf_min_bandwidth(p_hwfn, p_ptt, p_link, min_bw);
1219 ecore_configure_vp_wfq_on_link_change(p_hwfn->p_dev, p_ptt,
1220 p_link->min_pf_rate);
1222 p_link->an = !!(status & LINK_STATUS_AUTO_NEGOTIATE_ENABLED);
1223 p_link->an_complete = !!(status &
1224 LINK_STATUS_AUTO_NEGOTIATE_COMPLETE);
1225 p_link->parallel_detection = !!(status &
1226 LINK_STATUS_PARALLEL_DETECTION_USED);
1227 p_link->pfc_enabled = !!(status & LINK_STATUS_PFC_ENABLED);
1229 p_link->partner_adv_speed |=
1230 (status & LINK_STATUS_LINK_PARTNER_1000TFD_CAPABLE) ?
1231 ECORE_LINK_PARTNER_SPEED_1G_FD : 0;
1232 p_link->partner_adv_speed |=
1233 (status & LINK_STATUS_LINK_PARTNER_1000THD_CAPABLE) ?
1234 ECORE_LINK_PARTNER_SPEED_1G_HD : 0;
1235 p_link->partner_adv_speed |=
1236 (status & LINK_STATUS_LINK_PARTNER_10G_CAPABLE) ?
1237 ECORE_LINK_PARTNER_SPEED_10G : 0;
1238 p_link->partner_adv_speed |=
1239 (status & LINK_STATUS_LINK_PARTNER_20G_CAPABLE) ?
1240 ECORE_LINK_PARTNER_SPEED_20G : 0;
1241 p_link->partner_adv_speed |=
1242 (status & LINK_STATUS_LINK_PARTNER_25G_CAPABLE) ?
1243 ECORE_LINK_PARTNER_SPEED_25G : 0;
1244 p_link->partner_adv_speed |=
1245 (status & LINK_STATUS_LINK_PARTNER_40G_CAPABLE) ?
1246 ECORE_LINK_PARTNER_SPEED_40G : 0;
1247 p_link->partner_adv_speed |=
1248 (status & LINK_STATUS_LINK_PARTNER_50G_CAPABLE) ?
1249 ECORE_LINK_PARTNER_SPEED_50G : 0;
1250 p_link->partner_adv_speed |=
1251 (status & LINK_STATUS_LINK_PARTNER_100G_CAPABLE) ?
1252 ECORE_LINK_PARTNER_SPEED_100G : 0;
1254 p_link->partner_tx_flow_ctrl_en =
1255 !!(status & LINK_STATUS_TX_FLOW_CONTROL_ENABLED);
1256 p_link->partner_rx_flow_ctrl_en =
1257 !!(status & LINK_STATUS_RX_FLOW_CONTROL_ENABLED);
1259 switch (status & LINK_STATUS_LINK_PARTNER_FLOW_CONTROL_MASK) {
1260 case LINK_STATUS_LINK_PARTNER_SYMMETRIC_PAUSE:
1261 p_link->partner_adv_pause = ECORE_LINK_PARTNER_SYMMETRIC_PAUSE;
1263 case LINK_STATUS_LINK_PARTNER_ASYMMETRIC_PAUSE:
1264 p_link->partner_adv_pause = ECORE_LINK_PARTNER_ASYMMETRIC_PAUSE;
1266 case LINK_STATUS_LINK_PARTNER_BOTH_PAUSE:
1267 p_link->partner_adv_pause = ECORE_LINK_PARTNER_BOTH_PAUSE;
1270 p_link->partner_adv_pause = 0;
1273 p_link->sfp_tx_fault = !!(status & LINK_STATUS_SFP_TX_FAULT);
1275 if (p_hwfn->mcp_info->capabilities & FW_MB_PARAM_FEATURE_SUPPORT_EEE)
1276 ecore_mcp_read_eee_config(p_hwfn, p_ptt, p_link);
1278 OSAL_LINK_UPDATE(p_hwfn);
1280 OSAL_SPIN_UNLOCK(&p_hwfn->mcp_info->link_lock);
1283 enum _ecore_status_t ecore_mcp_set_link(struct ecore_hwfn *p_hwfn,
1284 struct ecore_ptt *p_ptt,
1287 struct ecore_mcp_link_params *params = &p_hwfn->mcp_info->link_input;
1288 struct ecore_mcp_mb_params mb_params;
1289 struct eth_phy_cfg phy_cfg;
1290 enum _ecore_status_t rc = ECORE_SUCCESS;
1294 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev))
1295 return ECORE_SUCCESS;
1298 /* Set the shmem configuration according to params */
1299 OSAL_MEM_ZERO(&phy_cfg, sizeof(phy_cfg));
1300 cmd = b_up ? DRV_MSG_CODE_INIT_PHY : DRV_MSG_CODE_LINK_RESET;
1301 if (!params->speed.autoneg)
1302 phy_cfg.speed = params->speed.forced_speed;
1303 phy_cfg.pause |= (params->pause.autoneg) ? ETH_PAUSE_AUTONEG : 0;
1304 phy_cfg.pause |= (params->pause.forced_rx) ? ETH_PAUSE_RX : 0;
1305 phy_cfg.pause |= (params->pause.forced_tx) ? ETH_PAUSE_TX : 0;
1306 phy_cfg.adv_speed = params->speed.advertised_speeds;
1307 phy_cfg.loopback_mode = params->loopback_mode;
1308 if (p_hwfn->mcp_info->capabilities & FW_MB_PARAM_FEATURE_SUPPORT_EEE) {
1309 if (params->eee.enable)
1310 phy_cfg.eee_cfg |= EEE_CFG_EEE_ENABLED;
1311 if (params->eee.tx_lpi_enable)
1312 phy_cfg.eee_cfg |= EEE_CFG_TX_LPI;
1313 if (params->eee.adv_caps & ECORE_EEE_1G_ADV)
1314 phy_cfg.eee_cfg |= EEE_CFG_ADV_SPEED_1G;
1315 if (params->eee.adv_caps & ECORE_EEE_10G_ADV)
1316 phy_cfg.eee_cfg |= EEE_CFG_ADV_SPEED_10G;
1317 phy_cfg.eee_cfg |= (params->eee.tx_lpi_timer <<
1318 EEE_TX_TIMER_USEC_SHIFT) &
1319 EEE_TX_TIMER_USEC_MASK;
1322 p_hwfn->b_drv_link_init = b_up;
1325 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK,
1326 "Configuring Link: Speed 0x%08x, Pause 0x%08x, adv_speed 0x%08x, loopback 0x%08x\n",
1327 phy_cfg.speed, phy_cfg.pause, phy_cfg.adv_speed,
1328 phy_cfg.loopback_mode);
1330 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK, "Resetting link\n");
1332 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1333 mb_params.cmd = cmd;
1334 mb_params.p_data_src = &phy_cfg;
1335 mb_params.data_src_size = sizeof(phy_cfg);
1336 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1338 /* if mcp fails to respond we must abort */
1339 if (rc != ECORE_SUCCESS) {
1340 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
1344 /* Mimic link-change attention, done for several reasons:
1345 * - On reset, there's no guarantee MFW would trigger
1347 * - On initialization, older MFWs might not indicate link change
1348 * during LFA, so we'll never get an UP indication.
1350 ecore_mcp_handle_link_change(p_hwfn, p_ptt, !b_up);
1355 u32 ecore_get_process_kill_counter(struct ecore_hwfn *p_hwfn,
1356 struct ecore_ptt *p_ptt)
1358 u32 path_offsize_addr, path_offsize, path_addr, proc_kill_cnt;
1360 /* TODO - Add support for VFs */
1361 if (IS_VF(p_hwfn->p_dev))
1364 path_offsize_addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1366 path_offsize = ecore_rd(p_hwfn, p_ptt, path_offsize_addr);
1367 path_addr = SECTION_ADDR(path_offsize, ECORE_PATH_ID(p_hwfn));
1369 proc_kill_cnt = ecore_rd(p_hwfn, p_ptt,
1371 OFFSETOF(struct public_path, process_kill)) &
1372 PROCESS_KILL_COUNTER_MASK;
1374 return proc_kill_cnt;
1377 static void ecore_mcp_handle_process_kill(struct ecore_hwfn *p_hwfn,
1378 struct ecore_ptt *p_ptt)
1380 struct ecore_dev *p_dev = p_hwfn->p_dev;
1383 /* Prevent possible attentions/interrupts during the recovery handling
1384 * and till its load phase, during which they will be re-enabled.
1386 ecore_int_igu_disable_int(p_hwfn, p_ptt);
1388 DP_NOTICE(p_hwfn, false, "Received a process kill indication\n");
1390 /* The following operations should be done once, and thus in CMT mode
1391 * are carried out by only the first HW function.
1393 if (p_hwfn != ECORE_LEADING_HWFN(p_dev))
1396 if (p_dev->recov_in_prog) {
1397 DP_NOTICE(p_hwfn, false,
1398 "Ignoring the indication since a recovery process is already in progress\n");
1402 p_dev->recov_in_prog = true;
1404 proc_kill_cnt = ecore_get_process_kill_counter(p_hwfn, p_ptt);
1405 DP_NOTICE(p_hwfn, false, "Process kill counter: %d\n", proc_kill_cnt);
1407 OSAL_SCHEDULE_RECOVERY_HANDLER(p_hwfn);
1410 static void ecore_mcp_send_protocol_stats(struct ecore_hwfn *p_hwfn,
1411 struct ecore_ptt *p_ptt,
1412 enum MFW_DRV_MSG_TYPE type)
1414 enum ecore_mcp_protocol_type stats_type;
1415 union ecore_mcp_protocol_stats stats;
1416 struct ecore_mcp_mb_params mb_params;
1418 enum _ecore_status_t rc;
1421 case MFW_DRV_MSG_GET_LAN_STATS:
1422 stats_type = ECORE_MCP_LAN_STATS;
1423 hsi_param = DRV_MSG_CODE_STATS_TYPE_LAN;
1425 case MFW_DRV_MSG_GET_FCOE_STATS:
1426 stats_type = ECORE_MCP_FCOE_STATS;
1427 hsi_param = DRV_MSG_CODE_STATS_TYPE_FCOE;
1429 case MFW_DRV_MSG_GET_ISCSI_STATS:
1430 stats_type = ECORE_MCP_ISCSI_STATS;
1431 hsi_param = DRV_MSG_CODE_STATS_TYPE_ISCSI;
1433 case MFW_DRV_MSG_GET_RDMA_STATS:
1434 stats_type = ECORE_MCP_RDMA_STATS;
1435 hsi_param = DRV_MSG_CODE_STATS_TYPE_RDMA;
1438 DP_NOTICE(p_hwfn, false, "Invalid protocol type %d\n", type);
1442 OSAL_GET_PROTOCOL_STATS(p_hwfn->p_dev, stats_type, &stats);
1444 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1445 mb_params.cmd = DRV_MSG_CODE_GET_STATS;
1446 mb_params.param = hsi_param;
1447 mb_params.p_data_src = &stats;
1448 mb_params.data_src_size = sizeof(stats);
1449 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1450 if (rc != ECORE_SUCCESS)
1451 DP_ERR(p_hwfn, "Failed to send protocol stats, rc = %d\n", rc);
1454 static void ecore_read_pf_bandwidth(struct ecore_hwfn *p_hwfn,
1455 struct public_func *p_shmem_info)
1457 struct ecore_mcp_function_info *p_info;
1459 p_info = &p_hwfn->mcp_info->func_info;
1461 /* TODO - bandwidth min/max should have valid values of 1-100,
1462 * as well as some indication that the feature is disabled.
1463 * Until MFW/qlediag enforce those limitations, Assume THERE IS ALWAYS
1464 * limit and correct value to min `1' and max `100' if limit isn't in
1467 p_info->bandwidth_min = (p_shmem_info->config &
1468 FUNC_MF_CFG_MIN_BW_MASK) >>
1469 FUNC_MF_CFG_MIN_BW_SHIFT;
1470 if (p_info->bandwidth_min < 1 || p_info->bandwidth_min > 100) {
1472 "bandwidth minimum out of bounds [%02x]. Set to 1\n",
1473 p_info->bandwidth_min);
1474 p_info->bandwidth_min = 1;
1477 p_info->bandwidth_max = (p_shmem_info->config &
1478 FUNC_MF_CFG_MAX_BW_MASK) >>
1479 FUNC_MF_CFG_MAX_BW_SHIFT;
1480 if (p_info->bandwidth_max < 1 || p_info->bandwidth_max > 100) {
1482 "bandwidth maximum out of bounds [%02x]. Set to 100\n",
1483 p_info->bandwidth_max);
1484 p_info->bandwidth_max = 100;
1488 static u32 ecore_mcp_get_shmem_func(struct ecore_hwfn *p_hwfn,
1489 struct ecore_ptt *p_ptt,
1490 struct public_func *p_data,
1493 u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1495 u32 mfw_path_offsize = ecore_rd(p_hwfn, p_ptt, addr);
1496 u32 func_addr = SECTION_ADDR(mfw_path_offsize, pfid);
1499 OSAL_MEM_ZERO(p_data, sizeof(*p_data));
1501 size = OSAL_MIN_T(u32, sizeof(*p_data),
1502 SECTION_SIZE(mfw_path_offsize));
1503 for (i = 0; i < size / sizeof(u32); i++)
1504 ((u32 *)p_data)[i] = ecore_rd(p_hwfn, p_ptt,
1505 func_addr + (i << 2));
1510 /* This was introduced with FW 8.10.5.0; Hopefully this is only temp. */
1511 enum _ecore_status_t ecore_hw_init_first_eth(struct ecore_hwfn *p_hwfn,
1512 struct ecore_ptt *p_ptt,
1515 struct public_func shmem_info;
1518 /* Find first Ethernet interface in port */
1519 for (i = 0; i < NUM_OF_ENG_PFS(p_hwfn->p_dev);
1520 i += p_hwfn->p_dev->num_ports_in_engines) {
1521 ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info,
1522 MCP_PF_ID_BY_REL(p_hwfn, i));
1524 if (shmem_info.config & FUNC_MF_CFG_FUNC_HIDE)
1527 if ((shmem_info.config & FUNC_MF_CFG_PROTOCOL_MASK) ==
1528 FUNC_MF_CFG_PROTOCOL_ETHERNET) {
1530 return ECORE_SUCCESS;
1534 /* This might actually be valid somewhere in the future but for now
1535 * it's highly unlikely.
1537 DP_NOTICE(p_hwfn, false,
1538 "Failed to find on port an ethernet interface in MF_SI mode\n");
1544 ecore_mcp_update_bw(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt)
1546 struct ecore_mcp_function_info *p_info;
1547 struct public_func shmem_info;
1548 u32 resp = 0, param = 0;
1550 ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info,
1553 ecore_read_pf_bandwidth(p_hwfn, &shmem_info);
1555 p_info = &p_hwfn->mcp_info->func_info;
1557 ecore_configure_pf_min_bandwidth(p_hwfn->p_dev, p_info->bandwidth_min);
1559 ecore_configure_pf_max_bandwidth(p_hwfn->p_dev, p_info->bandwidth_max);
1561 /* Acknowledge the MFW */
1562 ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BW_UPDATE_ACK, 0, &resp,
1566 static void ecore_mcp_update_stag(struct ecore_hwfn *p_hwfn,
1567 struct ecore_ptt *p_ptt)
1569 struct public_func shmem_info;
1570 u32 resp = 0, param = 0;
1572 ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info,
1575 p_hwfn->mcp_info->func_info.ovlan = (u16)shmem_info.ovlan_stag &
1576 FUNC_MF_CFG_OV_STAG_MASK;
1577 p_hwfn->hw_info.ovlan = p_hwfn->mcp_info->func_info.ovlan;
1578 if ((p_hwfn->hw_info.hw_mode & (1 << MODE_MF_SD)) &&
1579 (p_hwfn->hw_info.ovlan != ECORE_MCP_VLAN_UNSET))
1580 ecore_wr(p_hwfn, p_ptt,
1581 NIG_REG_LLH_FUNC_TAG_VALUE,
1582 p_hwfn->hw_info.ovlan);
1584 OSAL_HW_INFO_CHANGE(p_hwfn, ECORE_HW_INFO_CHANGE_OVLAN);
1586 /* Acknowledge the MFW */
1587 ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_S_TAG_UPDATE_ACK, 0,
1591 static void ecore_mcp_handle_fan_failure(struct ecore_hwfn *p_hwfn,
1592 struct ecore_ptt *p_ptt)
1594 /* A single notification should be sent to upper driver in CMT mode */
1595 if (p_hwfn != ECORE_LEADING_HWFN(p_hwfn->p_dev))
1598 DP_NOTICE(p_hwfn, false,
1599 "Fan failure was detected on the network interface card and it's going to be shut down.\n");
1601 ecore_hw_err_notify(p_hwfn, ECORE_HW_ERR_FAN_FAIL);
1604 struct ecore_mdump_cmd_params {
1613 static enum _ecore_status_t
1614 ecore_mcp_mdump_cmd(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
1615 struct ecore_mdump_cmd_params *p_mdump_cmd_params)
1617 struct ecore_mcp_mb_params mb_params;
1618 enum _ecore_status_t rc;
1620 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1621 mb_params.cmd = DRV_MSG_CODE_MDUMP_CMD;
1622 mb_params.param = p_mdump_cmd_params->cmd;
1623 mb_params.p_data_src = p_mdump_cmd_params->p_data_src;
1624 mb_params.data_src_size = p_mdump_cmd_params->data_src_size;
1625 mb_params.p_data_dst = p_mdump_cmd_params->p_data_dst;
1626 mb_params.data_dst_size = p_mdump_cmd_params->data_dst_size;
1627 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1628 if (rc != ECORE_SUCCESS)
1631 p_mdump_cmd_params->mcp_resp = mb_params.mcp_resp;
1633 if (p_mdump_cmd_params->mcp_resp == FW_MSG_CODE_MDUMP_INVALID_CMD) {
1635 "The mdump sub command is unsupported by the MFW [mdump_cmd 0x%x]\n",
1636 p_mdump_cmd_params->cmd);
1638 } else if (p_mdump_cmd_params->mcp_resp == FW_MSG_CODE_UNSUPPORTED) {
1640 "The mdump command is not supported by the MFW\n");
1647 static enum _ecore_status_t ecore_mcp_mdump_ack(struct ecore_hwfn *p_hwfn,
1648 struct ecore_ptt *p_ptt)
1650 struct ecore_mdump_cmd_params mdump_cmd_params;
1652 OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1653 mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_ACK;
1655 return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1658 enum _ecore_status_t ecore_mcp_mdump_set_values(struct ecore_hwfn *p_hwfn,
1659 struct ecore_ptt *p_ptt,
1662 struct ecore_mdump_cmd_params mdump_cmd_params;
1664 OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1665 mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_SET_VALUES;
1666 mdump_cmd_params.p_data_src = &epoch;
1667 mdump_cmd_params.data_src_size = sizeof(epoch);
1669 return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1672 enum _ecore_status_t ecore_mcp_mdump_trigger(struct ecore_hwfn *p_hwfn,
1673 struct ecore_ptt *p_ptt)
1675 struct ecore_mdump_cmd_params mdump_cmd_params;
1677 OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1678 mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_TRIGGER;
1680 return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1683 static enum _ecore_status_t
1684 ecore_mcp_mdump_get_config(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
1685 struct mdump_config_stc *p_mdump_config)
1687 struct ecore_mdump_cmd_params mdump_cmd_params;
1688 enum _ecore_status_t rc;
1690 OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1691 mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_GET_CONFIG;
1692 mdump_cmd_params.p_data_dst = p_mdump_config;
1693 mdump_cmd_params.data_dst_size = sizeof(*p_mdump_config);
1695 rc = ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1696 if (rc != ECORE_SUCCESS)
1699 if (mdump_cmd_params.mcp_resp != FW_MSG_CODE_OK) {
1701 "Failed to get the mdump configuration and logs info [mcp_resp 0x%x]\n",
1702 mdump_cmd_params.mcp_resp);
1703 rc = ECORE_UNKNOWN_ERROR;
1709 enum _ecore_status_t
1710 ecore_mcp_mdump_get_info(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
1711 struct ecore_mdump_info *p_mdump_info)
1713 u32 addr, global_offsize, global_addr;
1714 struct mdump_config_stc mdump_config;
1715 enum _ecore_status_t rc;
1717 OSAL_MEMSET(p_mdump_info, 0, sizeof(*p_mdump_info));
1719 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1721 global_offsize = ecore_rd(p_hwfn, p_ptt, addr);
1722 global_addr = SECTION_ADDR(global_offsize, 0);
1723 p_mdump_info->reason = ecore_rd(p_hwfn, p_ptt,
1725 OFFSETOF(struct public_global,
1728 if (p_mdump_info->reason) {
1729 rc = ecore_mcp_mdump_get_config(p_hwfn, p_ptt, &mdump_config);
1730 if (rc != ECORE_SUCCESS)
1733 p_mdump_info->version = mdump_config.version;
1734 p_mdump_info->config = mdump_config.config;
1735 p_mdump_info->epoch = mdump_config.epoc;
1736 p_mdump_info->num_of_logs = mdump_config.num_of_logs;
1737 p_mdump_info->valid_logs = mdump_config.valid_logs;
1739 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1740 "MFW mdump info: reason %d, version 0x%x, config 0x%x, epoch 0x%x, num_of_logs 0x%x, valid_logs 0x%x\n",
1741 p_mdump_info->reason, p_mdump_info->version,
1742 p_mdump_info->config, p_mdump_info->epoch,
1743 p_mdump_info->num_of_logs, p_mdump_info->valid_logs);
1745 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1746 "MFW mdump info: reason %d\n", p_mdump_info->reason);
1749 return ECORE_SUCCESS;
1752 enum _ecore_status_t ecore_mcp_mdump_clear_logs(struct ecore_hwfn *p_hwfn,
1753 struct ecore_ptt *p_ptt)
1755 struct ecore_mdump_cmd_params mdump_cmd_params;
1757 OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1758 mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_CLEAR_LOGS;
1760 return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1763 enum _ecore_status_t
1764 ecore_mcp_mdump_get_retain(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
1765 struct ecore_mdump_retain_data *p_mdump_retain)
1767 struct ecore_mdump_cmd_params mdump_cmd_params;
1768 struct mdump_retain_data_stc mfw_mdump_retain;
1769 enum _ecore_status_t rc;
1771 OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1772 mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_GET_RETAIN;
1773 mdump_cmd_params.p_data_dst = &mfw_mdump_retain;
1774 mdump_cmd_params.data_dst_size = sizeof(mfw_mdump_retain);
1776 rc = ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1777 if (rc != ECORE_SUCCESS)
1780 if (mdump_cmd_params.mcp_resp != FW_MSG_CODE_OK) {
1782 "Failed to get the mdump retained data [mcp_resp 0x%x]\n",
1783 mdump_cmd_params.mcp_resp);
1784 return ECORE_UNKNOWN_ERROR;
1787 p_mdump_retain->valid = mfw_mdump_retain.valid;
1788 p_mdump_retain->epoch = mfw_mdump_retain.epoch;
1789 p_mdump_retain->pf = mfw_mdump_retain.pf;
1790 p_mdump_retain->status = mfw_mdump_retain.status;
1792 return ECORE_SUCCESS;
1795 enum _ecore_status_t ecore_mcp_mdump_clr_retain(struct ecore_hwfn *p_hwfn,
1796 struct ecore_ptt *p_ptt)
1798 struct ecore_mdump_cmd_params mdump_cmd_params;
1800 OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1801 mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_CLR_RETAIN;
1803 return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1806 static void ecore_mcp_handle_critical_error(struct ecore_hwfn *p_hwfn,
1807 struct ecore_ptt *p_ptt)
1809 struct ecore_mdump_retain_data mdump_retain;
1810 enum _ecore_status_t rc;
1812 /* In CMT mode - no need for more than a single acknowledgement to the
1813 * MFW, and no more than a single notification to the upper driver.
1815 if (p_hwfn != ECORE_LEADING_HWFN(p_hwfn->p_dev))
1818 rc = ecore_mcp_mdump_get_retain(p_hwfn, p_ptt, &mdump_retain);
1819 if (rc == ECORE_SUCCESS && mdump_retain.valid) {
1820 DP_NOTICE(p_hwfn, false,
1821 "The MFW notified that a critical error occurred in the device [epoch 0x%08x, pf 0x%x, status 0x%08x]\n",
1822 mdump_retain.epoch, mdump_retain.pf,
1823 mdump_retain.status);
1825 DP_NOTICE(p_hwfn, false,
1826 "The MFW notified that a critical error occurred in the device\n");
1829 if (p_hwfn->p_dev->allow_mdump) {
1830 DP_NOTICE(p_hwfn, false,
1831 "Not acknowledging the notification to allow the MFW crash dump\n");
1835 DP_NOTICE(p_hwfn, false,
1836 "Acknowledging the notification to not allow the MFW crash dump [driver debug data collection is preferable]\n");
1837 ecore_mcp_mdump_ack(p_hwfn, p_ptt);
1838 ecore_hw_err_notify(p_hwfn, ECORE_HW_ERR_HW_ATTN);
1841 enum _ecore_status_t ecore_mcp_handle_events(struct ecore_hwfn *p_hwfn,
1842 struct ecore_ptt *p_ptt)
1844 struct ecore_mcp_info *info = p_hwfn->mcp_info;
1845 enum _ecore_status_t rc = ECORE_SUCCESS;
1849 DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "Received message from MFW\n");
1851 /* Read Messages from MFW */
1852 ecore_mcp_read_mb(p_hwfn, p_ptt);
1854 /* Compare current messages to old ones */
1855 for (i = 0; i < info->mfw_mb_length; i++) {
1856 if (info->mfw_mb_cur[i] == info->mfw_mb_shadow[i])
1861 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK,
1862 "Msg [%d] - old CMD 0x%02x, new CMD 0x%02x\n",
1863 i, info->mfw_mb_shadow[i], info->mfw_mb_cur[i]);
1866 case MFW_DRV_MSG_LINK_CHANGE:
1867 ecore_mcp_handle_link_change(p_hwfn, p_ptt, false);
1869 case MFW_DRV_MSG_VF_DISABLED:
1870 ecore_mcp_handle_vf_flr(p_hwfn, p_ptt);
1872 case MFW_DRV_MSG_LLDP_DATA_UPDATED:
1873 ecore_dcbx_mib_update_event(p_hwfn, p_ptt,
1874 ECORE_DCBX_REMOTE_LLDP_MIB);
1876 case MFW_DRV_MSG_DCBX_REMOTE_MIB_UPDATED:
1877 ecore_dcbx_mib_update_event(p_hwfn, p_ptt,
1878 ECORE_DCBX_REMOTE_MIB);
1880 case MFW_DRV_MSG_DCBX_OPERATIONAL_MIB_UPDATED:
1881 ecore_dcbx_mib_update_event(p_hwfn, p_ptt,
1882 ECORE_DCBX_OPERATIONAL_MIB);
1884 case MFW_DRV_MSG_TRANSCEIVER_STATE_CHANGE:
1885 ecore_mcp_handle_transceiver_change(p_hwfn, p_ptt);
1887 case MFW_DRV_MSG_ERROR_RECOVERY:
1888 ecore_mcp_handle_process_kill(p_hwfn, p_ptt);
1890 case MFW_DRV_MSG_GET_LAN_STATS:
1891 case MFW_DRV_MSG_GET_FCOE_STATS:
1892 case MFW_DRV_MSG_GET_ISCSI_STATS:
1893 case MFW_DRV_MSG_GET_RDMA_STATS:
1894 ecore_mcp_send_protocol_stats(p_hwfn, p_ptt, i);
1896 case MFW_DRV_MSG_BW_UPDATE:
1897 ecore_mcp_update_bw(p_hwfn, p_ptt);
1899 case MFW_DRV_MSG_S_TAG_UPDATE:
1900 ecore_mcp_update_stag(p_hwfn, p_ptt);
1902 case MFW_DRV_MSG_FAILURE_DETECTED:
1903 ecore_mcp_handle_fan_failure(p_hwfn, p_ptt);
1905 case MFW_DRV_MSG_CRITICAL_ERROR_OCCURRED:
1906 ecore_mcp_handle_critical_error(p_hwfn, p_ptt);
1908 case MFW_DRV_MSG_GET_TLV_REQ:
1909 OSAL_MFW_TLV_REQ(p_hwfn);
1912 DP_INFO(p_hwfn, "Unimplemented MFW message %d\n", i);
1917 /* ACK everything */
1918 for (i = 0; i < MFW_DRV_MSG_MAX_DWORDS(info->mfw_mb_length); i++) {
1919 OSAL_BE32 val = OSAL_CPU_TO_BE32(((u32 *)info->mfw_mb_cur)[i]);
1921 /* MFW expect answer in BE, so we force write in that format */
1922 ecore_wr(p_hwfn, p_ptt,
1923 info->mfw_mb_addr + sizeof(u32) +
1924 MFW_DRV_MSG_MAX_DWORDS(info->mfw_mb_length) *
1925 sizeof(u32) + i * sizeof(u32), val);
1929 DP_NOTICE(p_hwfn, false,
1930 "Received an MFW message indication but no new message!\n");
1934 /* Copy the new mfw messages into the shadow */
1935 OSAL_MEMCPY(info->mfw_mb_shadow, info->mfw_mb_cur, info->mfw_mb_length);
1940 enum _ecore_status_t ecore_mcp_get_mfw_ver(struct ecore_hwfn *p_hwfn,
1941 struct ecore_ptt *p_ptt,
1943 u32 *p_running_bundle_id)
1948 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
1949 DP_NOTICE(p_hwfn, false, "Emulation - can't get MFW version\n");
1950 return ECORE_SUCCESS;
1954 if (IS_VF(p_hwfn->p_dev)) {
1955 if (p_hwfn->vf_iov_info) {
1956 struct pfvf_acquire_resp_tlv *p_resp;
1958 p_resp = &p_hwfn->vf_iov_info->acquire_resp;
1959 *p_mfw_ver = p_resp->pfdev_info.mfw_ver;
1960 return ECORE_SUCCESS;
1962 DP_VERBOSE(p_hwfn, ECORE_MSG_IOV,
1963 "VF requested MFW version prior to ACQUIRE\n");
1968 global_offsize = ecore_rd(p_hwfn, p_ptt,
1969 SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1971 *p_mfw_ver = ecore_rd(p_hwfn, p_ptt,
1972 SECTION_ADDR(global_offsize, 0) +
1973 OFFSETOF(struct public_global, mfw_ver));
1975 if (p_running_bundle_id != OSAL_NULL) {
1976 *p_running_bundle_id = ecore_rd(p_hwfn, p_ptt,
1977 SECTION_ADDR(global_offsize, 0) +
1978 OFFSETOF(struct public_global,
1979 running_bundle_id));
1982 return ECORE_SUCCESS;
1985 enum _ecore_status_t ecore_mcp_get_mbi_ver(struct ecore_hwfn *p_hwfn,
1986 struct ecore_ptt *p_ptt,
1989 u32 nvm_cfg_addr, nvm_cfg1_offset, mbi_ver_addr;
1992 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
1993 DP_NOTICE(p_hwfn, false, "Emulation - can't get MBI version\n");
1994 return ECORE_SUCCESS;
1998 if (IS_VF(p_hwfn->p_dev))
2001 /* Read the address of the nvm_cfg */
2002 nvm_cfg_addr = ecore_rd(p_hwfn, p_ptt, MISC_REG_GEN_PURP_CR0);
2003 if (!nvm_cfg_addr) {
2004 DP_NOTICE(p_hwfn, false, "Shared memory not initialized\n");
2008 /* Read the offset of nvm_cfg1 */
2009 nvm_cfg1_offset = ecore_rd(p_hwfn, p_ptt, nvm_cfg_addr + 4);
2011 mbi_ver_addr = MCP_REG_SCRATCH + nvm_cfg1_offset +
2012 OFFSETOF(struct nvm_cfg1, glob) +
2013 OFFSETOF(struct nvm_cfg1_glob, mbi_version);
2014 *p_mbi_ver = ecore_rd(p_hwfn, p_ptt, mbi_ver_addr) &
2015 (NVM_CFG1_GLOB_MBI_VERSION_0_MASK |
2016 NVM_CFG1_GLOB_MBI_VERSION_1_MASK |
2017 NVM_CFG1_GLOB_MBI_VERSION_2_MASK);
2019 return ECORE_SUCCESS;
2022 enum _ecore_status_t ecore_mcp_get_media_type(struct ecore_dev *p_dev,
2025 struct ecore_hwfn *p_hwfn = &p_dev->hwfns[0];
2026 struct ecore_ptt *p_ptt;
2028 /* TODO - Add support for VFs */
2032 if (!ecore_mcp_is_init(p_hwfn)) {
2033 DP_NOTICE(p_hwfn, true, "MFW is not initialized!\n");
2037 *p_media_type = MEDIA_UNSPECIFIED;
2039 p_ptt = ecore_ptt_acquire(p_hwfn);
2043 *p_media_type = ecore_rd(p_hwfn, p_ptt, p_hwfn->mcp_info->port_addr +
2044 OFFSETOF(struct public_port, media_type));
2046 ecore_ptt_release(p_hwfn, p_ptt);
2048 return ECORE_SUCCESS;
2051 /* Old MFW has a global configuration for all PFs regarding RDMA support */
2053 ecore_mcp_get_shmem_proto_legacy(struct ecore_hwfn *p_hwfn,
2054 enum ecore_pci_personality *p_proto)
2056 /* There wasn't ever a legacy MFW that published iwarp.
2057 * So at this point, this is either plain l2 or RoCE.
2059 if (OSAL_TEST_BIT(ECORE_DEV_CAP_ROCE,
2060 &p_hwfn->hw_info.device_capabilities))
2061 *p_proto = ECORE_PCI_ETH_ROCE;
2063 *p_proto = ECORE_PCI_ETH;
2065 DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
2066 "According to Legacy capabilities, L2 personality is %08x\n",
2070 static enum _ecore_status_t
2071 ecore_mcp_get_shmem_proto_mfw(struct ecore_hwfn *p_hwfn,
2072 struct ecore_ptt *p_ptt,
2073 enum ecore_pci_personality *p_proto)
2075 u32 resp = 0, param = 0;
2076 enum _ecore_status_t rc;
2078 rc = ecore_mcp_cmd(p_hwfn, p_ptt,
2079 DRV_MSG_CODE_GET_PF_RDMA_PROTOCOL, 0, &resp, ¶m);
2080 if (rc != ECORE_SUCCESS)
2082 if (resp != FW_MSG_CODE_OK) {
2083 DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
2084 "MFW lacks support for command; Returns %08x\n",
2090 case FW_MB_PARAM_GET_PF_RDMA_NONE:
2091 *p_proto = ECORE_PCI_ETH;
2093 case FW_MB_PARAM_GET_PF_RDMA_ROCE:
2094 *p_proto = ECORE_PCI_ETH_ROCE;
2096 case FW_MB_PARAM_GET_PF_RDMA_IWARP:
2097 *p_proto = ECORE_PCI_ETH_IWARP;
2099 case FW_MB_PARAM_GET_PF_RDMA_BOTH:
2100 *p_proto = ECORE_PCI_ETH_RDMA;
2103 DP_NOTICE(p_hwfn, true,
2104 "MFW answers GET_PF_RDMA_PROTOCOL but param is %08x\n",
2109 DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
2110 "According to capabilities, L2 personality is %08x [resp %08x param %08x]\n",
2111 (u32) *p_proto, resp, param);
2112 return ECORE_SUCCESS;
2115 static enum _ecore_status_t
2116 ecore_mcp_get_shmem_proto(struct ecore_hwfn *p_hwfn,
2117 struct public_func *p_info,
2118 struct ecore_ptt *p_ptt,
2119 enum ecore_pci_personality *p_proto)
2121 enum _ecore_status_t rc = ECORE_SUCCESS;
2123 switch (p_info->config & FUNC_MF_CFG_PROTOCOL_MASK) {
2124 case FUNC_MF_CFG_PROTOCOL_ETHERNET:
2125 if (ecore_mcp_get_shmem_proto_mfw(p_hwfn, p_ptt, p_proto) !=
2127 ecore_mcp_get_shmem_proto_legacy(p_hwfn, p_proto);
2129 case FUNC_MF_CFG_PROTOCOL_ISCSI:
2130 *p_proto = ECORE_PCI_ISCSI;
2132 case FUNC_MF_CFG_PROTOCOL_FCOE:
2133 *p_proto = ECORE_PCI_FCOE;
2135 case FUNC_MF_CFG_PROTOCOL_ROCE:
2136 DP_NOTICE(p_hwfn, true, "RoCE personality is not a valid value!\n");
2146 enum _ecore_status_t ecore_mcp_fill_shmem_func_info(struct ecore_hwfn *p_hwfn,
2147 struct ecore_ptt *p_ptt)
2149 struct ecore_mcp_function_info *info;
2150 struct public_func shmem_info;
2152 ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info,
2154 info = &p_hwfn->mcp_info->func_info;
2156 info->pause_on_host = (shmem_info.config &
2157 FUNC_MF_CFG_PAUSE_ON_HOST_RING) ? 1 : 0;
2159 if (ecore_mcp_get_shmem_proto(p_hwfn, &shmem_info, p_ptt,
2161 DP_ERR(p_hwfn, "Unknown personality %08x\n",
2162 (u32)(shmem_info.config & FUNC_MF_CFG_PROTOCOL_MASK));
2166 ecore_read_pf_bandwidth(p_hwfn, &shmem_info);
2168 if (shmem_info.mac_upper || shmem_info.mac_lower) {
2169 info->mac[0] = (u8)(shmem_info.mac_upper >> 8);
2170 info->mac[1] = (u8)(shmem_info.mac_upper);
2171 info->mac[2] = (u8)(shmem_info.mac_lower >> 24);
2172 info->mac[3] = (u8)(shmem_info.mac_lower >> 16);
2173 info->mac[4] = (u8)(shmem_info.mac_lower >> 8);
2174 info->mac[5] = (u8)(shmem_info.mac_lower);
2176 /* Store primary MAC for later possible WoL */
2177 OSAL_MEMCPY(&p_hwfn->p_dev->wol_mac, info->mac, ETH_ALEN);
2180 /* TODO - are there protocols for which there's no MAC? */
2181 DP_NOTICE(p_hwfn, false, "MAC is 0 in shmem\n");
2184 /* TODO - are these calculations true for BE machine? */
2185 info->wwn_port = (u64)shmem_info.fcoe_wwn_port_name_upper |
2186 (((u64)shmem_info.fcoe_wwn_port_name_lower) << 32);
2187 info->wwn_node = (u64)shmem_info.fcoe_wwn_node_name_upper |
2188 (((u64)shmem_info.fcoe_wwn_node_name_lower) << 32);
2190 info->ovlan = (u16)(shmem_info.ovlan_stag & FUNC_MF_CFG_OV_STAG_MASK);
2192 info->mtu = (u16)shmem_info.mtu_size;
2194 p_hwfn->hw_info.b_wol_support = ECORE_WOL_SUPPORT_NONE;
2195 if (ecore_mcp_is_init(p_hwfn)) {
2196 u32 resp = 0, param = 0;
2197 enum _ecore_status_t rc;
2199 rc = ecore_mcp_cmd(p_hwfn, p_ptt,
2200 DRV_MSG_CODE_OS_WOL, 0, &resp, ¶m);
2201 if (rc != ECORE_SUCCESS)
2203 if (resp == FW_MSG_CODE_OS_WOL_SUPPORTED)
2204 p_hwfn->hw_info.b_wol_support = ECORE_WOL_SUPPORT_PME;
2206 p_hwfn->p_dev->wol_config = (u8)ECORE_OV_WOL_DEFAULT;
2208 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_IFUP),
2209 "Read configuration from shmem: pause_on_host %02x protocol %02x BW [%02x - %02x] MAC %02x:%02x:%02x:%02x:%02x:%02x wwn port %llx node %llx ovlan %04x wol %02x\n",
2210 info->pause_on_host, info->protocol,
2211 info->bandwidth_min, info->bandwidth_max,
2212 info->mac[0], info->mac[1], info->mac[2],
2213 info->mac[3], info->mac[4], info->mac[5],
2214 (unsigned long long)info->wwn_port, (unsigned long long)info->wwn_node, info->ovlan,
2215 (u8)p_hwfn->hw_info.b_wol_support);
2217 return ECORE_SUCCESS;
2220 struct ecore_mcp_link_params
2221 *ecore_mcp_get_link_params(struct ecore_hwfn *p_hwfn)
2223 if (!p_hwfn || !p_hwfn->mcp_info)
2225 return &p_hwfn->mcp_info->link_input;
2228 struct ecore_mcp_link_state
2229 *ecore_mcp_get_link_state(struct ecore_hwfn *p_hwfn)
2231 if (!p_hwfn || !p_hwfn->mcp_info)
2235 if (CHIP_REV_IS_SLOW(p_hwfn->p_dev)) {
2236 DP_INFO(p_hwfn, "Non-ASIC - always notify that link is up\n");
2237 p_hwfn->mcp_info->link_output.link_up = true;
2241 return &p_hwfn->mcp_info->link_output;
2244 struct ecore_mcp_link_capabilities
2245 *ecore_mcp_get_link_capabilities(struct ecore_hwfn *p_hwfn)
2247 if (!p_hwfn || !p_hwfn->mcp_info)
2249 return &p_hwfn->mcp_info->link_capabilities;
2252 enum _ecore_status_t ecore_mcp_drain(struct ecore_hwfn *p_hwfn,
2253 struct ecore_ptt *p_ptt)
2255 u32 resp = 0, param = 0;
2256 enum _ecore_status_t rc;
2258 rc = ecore_mcp_cmd(p_hwfn, p_ptt,
2259 DRV_MSG_CODE_NIG_DRAIN, 1000,
2262 /* Wait for the drain to complete before returning */
2268 #ifndef LINUX_REMOVE
2269 const struct ecore_mcp_function_info
2270 *ecore_mcp_get_function_info(struct ecore_hwfn *p_hwfn)
2272 if (!p_hwfn || !p_hwfn->mcp_info)
2274 return &p_hwfn->mcp_info->func_info;
2278 enum _ecore_status_t ecore_mcp_nvm_command(struct ecore_hwfn *p_hwfn,
2279 struct ecore_ptt *p_ptt,
2280 struct ecore_mcp_nvm_params *params)
2282 enum _ecore_status_t rc;
2284 switch (params->type) {
2285 case ECORE_MCP_NVM_RD:
2286 rc = ecore_mcp_nvm_rd_cmd(p_hwfn, p_ptt, params->nvm_common.cmd,
2287 params->nvm_common.offset,
2288 ¶ms->nvm_common.resp,
2289 ¶ms->nvm_common.param,
2290 params->nvm_rd.buf_size,
2291 params->nvm_rd.buf);
2294 rc = ecore_mcp_cmd(p_hwfn, p_ptt, params->nvm_common.cmd,
2295 params->nvm_common.offset,
2296 ¶ms->nvm_common.resp,
2297 ¶ms->nvm_common.param);
2299 case ECORE_MCP_NVM_WR:
2300 rc = ecore_mcp_nvm_wr_cmd(p_hwfn, p_ptt, params->nvm_common.cmd,
2301 params->nvm_common.offset,
2302 ¶ms->nvm_common.resp,
2303 ¶ms->nvm_common.param,
2304 params->nvm_wr.buf_size,
2305 params->nvm_wr.buf);
2314 #ifndef LINUX_REMOVE
2315 int ecore_mcp_get_personality_cnt(struct ecore_hwfn *p_hwfn,
2316 struct ecore_ptt *p_ptt,
2319 enum ecore_pci_personality protocol = ECORE_PCI_DEFAULT;
2320 struct public_func shmem_info;
2321 int i, count = 0, num_pfs;
2323 num_pfs = NUM_OF_ENG_PFS(p_hwfn->p_dev);
2325 for (i = 0; i < num_pfs; i++) {
2326 ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info,
2327 MCP_PF_ID_BY_REL(p_hwfn, i));
2328 if (shmem_info.config & FUNC_MF_CFG_FUNC_HIDE)
2331 if (ecore_mcp_get_shmem_proto(p_hwfn, &shmem_info, p_ptt,
2336 if ((1 << ((u32)protocol)) & personalities)
2344 enum _ecore_status_t ecore_mcp_get_flash_size(struct ecore_hwfn *p_hwfn,
2345 struct ecore_ptt *p_ptt,
2351 if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
2352 DP_NOTICE(p_hwfn, false, "Emulation - can't get flash size\n");
2357 if (IS_VF(p_hwfn->p_dev))
2360 flash_size = ecore_rd(p_hwfn, p_ptt, MCP_REG_NVM_CFG4);
2361 flash_size = (flash_size & MCP_REG_NVM_CFG4_FLASH_SIZE) >>
2362 MCP_REG_NVM_CFG4_FLASH_SIZE_SHIFT;
2363 flash_size = (1 << (flash_size + MCP_BYTES_PER_MBIT_SHIFT));
2365 *p_flash_size = flash_size;
2367 return ECORE_SUCCESS;
2370 enum _ecore_status_t ecore_start_recovery_process(struct ecore_hwfn *p_hwfn,
2371 struct ecore_ptt *p_ptt)
2373 struct ecore_dev *p_dev = p_hwfn->p_dev;
2375 if (p_dev->recov_in_prog) {
2376 DP_NOTICE(p_hwfn, false,
2377 "Avoid triggering a recovery since such a process is already in progress\n");
2381 DP_NOTICE(p_hwfn, false, "Triggering a recovery process\n");
2382 ecore_wr(p_hwfn, p_ptt, MISC_REG_AEU_GENERAL_ATTN_35, 0x1);
2384 return ECORE_SUCCESS;
2387 enum _ecore_status_t ecore_mcp_config_vf_msix(struct ecore_hwfn *p_hwfn,
2388 struct ecore_ptt *p_ptt,
2391 u32 resp = 0, param = 0, rc_param = 0;
2392 enum _ecore_status_t rc;
2394 /* Only Leader can configure MSIX, and need to take CMT into account */
2395 if (!IS_LEAD_HWFN(p_hwfn))
2396 return ECORE_SUCCESS;
2397 num *= p_hwfn->p_dev->num_hwfns;
2399 param |= (vf_id << DRV_MB_PARAM_CFG_VF_MSIX_VF_ID_SHIFT) &
2400 DRV_MB_PARAM_CFG_VF_MSIX_VF_ID_MASK;
2401 param |= (num << DRV_MB_PARAM_CFG_VF_MSIX_SB_NUM_SHIFT) &
2402 DRV_MB_PARAM_CFG_VF_MSIX_SB_NUM_MASK;
2404 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_CFG_VF_MSIX, param,
2407 if (resp != FW_MSG_CODE_DRV_CFG_VF_MSIX_DONE) {
2408 DP_NOTICE(p_hwfn, true, "VF[%d]: MFW failed to set MSI-X\n",
2412 DP_VERBOSE(p_hwfn, ECORE_MSG_IOV,
2413 "Requested 0x%02x MSI-x interrupts from VF 0x%02x\n",
2420 enum _ecore_status_t
2421 ecore_mcp_send_drv_version(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2422 struct ecore_mcp_drv_version *p_ver)
2424 struct ecore_mcp_mb_params mb_params;
2425 struct drv_version_stc drv_version;
2429 enum _ecore_status_t rc;
2432 if (CHIP_REV_IS_SLOW(p_hwfn->p_dev))
2433 return ECORE_SUCCESS;
2436 OSAL_MEM_ZERO(&drv_version, sizeof(drv_version));
2437 drv_version.version = p_ver->version;
2438 num_words = (MCP_DRV_VER_STR_SIZE - 4) / 4;
2439 for (i = 0; i < num_words; i++) {
2440 /* The driver name is expected to be in a big-endian format */
2441 p_name = &p_ver->name[i * sizeof(u32)];
2442 val = OSAL_CPU_TO_BE32(*(u32 *)p_name);
2443 *(u32 *)&drv_version.name[i * sizeof(u32)] = val;
2446 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
2447 mb_params.cmd = DRV_MSG_CODE_SET_VERSION;
2448 mb_params.p_data_src = &drv_version;
2449 mb_params.data_src_size = sizeof(drv_version);
2450 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
2451 if (rc != ECORE_SUCCESS)
2452 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2457 enum _ecore_status_t ecore_mcp_halt(struct ecore_hwfn *p_hwfn,
2458 struct ecore_ptt *p_ptt)
2460 enum _ecore_status_t rc;
2461 u32 resp = 0, param = 0;
2463 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MCP_HALT, 0, &resp,
2465 if (rc != ECORE_SUCCESS)
2466 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2471 enum _ecore_status_t ecore_mcp_resume(struct ecore_hwfn *p_hwfn,
2472 struct ecore_ptt *p_ptt)
2474 u32 value, cpu_mode;
2476 ecore_wr(p_hwfn, p_ptt, MCP_REG_CPU_STATE, 0xffffffff);
2478 value = ecore_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);
2479 value &= ~MCP_REG_CPU_MODE_SOFT_HALT;
2480 ecore_wr(p_hwfn, p_ptt, MCP_REG_CPU_MODE, value);
2481 cpu_mode = ecore_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);
2483 return (cpu_mode & MCP_REG_CPU_MODE_SOFT_HALT) ? -1 : 0;
2486 enum _ecore_status_t
2487 ecore_mcp_ov_update_current_config(struct ecore_hwfn *p_hwfn,
2488 struct ecore_ptt *p_ptt,
2489 enum ecore_ov_client client)
2491 enum _ecore_status_t rc;
2492 u32 resp = 0, param = 0;
2496 case ECORE_OV_CLIENT_DRV:
2497 drv_mb_param = DRV_MB_PARAM_OV_CURR_CFG_OS;
2499 case ECORE_OV_CLIENT_USER:
2500 drv_mb_param = DRV_MB_PARAM_OV_CURR_CFG_OTHER;
2502 case ECORE_OV_CLIENT_VENDOR_SPEC:
2503 drv_mb_param = DRV_MB_PARAM_OV_CURR_CFG_VENDOR_SPEC;
2506 DP_NOTICE(p_hwfn, true,
2507 "Invalid client type %d\n", client);
2511 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OV_UPDATE_CURR_CFG,
2512 drv_mb_param, &resp, ¶m);
2513 if (rc != ECORE_SUCCESS)
2514 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2519 enum _ecore_status_t
2520 ecore_mcp_ov_update_driver_state(struct ecore_hwfn *p_hwfn,
2521 struct ecore_ptt *p_ptt,
2522 enum ecore_ov_driver_state drv_state)
2524 enum _ecore_status_t rc;
2525 u32 resp = 0, param = 0;
2528 switch (drv_state) {
2529 case ECORE_OV_DRIVER_STATE_NOT_LOADED:
2530 drv_mb_param = DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE_NOT_LOADED;
2532 case ECORE_OV_DRIVER_STATE_DISABLED:
2533 drv_mb_param = DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE_DISABLED;
2535 case ECORE_OV_DRIVER_STATE_ACTIVE:
2536 drv_mb_param = DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE_ACTIVE;
2539 DP_NOTICE(p_hwfn, true,
2540 "Invalid driver state %d\n", drv_state);
2544 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE,
2545 drv_mb_param, &resp, ¶m);
2546 if (rc != ECORE_SUCCESS)
2547 DP_ERR(p_hwfn, "Failed to send driver state\n");
2552 enum _ecore_status_t
2553 ecore_mcp_ov_get_fc_npiv(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2554 struct ecore_fc_npiv_tbl *p_table)
2556 enum _ecore_status_t rc = ECORE_SUCCESS;
2557 struct dci_fc_npiv_tbl *p_npiv_table;
2558 u8 *p_buf = OSAL_NULL;
2561 p_table->num_wwpn = 0;
2562 p_table->num_wwnn = 0;
2563 addr = ecore_rd(p_hwfn, p_ptt, p_hwfn->mcp_info->port_addr +
2564 OFFSETOF(struct public_port, fc_npiv_nvram_tbl_addr));
2565 if (addr == NPIV_TBL_INVALID_ADDR) {
2566 DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "NPIV table doesn't exist\n");
2570 size = ecore_rd(p_hwfn, p_ptt, p_hwfn->mcp_info->port_addr +
2571 OFFSETOF(struct public_port, fc_npiv_nvram_tbl_size));
2573 DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "NPIV table is empty\n");
2577 p_buf = OSAL_VZALLOC(p_hwfn->p_dev, size);
2579 DP_ERR(p_hwfn, "Buffer allocation failed\n");
2583 rc = ecore_mcp_nvm_read(p_hwfn->p_dev, addr, p_buf, size);
2584 if (rc != ECORE_SUCCESS) {
2585 OSAL_VFREE(p_hwfn->p_dev, p_buf);
2589 p_npiv_table = (struct dci_fc_npiv_tbl *)p_buf;
2590 p_table->num_wwpn = (u16)p_npiv_table->fc_npiv_cfg.num_of_npiv;
2591 p_table->num_wwnn = (u16)p_npiv_table->fc_npiv_cfg.num_of_npiv;
2592 for (i = 0; i < p_table->num_wwpn; i++) {
2593 OSAL_MEMCPY(p_table->wwpn, p_npiv_table->settings[i].npiv_wwpn,
2595 OSAL_MEMCPY(p_table->wwnn, p_npiv_table->settings[i].npiv_wwnn,
2599 OSAL_VFREE(p_hwfn->p_dev, p_buf);
2601 return ECORE_SUCCESS;
2604 enum _ecore_status_t
2605 ecore_mcp_ov_update_mtu(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2608 enum _ecore_status_t rc;
2609 u32 resp = 0, param = 0;
2612 drv_mb_param = (u32)mtu << DRV_MB_PARAM_OV_MTU_SIZE_SHIFT;
2613 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OV_UPDATE_MTU,
2614 drv_mb_param, &resp, ¶m);
2615 if (rc != ECORE_SUCCESS)
2616 DP_ERR(p_hwfn, "Failed to send mtu value, rc = %d\n", rc);
2621 enum _ecore_status_t
2622 ecore_mcp_ov_update_mac(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2625 struct ecore_mcp_mb_params mb_params;
2626 enum _ecore_status_t rc;
2629 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
2630 mb_params.cmd = DRV_MSG_CODE_SET_VMAC;
2631 mb_params.param = DRV_MSG_CODE_VMAC_TYPE_MAC <<
2632 DRV_MSG_CODE_VMAC_TYPE_SHIFT;
2633 mb_params.param |= MCP_PF_ID(p_hwfn);
2635 /* MCP is BE, and on LE platforms PCI would swap access to SHMEM
2636 * in 32-bit granularity.
2637 * So the MAC has to be set in native order [and not byte order],
2638 * otherwise it would be read incorrectly by MFW after swap.
2640 mfw_mac[0] = mac[0] << 24 | mac[1] << 16 | mac[2] << 8 | mac[3];
2641 mfw_mac[1] = mac[4] << 24 | mac[5] << 16;
2643 mb_params.p_data_src = (u8 *)mfw_mac;
2644 mb_params.data_src_size = 8;
2645 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
2646 if (rc != ECORE_SUCCESS)
2647 DP_ERR(p_hwfn, "Failed to send mac address, rc = %d\n", rc);
2649 /* Store primary MAC for later possible WoL */
2650 OSAL_MEMCPY(p_hwfn->p_dev->wol_mac, mac, ETH_ALEN);
2655 enum _ecore_status_t
2656 ecore_mcp_ov_update_wol(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2657 enum ecore_ov_wol wol)
2659 enum _ecore_status_t rc;
2660 u32 resp = 0, param = 0;
2663 if (p_hwfn->hw_info.b_wol_support == ECORE_WOL_SUPPORT_NONE) {
2664 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
2665 "Can't change WoL configuration when WoL isn't supported\n");
2670 case ECORE_OV_WOL_DEFAULT:
2671 drv_mb_param = DRV_MB_PARAM_WOL_DEFAULT;
2673 case ECORE_OV_WOL_DISABLED:
2674 drv_mb_param = DRV_MB_PARAM_WOL_DISABLED;
2676 case ECORE_OV_WOL_ENABLED:
2677 drv_mb_param = DRV_MB_PARAM_WOL_ENABLED;
2680 DP_ERR(p_hwfn, "Invalid wol state %d\n", wol);
2684 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OV_UPDATE_WOL,
2685 drv_mb_param, &resp, ¶m);
2686 if (rc != ECORE_SUCCESS)
2687 DP_ERR(p_hwfn, "Failed to send wol mode, rc = %d\n", rc);
2689 /* Store the WoL update for a future unload */
2690 p_hwfn->p_dev->wol_config = (u8)wol;
2695 enum _ecore_status_t
2696 ecore_mcp_ov_update_eswitch(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2697 enum ecore_ov_eswitch eswitch)
2699 enum _ecore_status_t rc;
2700 u32 resp = 0, param = 0;
2704 case ECORE_OV_ESWITCH_NONE:
2705 drv_mb_param = DRV_MB_PARAM_ESWITCH_MODE_NONE;
2707 case ECORE_OV_ESWITCH_VEB:
2708 drv_mb_param = DRV_MB_PARAM_ESWITCH_MODE_VEB;
2710 case ECORE_OV_ESWITCH_VEPA:
2711 drv_mb_param = DRV_MB_PARAM_ESWITCH_MODE_VEPA;
2714 DP_ERR(p_hwfn, "Invalid eswitch mode %d\n", eswitch);
2718 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OV_UPDATE_ESWITCH_MODE,
2719 drv_mb_param, &resp, ¶m);
2720 if (rc != ECORE_SUCCESS)
2721 DP_ERR(p_hwfn, "Failed to send eswitch mode, rc = %d\n", rc);
2726 enum _ecore_status_t ecore_mcp_set_led(struct ecore_hwfn *p_hwfn,
2727 struct ecore_ptt *p_ptt,
2728 enum ecore_led_mode mode)
2730 u32 resp = 0, param = 0, drv_mb_param;
2731 enum _ecore_status_t rc;
2734 case ECORE_LED_MODE_ON:
2735 drv_mb_param = DRV_MB_PARAM_SET_LED_MODE_ON;
2737 case ECORE_LED_MODE_OFF:
2738 drv_mb_param = DRV_MB_PARAM_SET_LED_MODE_OFF;
2740 case ECORE_LED_MODE_RESTORE:
2741 drv_mb_param = DRV_MB_PARAM_SET_LED_MODE_OPER;
2744 DP_NOTICE(p_hwfn, true, "Invalid LED mode %d\n", mode);
2748 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_SET_LED_MODE,
2749 drv_mb_param, &resp, ¶m);
2750 if (rc != ECORE_SUCCESS)
2751 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2756 enum _ecore_status_t ecore_mcp_mask_parities(struct ecore_hwfn *p_hwfn,
2757 struct ecore_ptt *p_ptt,
2760 enum _ecore_status_t rc;
2761 u32 resp = 0, param = 0;
2763 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MASK_PARITIES,
2764 mask_parities, &resp, ¶m);
2766 if (rc != ECORE_SUCCESS) {
2767 DP_ERR(p_hwfn, "MCP response failure for mask parities, aborting\n");
2768 } else if (resp != FW_MSG_CODE_OK) {
2769 DP_ERR(p_hwfn, "MCP did not acknowledge mask parity request. Old MFW?\n");
2776 enum _ecore_status_t ecore_mcp_nvm_read(struct ecore_dev *p_dev, u32 addr,
2779 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2780 u32 bytes_left, offset, bytes_to_copy, buf_size;
2781 struct ecore_mcp_nvm_params params;
2782 struct ecore_ptt *p_ptt;
2783 enum _ecore_status_t rc = ECORE_SUCCESS;
2785 p_ptt = ecore_ptt_acquire(p_hwfn);
2789 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
2792 params.type = ECORE_MCP_NVM_RD;
2793 params.nvm_rd.buf_size = &buf_size;
2794 params.nvm_common.cmd = DRV_MSG_CODE_NVM_READ_NVRAM;
2795 while (bytes_left > 0) {
2796 bytes_to_copy = OSAL_MIN_T(u32, bytes_left,
2797 MCP_DRV_NVM_BUF_LEN);
2798 params.nvm_common.offset = (addr + offset) |
2800 DRV_MB_PARAM_NVM_LEN_SHIFT);
2801 params.nvm_rd.buf = (u32 *)(p_buf + offset);
2802 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
2803 if (rc != ECORE_SUCCESS || (params.nvm_common.resp !=
2804 FW_MSG_CODE_NVM_OK)) {
2805 DP_NOTICE(p_dev, false, "MCP command rc = %d\n",
2810 /* This can be a lengthy process, and it's possible scheduler
2811 * isn't preemptable. Sleep a bit to prevent CPU hogging.
2813 if (bytes_left % 0x1000 <
2814 (bytes_left - *params.nvm_rd.buf_size) % 0x1000)
2817 offset += *params.nvm_rd.buf_size;
2818 bytes_left -= *params.nvm_rd.buf_size;
2821 p_dev->mcp_nvm_resp = params.nvm_common.resp;
2822 ecore_ptt_release(p_hwfn, p_ptt);
2827 enum _ecore_status_t ecore_mcp_phy_read(struct ecore_dev *p_dev, u32 cmd,
2828 u32 addr, u8 *p_buf, u32 len)
2830 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2831 struct ecore_mcp_nvm_params params;
2832 struct ecore_ptt *p_ptt;
2833 enum _ecore_status_t rc;
2835 p_ptt = ecore_ptt_acquire(p_hwfn);
2839 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
2840 params.type = ECORE_MCP_NVM_RD;
2841 params.nvm_rd.buf_size = &len;
2842 params.nvm_common.cmd = (cmd == ECORE_PHY_CORE_READ) ?
2843 DRV_MSG_CODE_PHY_CORE_READ :
2844 DRV_MSG_CODE_PHY_RAW_READ;
2845 params.nvm_common.offset = addr;
2846 params.nvm_rd.buf = (u32 *)p_buf;
2847 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
2848 if (rc != ECORE_SUCCESS)
2849 DP_NOTICE(p_dev, false, "MCP command rc = %d\n", rc);
2851 p_dev->mcp_nvm_resp = params.nvm_common.resp;
2852 ecore_ptt_release(p_hwfn, p_ptt);
2857 enum _ecore_status_t ecore_mcp_nvm_resp(struct ecore_dev *p_dev, u8 *p_buf)
2859 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2860 struct ecore_mcp_nvm_params params;
2861 struct ecore_ptt *p_ptt;
2863 p_ptt = ecore_ptt_acquire(p_hwfn);
2867 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
2868 OSAL_MEMCPY(p_buf, &p_dev->mcp_nvm_resp, sizeof(p_dev->mcp_nvm_resp));
2869 ecore_ptt_release(p_hwfn, p_ptt);
2871 return ECORE_SUCCESS;
2874 enum _ecore_status_t ecore_mcp_nvm_del_file(struct ecore_dev *p_dev,
2877 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2878 struct ecore_mcp_nvm_params params;
2879 struct ecore_ptt *p_ptt;
2880 enum _ecore_status_t rc;
2882 p_ptt = ecore_ptt_acquire(p_hwfn);
2885 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
2886 params.type = ECORE_MCP_CMD;
2887 params.nvm_common.cmd = DRV_MSG_CODE_NVM_DEL_FILE;
2888 params.nvm_common.offset = addr;
2889 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
2890 p_dev->mcp_nvm_resp = params.nvm_common.resp;
2891 ecore_ptt_release(p_hwfn, p_ptt);
2896 enum _ecore_status_t ecore_mcp_nvm_put_file_begin(struct ecore_dev *p_dev,
2899 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2900 struct ecore_mcp_nvm_params params;
2901 struct ecore_ptt *p_ptt;
2902 enum _ecore_status_t rc;
2904 p_ptt = ecore_ptt_acquire(p_hwfn);
2907 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
2908 params.type = ECORE_MCP_CMD;
2909 params.nvm_common.cmd = DRV_MSG_CODE_NVM_PUT_FILE_BEGIN;
2910 params.nvm_common.offset = addr;
2911 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
2912 p_dev->mcp_nvm_resp = params.nvm_common.resp;
2913 ecore_ptt_release(p_hwfn, p_ptt);
2918 /* rc receives ECORE_INVAL as default parameter because
2919 * it might not enter the while loop if the len is 0
2921 enum _ecore_status_t ecore_mcp_nvm_write(struct ecore_dev *p_dev, u32 cmd,
2922 u32 addr, u8 *p_buf, u32 len)
2924 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2925 enum _ecore_status_t rc = ECORE_INVAL;
2926 struct ecore_mcp_nvm_params params;
2927 struct ecore_ptt *p_ptt;
2928 u32 buf_idx, buf_size;
2930 p_ptt = ecore_ptt_acquire(p_hwfn);
2934 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
2935 params.type = ECORE_MCP_NVM_WR;
2937 case ECORE_PUT_FILE_DATA:
2938 params.nvm_common.cmd = DRV_MSG_CODE_NVM_PUT_FILE_DATA;
2940 case ECORE_NVM_WRITE_NVRAM:
2941 params.nvm_common.cmd = DRV_MSG_CODE_NVM_WRITE_NVRAM;
2943 case ECORE_EXT_PHY_FW_UPGRADE:
2944 params.nvm_common.cmd = DRV_MSG_CODE_EXT_PHY_FW_UPGRADE;
2947 DP_NOTICE(p_hwfn, true, "Invalid nvm write command 0x%x\n",
2953 while (buf_idx < len) {
2954 buf_size = OSAL_MIN_T(u32, (len - buf_idx),
2955 MCP_DRV_NVM_BUF_LEN);
2956 params.nvm_common.offset = ((buf_size <<
2957 DRV_MB_PARAM_NVM_LEN_SHIFT)
2959 params.nvm_wr.buf_size = buf_size;
2960 params.nvm_wr.buf = (u32 *)&p_buf[buf_idx];
2961 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
2962 if (rc != ECORE_SUCCESS ||
2963 ((params.nvm_common.resp != FW_MSG_CODE_NVM_OK) &&
2964 (params.nvm_common.resp !=
2965 FW_MSG_CODE_NVM_PUT_FILE_FINISH_OK)))
2966 DP_NOTICE(p_dev, false, "MCP command rc = %d\n", rc);
2968 /* This can be a lengthy process, and it's possible scheduler
2969 * isn't preemptable. Sleep a bit to prevent CPU hogging.
2971 if (buf_idx % 0x1000 >
2972 (buf_idx + buf_size) % 0x1000)
2975 buf_idx += buf_size;
2978 p_dev->mcp_nvm_resp = params.nvm_common.resp;
2979 ecore_ptt_release(p_hwfn, p_ptt);
2984 enum _ecore_status_t ecore_mcp_phy_write(struct ecore_dev *p_dev, u32 cmd,
2985 u32 addr, u8 *p_buf, u32 len)
2987 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2988 struct ecore_mcp_nvm_params params;
2989 struct ecore_ptt *p_ptt;
2990 enum _ecore_status_t rc;
2992 p_ptt = ecore_ptt_acquire(p_hwfn);
2996 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
2997 params.type = ECORE_MCP_NVM_WR;
2998 params.nvm_wr.buf_size = len;
2999 params.nvm_common.cmd = (cmd == ECORE_PHY_CORE_WRITE) ?
3000 DRV_MSG_CODE_PHY_CORE_WRITE :
3001 DRV_MSG_CODE_PHY_RAW_WRITE;
3002 params.nvm_common.offset = addr;
3003 params.nvm_wr.buf = (u32 *)p_buf;
3004 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
3005 if (rc != ECORE_SUCCESS)
3006 DP_NOTICE(p_dev, false, "MCP command rc = %d\n", rc);
3007 p_dev->mcp_nvm_resp = params.nvm_common.resp;
3008 ecore_ptt_release(p_hwfn, p_ptt);
3013 enum _ecore_status_t ecore_mcp_nvm_set_secure_mode(struct ecore_dev *p_dev,
3016 struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
3017 struct ecore_mcp_nvm_params params;
3018 struct ecore_ptt *p_ptt;
3019 enum _ecore_status_t rc;
3021 p_ptt = ecore_ptt_acquire(p_hwfn);
3025 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
3026 params.type = ECORE_MCP_CMD;
3027 params.nvm_common.cmd = DRV_MSG_CODE_SET_SECURE_MODE;
3028 params.nvm_common.offset = addr;
3029 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
3030 p_dev->mcp_nvm_resp = params.nvm_common.resp;
3031 ecore_ptt_release(p_hwfn, p_ptt);
3036 enum _ecore_status_t ecore_mcp_phy_sfp_read(struct ecore_hwfn *p_hwfn,
3037 struct ecore_ptt *p_ptt,
3038 u32 port, u32 addr, u32 offset,
3041 struct ecore_mcp_nvm_params params;
3042 enum _ecore_status_t rc;
3043 u32 bytes_left, bytes_to_copy, buf_size;
3045 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
3046 params.nvm_common.offset =
3047 (port << DRV_MB_PARAM_TRANSCEIVER_PORT_SHIFT) |
3048 (addr << DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_SHIFT);
3052 params.type = ECORE_MCP_NVM_RD;
3053 params.nvm_rd.buf_size = &buf_size;
3054 params.nvm_common.cmd = DRV_MSG_CODE_TRANSCEIVER_READ;
3055 while (bytes_left > 0) {
3056 bytes_to_copy = OSAL_MIN_T(u32, bytes_left,
3057 MAX_I2C_TRANSACTION_SIZE);
3058 params.nvm_rd.buf = (u32 *)(p_buf + offset);
3059 params.nvm_common.offset &=
3060 (DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_MASK |
3061 DRV_MB_PARAM_TRANSCEIVER_PORT_MASK);
3062 params.nvm_common.offset |=
3064 DRV_MB_PARAM_TRANSCEIVER_OFFSET_SHIFT);
3065 params.nvm_common.offset |=
3066 (bytes_to_copy << DRV_MB_PARAM_TRANSCEIVER_SIZE_SHIFT);
3067 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
3068 if ((params.nvm_common.resp & FW_MSG_CODE_MASK) ==
3069 FW_MSG_CODE_TRANSCEIVER_NOT_PRESENT) {
3071 } else if ((params.nvm_common.resp & FW_MSG_CODE_MASK) !=
3072 FW_MSG_CODE_TRANSCEIVER_DIAG_OK)
3073 return ECORE_UNKNOWN_ERROR;
3075 offset += *params.nvm_rd.buf_size;
3076 bytes_left -= *params.nvm_rd.buf_size;
3079 return ECORE_SUCCESS;
3082 enum _ecore_status_t ecore_mcp_phy_sfp_write(struct ecore_hwfn *p_hwfn,
3083 struct ecore_ptt *p_ptt,
3084 u32 port, u32 addr, u32 offset,
3087 struct ecore_mcp_nvm_params params;
3088 enum _ecore_status_t rc;
3089 u32 buf_idx, buf_size;
3091 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
3092 params.nvm_common.offset =
3093 (port << DRV_MB_PARAM_TRANSCEIVER_PORT_SHIFT) |
3094 (addr << DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_SHIFT);
3095 params.type = ECORE_MCP_NVM_WR;
3096 params.nvm_common.cmd = DRV_MSG_CODE_TRANSCEIVER_WRITE;
3098 while (buf_idx < len) {
3099 buf_size = OSAL_MIN_T(u32, (len - buf_idx),
3100 MAX_I2C_TRANSACTION_SIZE);
3101 params.nvm_common.offset &=
3102 (DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_MASK |
3103 DRV_MB_PARAM_TRANSCEIVER_PORT_MASK);
3104 params.nvm_common.offset |=
3105 ((offset + buf_idx) <<
3106 DRV_MB_PARAM_TRANSCEIVER_OFFSET_SHIFT);
3107 params.nvm_common.offset |=
3108 (buf_size << DRV_MB_PARAM_TRANSCEIVER_SIZE_SHIFT);
3109 params.nvm_wr.buf_size = buf_size;
3110 params.nvm_wr.buf = (u32 *)&p_buf[buf_idx];
3111 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
3112 if ((params.nvm_common.resp & FW_MSG_CODE_MASK) ==
3113 FW_MSG_CODE_TRANSCEIVER_NOT_PRESENT) {
3115 } else if ((params.nvm_common.resp & FW_MSG_CODE_MASK) !=
3116 FW_MSG_CODE_TRANSCEIVER_DIAG_OK)
3117 return ECORE_UNKNOWN_ERROR;
3119 buf_idx += buf_size;
3122 return ECORE_SUCCESS;
3125 enum _ecore_status_t ecore_mcp_gpio_read(struct ecore_hwfn *p_hwfn,
3126 struct ecore_ptt *p_ptt,
3127 u16 gpio, u32 *gpio_val)
3129 enum _ecore_status_t rc = ECORE_SUCCESS;
3130 u32 drv_mb_param = 0, rsp;
3132 drv_mb_param = (gpio << DRV_MB_PARAM_GPIO_NUMBER_SHIFT);
3134 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GPIO_READ,
3135 drv_mb_param, &rsp, gpio_val);
3137 if (rc != ECORE_SUCCESS)
3140 if ((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_GPIO_OK)
3141 return ECORE_UNKNOWN_ERROR;
3143 return ECORE_SUCCESS;
3146 enum _ecore_status_t ecore_mcp_gpio_write(struct ecore_hwfn *p_hwfn,
3147 struct ecore_ptt *p_ptt,
3148 u16 gpio, u16 gpio_val)
3150 enum _ecore_status_t rc = ECORE_SUCCESS;
3151 u32 drv_mb_param = 0, param, rsp;
3153 drv_mb_param = (gpio << DRV_MB_PARAM_GPIO_NUMBER_SHIFT) |
3154 (gpio_val << DRV_MB_PARAM_GPIO_VALUE_SHIFT);
3156 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GPIO_WRITE,
3157 drv_mb_param, &rsp, ¶m);
3159 if (rc != ECORE_SUCCESS)
3162 if ((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_GPIO_OK)
3163 return ECORE_UNKNOWN_ERROR;
3165 return ECORE_SUCCESS;
3168 enum _ecore_status_t ecore_mcp_gpio_info(struct ecore_hwfn *p_hwfn,
3169 struct ecore_ptt *p_ptt,
3170 u16 gpio, u32 *gpio_direction,
3173 u32 drv_mb_param = 0, rsp, val = 0;
3174 enum _ecore_status_t rc = ECORE_SUCCESS;
3176 drv_mb_param = gpio << DRV_MB_PARAM_GPIO_NUMBER_SHIFT;
3178 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GPIO_INFO,
3179 drv_mb_param, &rsp, &val);
3180 if (rc != ECORE_SUCCESS)
3183 *gpio_direction = (val & DRV_MB_PARAM_GPIO_DIRECTION_MASK) >>
3184 DRV_MB_PARAM_GPIO_DIRECTION_SHIFT;
3185 *gpio_ctrl = (val & DRV_MB_PARAM_GPIO_CTRL_MASK) >>
3186 DRV_MB_PARAM_GPIO_CTRL_SHIFT;
3188 if ((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_GPIO_OK)
3189 return ECORE_UNKNOWN_ERROR;
3191 return ECORE_SUCCESS;
3194 enum _ecore_status_t ecore_mcp_bist_register_test(struct ecore_hwfn *p_hwfn,
3195 struct ecore_ptt *p_ptt)
3197 u32 drv_mb_param = 0, rsp, param;
3198 enum _ecore_status_t rc = ECORE_SUCCESS;
3200 drv_mb_param = (DRV_MB_PARAM_BIST_REGISTER_TEST <<
3201 DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
3203 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BIST_TEST,
3204 drv_mb_param, &rsp, ¶m);
3206 if (rc != ECORE_SUCCESS)
3209 if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK) ||
3210 (param != DRV_MB_PARAM_BIST_RC_PASSED))
3211 rc = ECORE_UNKNOWN_ERROR;
3216 enum _ecore_status_t ecore_mcp_bist_clock_test(struct ecore_hwfn *p_hwfn,
3217 struct ecore_ptt *p_ptt)
3219 u32 drv_mb_param, rsp, param;
3220 enum _ecore_status_t rc = ECORE_SUCCESS;
3222 drv_mb_param = (DRV_MB_PARAM_BIST_CLOCK_TEST <<
3223 DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
3225 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BIST_TEST,
3226 drv_mb_param, &rsp, ¶m);
3228 if (rc != ECORE_SUCCESS)
3231 if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK) ||
3232 (param != DRV_MB_PARAM_BIST_RC_PASSED))
3233 rc = ECORE_UNKNOWN_ERROR;
3238 enum _ecore_status_t ecore_mcp_bist_nvm_test_get_num_images(
3239 struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, u32 *num_images)
3241 u32 drv_mb_param = 0, rsp;
3242 enum _ecore_status_t rc = ECORE_SUCCESS;
3244 drv_mb_param = (DRV_MB_PARAM_BIST_NVM_TEST_NUM_IMAGES <<
3245 DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
3247 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BIST_TEST,
3248 drv_mb_param, &rsp, num_images);
3250 if (rc != ECORE_SUCCESS)
3253 if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK))
3254 rc = ECORE_UNKNOWN_ERROR;
3259 enum _ecore_status_t ecore_mcp_bist_nvm_test_get_image_att(
3260 struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3261 struct bist_nvm_image_att *p_image_att, u32 image_index)
3263 struct ecore_mcp_nvm_params params;
3264 enum _ecore_status_t rc;
3267 OSAL_MEMSET(¶ms, 0, sizeof(struct ecore_mcp_nvm_params));
3268 params.nvm_common.offset = (DRV_MB_PARAM_BIST_NVM_TEST_IMAGE_BY_INDEX <<
3269 DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
3270 params.nvm_common.offset |= (image_index <<
3271 DRV_MB_PARAM_BIST_TEST_IMAGE_INDEX_SHIFT);
3273 params.type = ECORE_MCP_NVM_RD;
3274 params.nvm_rd.buf_size = &buf_size;
3275 params.nvm_common.cmd = DRV_MSG_CODE_BIST_TEST;
3276 params.nvm_rd.buf = (u32 *)p_image_att;
3278 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
3279 if (rc != ECORE_SUCCESS)
3282 if (((params.nvm_common.resp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK) ||
3283 (p_image_att->return_code != 1))
3284 rc = ECORE_UNKNOWN_ERROR;
3289 enum _ecore_status_t
3290 ecore_mcp_get_nvm_image_att(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3291 enum ecore_nvm_images image_id,
3292 struct ecore_nvm_image_att *p_image_att)
3294 struct bist_nvm_image_att mfw_image_att;
3295 enum nvm_image_type type;
3297 enum _ecore_status_t rc;
3299 /* Translate image_id into MFW definitions */
3301 case ECORE_NVM_IMAGE_ISCSI_CFG:
3302 type = NVM_TYPE_ISCSI_CFG;
3304 case ECORE_NVM_IMAGE_FCOE_CFG:
3305 type = NVM_TYPE_FCOE_CFG;
3307 case ECORE_NVM_IMAGE_MDUMP:
3308 type = NVM_TYPE_MDUMP;
3311 DP_NOTICE(p_hwfn, false, "Unknown request of image_id %08x\n",
3316 /* Learn number of images, then traverse and see if one fits */
3317 rc = ecore_mcp_bist_nvm_test_get_num_images(p_hwfn, p_ptt, &num_images);
3318 if (rc != ECORE_SUCCESS || !num_images)
3321 for (i = 0; i < num_images; i++) {
3322 rc = ecore_mcp_bist_nvm_test_get_image_att(p_hwfn, p_ptt,
3324 if (rc != ECORE_SUCCESS)
3327 if (type == mfw_image_att.image_type)
3330 if (i == num_images) {
3331 DP_VERBOSE(p_hwfn, ECORE_MSG_STORAGE,
3332 "Failed to find nvram image of type %08x\n",
3337 p_image_att->start_addr = mfw_image_att.nvm_start_addr;
3338 p_image_att->length = mfw_image_att.len;
3340 return ECORE_SUCCESS;
3343 enum _ecore_status_t ecore_mcp_get_nvm_image(struct ecore_hwfn *p_hwfn,
3344 struct ecore_ptt *p_ptt,
3345 enum ecore_nvm_images image_id,
3346 u8 *p_buffer, u32 buffer_len)
3348 struct ecore_nvm_image_att image_att;
3349 enum _ecore_status_t rc;
3351 OSAL_MEM_ZERO(p_buffer, buffer_len);
3353 rc = ecore_mcp_get_nvm_image_att(p_hwfn, p_ptt, image_id, &image_att);
3354 if (rc != ECORE_SUCCESS)
3357 /* Validate sizes - both the image's and the supplied buffer's */
3358 if (image_att.length <= 4) {
3359 DP_VERBOSE(p_hwfn, ECORE_MSG_STORAGE,
3360 "Image [%d] is too small - only %d bytes\n",
3361 image_id, image_att.length);
3365 /* Each NVM image is suffixed by CRC; Upper-layer has no need for it */
3366 image_att.length -= 4;
3368 if (image_att.length > buffer_len) {
3369 DP_VERBOSE(p_hwfn, ECORE_MSG_STORAGE,
3370 "Image [%d] is too big - %08x bytes where only %08x are available\n",
3371 image_id, image_att.length, buffer_len);
3375 return ecore_mcp_nvm_read(p_hwfn->p_dev, image_att.start_addr,
3376 p_buffer, image_att.length);
3379 enum _ecore_status_t
3380 ecore_mcp_get_temperature_info(struct ecore_hwfn *p_hwfn,
3381 struct ecore_ptt *p_ptt,
3382 struct ecore_temperature_info *p_temp_info)
3384 struct ecore_temperature_sensor *p_temp_sensor;
3385 struct temperature_status_stc mfw_temp_info;
3386 struct ecore_mcp_mb_params mb_params;
3388 enum _ecore_status_t rc;
3391 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
3392 mb_params.cmd = DRV_MSG_CODE_GET_TEMPERATURE;
3393 mb_params.p_data_dst = &mfw_temp_info;
3394 mb_params.data_dst_size = sizeof(mfw_temp_info);
3395 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
3396 if (rc != ECORE_SUCCESS)
3399 OSAL_BUILD_BUG_ON(ECORE_MAX_NUM_OF_SENSORS != MAX_NUM_OF_SENSORS);
3400 p_temp_info->num_sensors = OSAL_MIN_T(u32, mfw_temp_info.num_of_sensors,
3401 ECORE_MAX_NUM_OF_SENSORS);
3402 for (i = 0; i < p_temp_info->num_sensors; i++) {
3403 val = mfw_temp_info.sensor[i];
3404 p_temp_sensor = &p_temp_info->sensors[i];
3405 p_temp_sensor->sensor_location = (val & SENSOR_LOCATION_MASK) >>
3406 SENSOR_LOCATION_SHIFT;
3407 p_temp_sensor->threshold_high = (val & THRESHOLD_HIGH_MASK) >>
3408 THRESHOLD_HIGH_SHIFT;
3409 p_temp_sensor->critical = (val & CRITICAL_TEMPERATURE_MASK) >>
3410 CRITICAL_TEMPERATURE_SHIFT;
3411 p_temp_sensor->current_temp = (val & CURRENT_TEMP_MASK) >>
3415 return ECORE_SUCCESS;
3418 enum _ecore_status_t ecore_mcp_get_mba_versions(
3419 struct ecore_hwfn *p_hwfn,
3420 struct ecore_ptt *p_ptt,
3421 struct ecore_mba_vers *p_mba_vers)
3423 struct ecore_mcp_nvm_params params;
3424 enum _ecore_status_t rc;
3427 OSAL_MEM_ZERO(¶ms, sizeof(params));
3428 params.type = ECORE_MCP_NVM_RD;
3429 params.nvm_common.cmd = DRV_MSG_CODE_GET_MBA_VERSION;
3430 params.nvm_common.offset = 0;
3431 params.nvm_rd.buf = &(p_mba_vers->mba_vers[0]);
3432 params.nvm_rd.buf_size = &buf_size;
3433 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, ¶ms);
3435 if (rc != ECORE_SUCCESS)
3438 if ((params.nvm_common.resp & FW_MSG_CODE_MASK) !=
3440 rc = ECORE_UNKNOWN_ERROR;
3442 if (buf_size != MCP_DRV_NVM_BUF_LEN)
3443 rc = ECORE_UNKNOWN_ERROR;
3448 enum _ecore_status_t ecore_mcp_mem_ecc_events(struct ecore_hwfn *p_hwfn,
3449 struct ecore_ptt *p_ptt,
3454 return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MEM_ECC_EVENTS,
3455 0, &rsp, (u32 *)num_events);
3458 static enum resource_id_enum
3459 ecore_mcp_get_mfw_res_id(enum ecore_resources res_id)
3461 enum resource_id_enum mfw_res_id = RESOURCE_NUM_INVALID;
3465 mfw_res_id = RESOURCE_NUM_SB_E;
3467 case ECORE_L2_QUEUE:
3468 mfw_res_id = RESOURCE_NUM_L2_QUEUE_E;
3471 mfw_res_id = RESOURCE_NUM_VPORT_E;
3474 mfw_res_id = RESOURCE_NUM_RSS_ENGINES_E;
3477 mfw_res_id = RESOURCE_NUM_PQ_E;
3480 mfw_res_id = RESOURCE_NUM_RL_E;
3484 /* Each VFC resource can accommodate both a MAC and a VLAN */
3485 mfw_res_id = RESOURCE_VFC_FILTER_E;
3488 mfw_res_id = RESOURCE_ILT_E;
3490 case ECORE_LL2_QUEUE:
3491 mfw_res_id = RESOURCE_LL2_QUEUE_E;
3493 case ECORE_RDMA_CNQ_RAM:
3494 case ECORE_CMDQS_CQS:
3495 /* CNQ/CMDQS are the same resource */
3496 mfw_res_id = RESOURCE_CQS_E;
3498 case ECORE_RDMA_STATS_QUEUE:
3499 mfw_res_id = RESOURCE_RDMA_STATS_QUEUE_E;
3502 mfw_res_id = RESOURCE_BDQ_E;
3511 #define ECORE_RESC_ALLOC_VERSION_MAJOR 2
3512 #define ECORE_RESC_ALLOC_VERSION_MINOR 0
3513 #define ECORE_RESC_ALLOC_VERSION \
3514 ((ECORE_RESC_ALLOC_VERSION_MAJOR << \
3515 DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MAJOR_SHIFT) | \
3516 (ECORE_RESC_ALLOC_VERSION_MINOR << \
3517 DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MINOR_SHIFT))
3519 struct ecore_resc_alloc_in_params {
3521 enum ecore_resources res_id;
3525 struct ecore_resc_alloc_out_params {
3535 static enum _ecore_status_t
3536 ecore_mcp_resc_allocation_msg(struct ecore_hwfn *p_hwfn,
3537 struct ecore_ptt *p_ptt,
3538 struct ecore_resc_alloc_in_params *p_in_params,
3539 struct ecore_resc_alloc_out_params *p_out_params)
3541 struct ecore_mcp_mb_params mb_params;
3542 struct resource_info mfw_resc_info;
3543 enum _ecore_status_t rc;
3545 OSAL_MEM_ZERO(&mfw_resc_info, sizeof(mfw_resc_info));
3547 mfw_resc_info.res_id = ecore_mcp_get_mfw_res_id(p_in_params->res_id);
3548 if (mfw_resc_info.res_id == RESOURCE_NUM_INVALID) {
3550 "Failed to match resource %d [%s] with the MFW resources\n",
3551 p_in_params->res_id,
3552 ecore_hw_get_resc_name(p_in_params->res_id));
3556 switch (p_in_params->cmd) {
3557 case DRV_MSG_SET_RESOURCE_VALUE_MSG:
3558 mfw_resc_info.size = p_in_params->resc_max_val;
3560 case DRV_MSG_GET_RESOURCE_ALLOC_MSG:
3563 DP_ERR(p_hwfn, "Unexpected resource alloc command [0x%08x]\n",
3568 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
3569 mb_params.cmd = p_in_params->cmd;
3570 mb_params.param = ECORE_RESC_ALLOC_VERSION;
3571 mb_params.p_data_src = &mfw_resc_info;
3572 mb_params.data_src_size = sizeof(mfw_resc_info);
3573 mb_params.p_data_dst = mb_params.p_data_src;
3574 mb_params.data_dst_size = mb_params.data_src_size;
3576 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3577 "Resource message request: cmd 0x%08x, res_id %d [%s], hsi_version %d.%d, val 0x%x\n",
3578 p_in_params->cmd, p_in_params->res_id,
3579 ecore_hw_get_resc_name(p_in_params->res_id),
3580 ECORE_MFW_GET_FIELD(mb_params.param,
3581 DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MAJOR),
3582 ECORE_MFW_GET_FIELD(mb_params.param,
3583 DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MINOR),
3584 p_in_params->resc_max_val);
3586 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
3587 if (rc != ECORE_SUCCESS)
3590 p_out_params->mcp_resp = mb_params.mcp_resp;
3591 p_out_params->mcp_param = mb_params.mcp_param;
3592 p_out_params->resc_num = mfw_resc_info.size;
3593 p_out_params->resc_start = mfw_resc_info.offset;
3594 p_out_params->vf_resc_num = mfw_resc_info.vf_size;
3595 p_out_params->vf_resc_start = mfw_resc_info.vf_offset;
3596 p_out_params->flags = mfw_resc_info.flags;
3598 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3599 "Resource message response: mfw_hsi_version %d.%d, num 0x%x, start 0x%x, vf_num 0x%x, vf_start 0x%x, flags 0x%08x\n",
3600 ECORE_MFW_GET_FIELD(p_out_params->mcp_param,
3601 FW_MB_PARAM_RESOURCE_ALLOC_VERSION_MAJOR),
3602 ECORE_MFW_GET_FIELD(p_out_params->mcp_param,
3603 FW_MB_PARAM_RESOURCE_ALLOC_VERSION_MINOR),
3604 p_out_params->resc_num, p_out_params->resc_start,
3605 p_out_params->vf_resc_num, p_out_params->vf_resc_start,
3606 p_out_params->flags);
3608 return ECORE_SUCCESS;
3611 enum _ecore_status_t
3612 ecore_mcp_set_resc_max_val(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3613 enum ecore_resources res_id, u32 resc_max_val,
3616 struct ecore_resc_alloc_out_params out_params;
3617 struct ecore_resc_alloc_in_params in_params;
3618 enum _ecore_status_t rc;
3620 OSAL_MEM_ZERO(&in_params, sizeof(in_params));
3621 in_params.cmd = DRV_MSG_SET_RESOURCE_VALUE_MSG;
3622 in_params.res_id = res_id;
3623 in_params.resc_max_val = resc_max_val;
3624 OSAL_MEM_ZERO(&out_params, sizeof(out_params));
3625 rc = ecore_mcp_resc_allocation_msg(p_hwfn, p_ptt, &in_params,
3627 if (rc != ECORE_SUCCESS)
3630 *p_mcp_resp = out_params.mcp_resp;
3632 return ECORE_SUCCESS;
3635 enum _ecore_status_t
3636 ecore_mcp_get_resc_info(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3637 enum ecore_resources res_id, u32 *p_mcp_resp,
3638 u32 *p_resc_num, u32 *p_resc_start)
3640 struct ecore_resc_alloc_out_params out_params;
3641 struct ecore_resc_alloc_in_params in_params;
3642 enum _ecore_status_t rc;
3644 OSAL_MEM_ZERO(&in_params, sizeof(in_params));
3645 in_params.cmd = DRV_MSG_GET_RESOURCE_ALLOC_MSG;
3646 in_params.res_id = res_id;
3647 OSAL_MEM_ZERO(&out_params, sizeof(out_params));
3648 rc = ecore_mcp_resc_allocation_msg(p_hwfn, p_ptt, &in_params,
3650 if (rc != ECORE_SUCCESS)
3653 *p_mcp_resp = out_params.mcp_resp;
3655 if (*p_mcp_resp == FW_MSG_CODE_RESOURCE_ALLOC_OK) {
3656 *p_resc_num = out_params.resc_num;
3657 *p_resc_start = out_params.resc_start;
3660 return ECORE_SUCCESS;
3663 enum _ecore_status_t ecore_mcp_initiate_pf_flr(struct ecore_hwfn *p_hwfn,
3664 struct ecore_ptt *p_ptt)
3666 u32 mcp_resp, mcp_param;
3668 return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_INITIATE_PF_FLR, 0,
3669 &mcp_resp, &mcp_param);
3672 enum _ecore_status_t ecore_mcp_get_lldp_mac(struct ecore_hwfn *p_hwfn,
3673 struct ecore_ptt *p_ptt,
3674 u8 lldp_mac_addr[ETH_ALEN])
3676 struct ecore_mcp_mb_params mb_params;
3677 struct mcp_mac lldp_mac;
3678 enum _ecore_status_t rc;
3680 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
3681 mb_params.cmd = DRV_MSG_CODE_GET_LLDP_MAC;
3682 mb_params.p_data_dst = &lldp_mac;
3683 mb_params.data_dst_size = sizeof(lldp_mac);
3684 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
3685 if (rc != ECORE_SUCCESS)
3688 if (mb_params.mcp_resp != FW_MSG_CODE_OK) {
3689 DP_NOTICE(p_hwfn, false,
3690 "MFW lacks support for the GET_LLDP_MAC command [resp 0x%08x]\n",
3691 mb_params.mcp_resp);
3695 *(u16 *)lldp_mac_addr = *(u16 *)&lldp_mac.mac_upper;
3696 *(u32 *)(lldp_mac_addr + 2) = lldp_mac.mac_lower;
3698 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3699 "LLDP MAC address is %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
3700 lldp_mac_addr[0], lldp_mac_addr[1], lldp_mac_addr[2],
3701 lldp_mac_addr[3], lldp_mac_addr[4], lldp_mac_addr[5]);
3703 return ECORE_SUCCESS;
3706 enum _ecore_status_t ecore_mcp_set_lldp_mac(struct ecore_hwfn *p_hwfn,
3707 struct ecore_ptt *p_ptt,
3708 u8 lldp_mac_addr[ETH_ALEN])
3710 struct ecore_mcp_mb_params mb_params;
3711 struct mcp_mac lldp_mac;
3712 enum _ecore_status_t rc;
3714 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3715 "Configuring LLDP MAC address to %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
3716 lldp_mac_addr[0], lldp_mac_addr[1], lldp_mac_addr[2],
3717 lldp_mac_addr[3], lldp_mac_addr[4], lldp_mac_addr[5]);
3719 OSAL_MEM_ZERO(&lldp_mac, sizeof(lldp_mac));
3720 lldp_mac.mac_upper = *(u16 *)lldp_mac_addr;
3721 lldp_mac.mac_lower = *(u32 *)(lldp_mac_addr + 2);
3723 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
3724 mb_params.cmd = DRV_MSG_CODE_SET_LLDP_MAC;
3725 mb_params.p_data_src = &lldp_mac;
3726 mb_params.data_src_size = sizeof(lldp_mac);
3727 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
3728 if (rc != ECORE_SUCCESS)
3731 if (mb_params.mcp_resp != FW_MSG_CODE_OK) {
3732 DP_NOTICE(p_hwfn, false,
3733 "MFW lacks support for the SET_LLDP_MAC command [resp 0x%08x]\n",
3734 mb_params.mcp_resp);
3738 return ECORE_SUCCESS;
3741 static enum _ecore_status_t ecore_mcp_resource_cmd(struct ecore_hwfn *p_hwfn,
3742 struct ecore_ptt *p_ptt,
3743 u32 param, u32 *p_mcp_resp,
3746 enum _ecore_status_t rc;
3748 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_RESOURCE_CMD, param,
3749 p_mcp_resp, p_mcp_param);
3750 if (rc != ECORE_SUCCESS)
3753 if (*p_mcp_resp == FW_MSG_CODE_UNSUPPORTED) {
3755 "The resource command is unsupported by the MFW\n");
3756 return ECORE_NOTIMPL;
3759 if (*p_mcp_param == RESOURCE_OPCODE_UNKNOWN_CMD) {
3760 u8 opcode = ECORE_MFW_GET_FIELD(param, RESOURCE_CMD_REQ_OPCODE);
3762 DP_NOTICE(p_hwfn, false,
3763 "The resource command is unknown to the MFW [param 0x%08x, opcode %d]\n",
3771 static enum _ecore_status_t
3772 __ecore_mcp_resc_lock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3773 struct ecore_resc_lock_params *p_params)
3775 u32 param = 0, mcp_resp, mcp_param;
3777 enum _ecore_status_t rc;
3779 switch (p_params->timeout) {
3780 case ECORE_MCP_RESC_LOCK_TO_DEFAULT:
3781 opcode = RESOURCE_OPCODE_REQ;
3782 p_params->timeout = 0;
3784 case ECORE_MCP_RESC_LOCK_TO_NONE:
3785 opcode = RESOURCE_OPCODE_REQ_WO_AGING;
3786 p_params->timeout = 0;
3789 opcode = RESOURCE_OPCODE_REQ_W_AGING;
3793 ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_RESC, p_params->resource);
3794 ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_OPCODE, opcode);
3795 ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_AGE, p_params->timeout);
3797 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3798 "Resource lock request: param 0x%08x [age %d, opcode %d, resource %d]\n",
3799 param, p_params->timeout, opcode, p_params->resource);
3801 /* Attempt to acquire the resource */
3802 rc = ecore_mcp_resource_cmd(p_hwfn, p_ptt, param, &mcp_resp,
3804 if (rc != ECORE_SUCCESS)
3807 /* Analyze the response */
3808 p_params->owner = ECORE_MFW_GET_FIELD(mcp_param,
3809 RESOURCE_CMD_RSP_OWNER);
3810 opcode = ECORE_MFW_GET_FIELD(mcp_param, RESOURCE_CMD_RSP_OPCODE);
3812 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3813 "Resource lock response: mcp_param 0x%08x [opcode %d, owner %d]\n",
3814 mcp_param, opcode, p_params->owner);
3817 case RESOURCE_OPCODE_GNT:
3818 p_params->b_granted = true;
3820 case RESOURCE_OPCODE_BUSY:
3821 p_params->b_granted = false;
3824 DP_NOTICE(p_hwfn, false,
3825 "Unexpected opcode in resource lock response [mcp_param 0x%08x, opcode %d]\n",
3830 return ECORE_SUCCESS;
3833 enum _ecore_status_t
3834 ecore_mcp_resc_lock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3835 struct ecore_resc_lock_params *p_params)
3838 enum _ecore_status_t rc;
3841 /* No need for an interval before the first iteration */
3843 if (p_params->sleep_b4_retry) {
3844 u16 retry_interval_in_ms =
3845 DIV_ROUND_UP(p_params->retry_interval,
3848 OSAL_MSLEEP(retry_interval_in_ms);
3850 OSAL_UDELAY(p_params->retry_interval);
3854 rc = __ecore_mcp_resc_lock(p_hwfn, p_ptt, p_params);
3855 if (rc != ECORE_SUCCESS)
3858 if (p_params->b_granted)
3860 } while (retry_cnt++ < p_params->retry_num);
3862 return ECORE_SUCCESS;
3865 enum _ecore_status_t
3866 ecore_mcp_resc_unlock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3867 struct ecore_resc_unlock_params *p_params)
3869 u32 param = 0, mcp_resp, mcp_param;
3871 enum _ecore_status_t rc;
3873 opcode = p_params->b_force ? RESOURCE_OPCODE_FORCE_RELEASE
3874 : RESOURCE_OPCODE_RELEASE;
3875 ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_RESC, p_params->resource);
3876 ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_OPCODE, opcode);
3878 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3879 "Resource unlock request: param 0x%08x [opcode %d, resource %d]\n",
3880 param, opcode, p_params->resource);
3882 /* Attempt to release the resource */
3883 rc = ecore_mcp_resource_cmd(p_hwfn, p_ptt, param, &mcp_resp,
3885 if (rc != ECORE_SUCCESS)
3888 /* Analyze the response */
3889 opcode = ECORE_MFW_GET_FIELD(mcp_param, RESOURCE_CMD_RSP_OPCODE);
3891 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3892 "Resource unlock response: mcp_param 0x%08x [opcode %d]\n",
3896 case RESOURCE_OPCODE_RELEASED_PREVIOUS:
3898 "Resource unlock request for an already released resource [%d]\n",
3899 p_params->resource);
3901 case RESOURCE_OPCODE_RELEASED:
3902 p_params->b_released = true;
3904 case RESOURCE_OPCODE_WRONG_OWNER:
3905 p_params->b_released = false;
3908 DP_NOTICE(p_hwfn, false,
3909 "Unexpected opcode in resource unlock response [mcp_param 0x%08x, opcode %d]\n",
3914 return ECORE_SUCCESS;
3917 enum _ecore_status_t
3918 ecore_mcp_update_fcoe_cvid(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3921 u32 resp = 0, param = 0;
3922 enum _ecore_status_t rc;
3924 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OEM_UPDATE_FCOE_CVID,
3925 (u32)vlan << DRV_MB_PARAM_FCOE_CVID_SHIFT,
3927 if (rc != ECORE_SUCCESS)
3928 DP_ERR(p_hwfn, "Failed to update fcoe vlan, rc = %d\n", rc);
3933 enum _ecore_status_t
3934 ecore_mcp_update_fcoe_fabric_name(struct ecore_hwfn *p_hwfn,
3935 struct ecore_ptt *p_ptt, u8 *wwn)
3937 struct ecore_mcp_mb_params mb_params;
3938 struct mcp_wwn fabric_name;
3939 enum _ecore_status_t rc;
3941 OSAL_MEM_ZERO(&fabric_name, sizeof(fabric_name));
3942 fabric_name.wwn_upper = *(u32 *)wwn;
3943 fabric_name.wwn_lower = *(u32 *)(wwn + 4);
3945 OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
3946 mb_params.cmd = DRV_MSG_CODE_OEM_UPDATE_FCOE_FABRIC_NAME;
3947 mb_params.p_data_src = &fabric_name;
3948 mb_params.data_src_size = sizeof(fabric_name);
3949 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
3950 if (rc != ECORE_SUCCESS)
3951 DP_ERR(p_hwfn, "Failed to update fcoe wwn, rc = %d\n", rc);
3956 void ecore_mcp_wol_wr(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3957 u32 offset, u32 val)
3959 struct ecore_mcp_mb_params mb_params = {0};
3960 enum _ecore_status_t rc = ECORE_SUCCESS;
3963 mb_params.cmd = DRV_MSG_CODE_WRITE_WOL_REG;
3964 mb_params.param = offset;
3965 mb_params.p_data_src = &dword;
3966 mb_params.data_src_size = sizeof(dword);
3968 rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
3969 if (rc != ECORE_SUCCESS) {
3970 DP_NOTICE(p_hwfn, false,
3971 "Failed to wol write request, rc = %d\n", rc);
3974 if (mb_params.mcp_resp != FW_MSG_CODE_WOL_READ_WRITE_OK) {
3975 DP_NOTICE(p_hwfn, false,
3976 "Failed to write value 0x%x to offset 0x%x [mcp_resp 0x%x]\n",
3977 val, offset, mb_params.mcp_resp);
3978 rc = ECORE_UNKNOWN_ERROR;
3982 enum _ecore_status_t ecore_mcp_get_capabilities(struct ecore_hwfn *p_hwfn,
3983 struct ecore_ptt *p_ptt)
3986 enum _ecore_status_t rc;
3988 rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GET_MFW_FEATURE_SUPPORT,
3989 0, &mcp_resp, &p_hwfn->mcp_info->capabilities);
3990 if (rc == ECORE_SUCCESS)
3991 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_PROBE),
3992 "MFW supported features: %08x\n",
3993 p_hwfn->mcp_info->capabilities);
3998 enum _ecore_status_t ecore_mcp_set_capabilities(struct ecore_hwfn *p_hwfn,
3999 struct ecore_ptt *p_ptt)
4001 u32 mcp_resp, mcp_param, features;
4003 features = DRV_MB_PARAM_FEATURE_SUPPORT_PORT_SMARTLINQ |
4004 DRV_MB_PARAM_FEATURE_SUPPORT_PORT_EEE;
4006 return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_FEATURE_SUPPORT,
4007 features, &mcp_resp, &mcp_param);