drivers/net/qede/base/ecore_mcp.c

   1 /*
   2  * Copyright (c) 2016 QLogic Corporation.
   3  * All rights reserved.
   4  * www.qlogic.com
   5  *
   6  * See LICENSE.qede_pmd for copyright and licensing details.
   7  */
   8
   9 #include "bcm_osal.h"
  10 #include "ecore.h"
  11 #include "ecore_status.h"
  12 #include "ecore_mcp.h"
  13 #include "mcp_public.h"
  14 #include "reg_addr.h"
  15 #include "ecore_hw.h"
  16 #include "ecore_init_fw_funcs.h"
  17 #include "ecore_sriov.h"
  18 #include "ecore_vf.h"
  19 #include "ecore_iov_api.h"
  20 #include "ecore_gtt_reg_addr.h"
  21 #include "ecore_iro.h"
  22 #include "ecore_dcbx.h"
  23
  24 #define CHIP_MCP_RESP_ITER_US 10
  25 #define EMUL_MCP_RESP_ITER_US (1000 * 1000)
  26
  27 #define ECORE_DRV_MB_MAX_RETRIES (500 * 1000)   /* Account for 5 sec */
  28 #define ECORE_MCP_RESET_RETRIES (50 * 1000)     /* Account for 500 msec */
  29
  30 #define DRV_INNER_WR(_p_hwfn, _p_ptt, _ptr, _offset, _val) \
  31         ecore_wr(_p_hwfn, _p_ptt, (_p_hwfn->mcp_info->_ptr + _offset), \
  32                  _val)
  33
  34 #define DRV_INNER_RD(_p_hwfn, _p_ptt, _ptr, _offset) \
  35         ecore_rd(_p_hwfn, _p_ptt, (_p_hwfn->mcp_info->_ptr + _offset))
  36
  37 #define DRV_MB_WR(_p_hwfn, _p_ptt, _field, _val) \
  38         DRV_INNER_WR(p_hwfn, _p_ptt, drv_mb_addr, \
  39                      OFFSETOF(struct public_drv_mb, _field), _val)
  40
  41 #define DRV_MB_RD(_p_hwfn, _p_ptt, _field) \
  42         DRV_INNER_RD(_p_hwfn, _p_ptt, drv_mb_addr, \
  43                      OFFSETOF(struct public_drv_mb, _field))
  44
  45 #define PDA_COMP (((FW_MAJOR_VERSION) + (FW_MINOR_VERSION << 8)) << \
  46         DRV_ID_PDA_COMP_VER_SHIFT)
  47
  48 #define MCP_BYTES_PER_MBIT_SHIFT 17
  49
  50 #ifndef ASIC_ONLY
  51 static int loaded;
  52 static int loaded_port[MAX_NUM_PORTS] = { 0 };
  53 #endif
  54
  55 bool ecore_mcp_is_init(struct ecore_hwfn *p_hwfn)
  56 {
  57         if (!p_hwfn->mcp_info || !p_hwfn->mcp_info->public_base)
  58                 return false;
  59         return true;
  60 }
  61
  62 void ecore_mcp_cmd_port_init(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt)
  63 {
  64         u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
  65                                         PUBLIC_PORT);
  66         u32 mfw_mb_offsize = ecore_rd(p_hwfn, p_ptt, addr);
  67
  68         p_hwfn->mcp_info->port_addr = SECTION_ADDR(mfw_mb_offsize,
  69                                                    MFW_PORT(p_hwfn));
  70         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
  71                    "port_addr = 0x%x, port_id 0x%02x\n",
  72                    p_hwfn->mcp_info->port_addr, MFW_PORT(p_hwfn));
  73 }
  74
  75 void ecore_mcp_read_mb(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt)
  76 {
  77         u32 length = MFW_DRV_MSG_MAX_DWORDS(p_hwfn->mcp_info->mfw_mb_length);
  78         OSAL_BE32 tmp;
  79         u32 i;
  80
  81 #ifndef ASIC_ONLY
  82         if (CHIP_REV_IS_TEDIBEAR(p_hwfn->p_dev))
  83                 return;
  84 #endif
  85
  86         if (!p_hwfn->mcp_info->public_base)
  87                 return;
  88
  89         for (i = 0; i < length; i++) {
  90                 tmp = ecore_rd(p_hwfn, p_ptt,
  91                                p_hwfn->mcp_info->mfw_mb_addr +
  92                                (i << 2) + sizeof(u32));
  93
  94                 ((u32 *)p_hwfn->mcp_info->mfw_mb_cur)[i] =
  95                     OSAL_BE32_TO_CPU(tmp);
  96         }
  97 }
  98
  99 enum _ecore_status_t ecore_mcp_free(struct ecore_hwfn *p_hwfn)
 100 {
 101         if (p_hwfn->mcp_info) {
 102                 OSAL_FREE(p_hwfn->p_dev, p_hwfn->mcp_info->mfw_mb_cur);
 103                 OSAL_FREE(p_hwfn->p_dev, p_hwfn->mcp_info->mfw_mb_shadow);
 104                 OSAL_SPIN_LOCK_DEALLOC(&p_hwfn->mcp_info->lock);
 105         }
 106         OSAL_FREE(p_hwfn->p_dev, p_hwfn->mcp_info);
 107
 108         return ECORE_SUCCESS;
 109 }
 110
 111 static enum _ecore_status_t ecore_load_mcp_offsets(struct ecore_hwfn *p_hwfn,
 112                                                    struct ecore_ptt *p_ptt)
 113 {
 114         struct ecore_mcp_info *p_info = p_hwfn->mcp_info;
 115         u32 drv_mb_offsize, mfw_mb_offsize;
 116         u32 mcp_pf_id = MCP_PF_ID(p_hwfn);
 117
 118 #ifndef ASIC_ONLY
 119         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
 120                 DP_NOTICE(p_hwfn, false, "Emulation - assume no MFW\n");
 121                 p_info->public_base = 0;
 122                 return ECORE_INVAL;
 123         }
 124 #endif
 125
 126         p_info->public_base = ecore_rd(p_hwfn, p_ptt, MISC_REG_SHARED_MEM_ADDR);
 127         if (!p_info->public_base)
 128                 return ECORE_INVAL;
 129
 130         p_info->public_base |= GRCBASE_MCP;
 131
 132         /* Calculate the driver and MFW mailbox address */
 133         drv_mb_offsize = ecore_rd(p_hwfn, p_ptt,
 134                                   SECTION_OFFSIZE_ADDR(p_info->public_base,
 135                                                        PUBLIC_DRV_MB));
 136         p_info->drv_mb_addr = SECTION_ADDR(drv_mb_offsize, mcp_pf_id);
 137         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 138                    "drv_mb_offsiz = 0x%x, drv_mb_addr = 0x%x"
 139                    " mcp_pf_id = 0x%x\n",
 140                    drv_mb_offsize, p_info->drv_mb_addr, mcp_pf_id);
 141
 142         /* Set the MFW MB address */
 143         mfw_mb_offsize = ecore_rd(p_hwfn, p_ptt,
 144                                   SECTION_OFFSIZE_ADDR(p_info->public_base,
 145                                                        PUBLIC_MFW_MB));
 146         p_info->mfw_mb_addr = SECTION_ADDR(mfw_mb_offsize, mcp_pf_id);
 147         p_info->mfw_mb_length = (u16)ecore_rd(p_hwfn, p_ptt,
 148                                                p_info->mfw_mb_addr);
 149
 150         /* Get the current driver mailbox sequence before sending
 151          * the first command
 152          */
 153         p_info->drv_mb_seq = DRV_MB_RD(p_hwfn, p_ptt, drv_mb_header) &
 154             DRV_MSG_SEQ_NUMBER_MASK;
 155
 156         /* Get current FW pulse sequence */
 157         p_info->drv_pulse_seq = DRV_MB_RD(p_hwfn, p_ptt, drv_pulse_mb) &
 158             DRV_PULSE_SEQ_MASK;
 159
 160         p_info->mcp_hist = (u16)ecore_rd(p_hwfn, p_ptt,
 161                                           MISCS_REG_GENERIC_POR_0);
 162
 163         return ECORE_SUCCESS;
 164 }
 165
 166 enum _ecore_status_t ecore_mcp_cmd_init(struct ecore_hwfn *p_hwfn,
 167                                         struct ecore_ptt *p_ptt)
 168 {
 169         struct ecore_mcp_info *p_info;
 170         u32 size;
 171
 172         /* Allocate mcp_info structure */
 173         p_hwfn->mcp_info = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL,
 174                                        sizeof(*p_hwfn->mcp_info));
 175         if (!p_hwfn->mcp_info)
 176                 goto err;
 177         p_info = p_hwfn->mcp_info;
 178
 179         if (ecore_load_mcp_offsets(p_hwfn, p_ptt) != ECORE_SUCCESS) {
 180                 DP_NOTICE(p_hwfn, false, "MCP is not initialized\n");
 181                 /* Do not free mcp_info here, since public_base indicate that
 182                  * the MCP is not initialized
 183                  */
 184                 return ECORE_SUCCESS;
 185         }
 186
 187         size = MFW_DRV_MSG_MAX_DWORDS(p_info->mfw_mb_length) * sizeof(u32);
 188         p_info->mfw_mb_cur = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL, size);
 189         p_info->mfw_mb_shadow = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL, size);
 190         if (!p_info->mfw_mb_shadow || !p_info->mfw_mb_addr)
 191                 goto err;
 192
 193         /* Initialize the MFW spinlock */
 194         OSAL_SPIN_LOCK_ALLOC(p_hwfn, &p_info->lock);
 195         OSAL_SPIN_LOCK_INIT(&p_info->lock);
 196
 197         return ECORE_SUCCESS;
 198
 199 err:
 200         DP_NOTICE(p_hwfn, true, "Failed to allocate mcp memory\n");
 201         ecore_mcp_free(p_hwfn);
 202         return ECORE_NOMEM;
 203 }
 204
 205 /* Locks the MFW mailbox of a PF to ensure a single access.
 206  * The lock is achieved in most cases by holding a spinlock, causing other
 207  * threads to wait till a previous access is done.
 208  * In some cases (currently when a [UN]LOAD_REQ commands are sent), the single
 209  * access is achieved by setting a blocking flag, which will fail other
 210  * competing contexts to send their mailboxes.
 211  */
 212 static enum _ecore_status_t ecore_mcp_mb_lock(struct ecore_hwfn *p_hwfn,
 213                                               u32 cmd)
 214 {
 215         OSAL_SPIN_LOCK(&p_hwfn->mcp_info->lock);
 216
 217         /* The spinlock shouldn't be acquired when the mailbox command is
 218          * [UN]LOAD_REQ, since the engine is locked by the MFW, and a parallel
 219          * pending [UN]LOAD_REQ command of another PF together with a spinlock
 220          * (i.e. interrupts are disabled) - can lead to a deadlock.
 221          * It is assumed that for a single PF, no other mailbox commands can be
 222          * sent from another context while sending LOAD_REQ, and that any
 223          * parallel commands to UNLOAD_REQ can be cancelled.
 224          */
 225         if (cmd == DRV_MSG_CODE_LOAD_DONE || cmd == DRV_MSG_CODE_UNLOAD_DONE)
 226                 p_hwfn->mcp_info->block_mb_sending = false;
 227
 228         /* There's at least a single command that is sent by ecore during the
 229          * load sequence [expectation of MFW].
 230          */
 231         if ((p_hwfn->mcp_info->block_mb_sending) &&
 232             (cmd != DRV_MSG_CODE_FEATURE_SUPPORT)) {
 233                 DP_NOTICE(p_hwfn, false,
 234                           "Trying to send a MFW mailbox command [0x%x]"
 235                           " in parallel to [UN]LOAD_REQ. Aborting.\n",
 236                           cmd);
 237                 OSAL_SPIN_UNLOCK(&p_hwfn->mcp_info->lock);
 238                 return ECORE_BUSY;
 239         }
 240
 241         if (cmd == DRV_MSG_CODE_LOAD_REQ || cmd == DRV_MSG_CODE_UNLOAD_REQ) {
 242                 p_hwfn->mcp_info->block_mb_sending = true;
 243                 OSAL_SPIN_UNLOCK(&p_hwfn->mcp_info->lock);
 244         }
 245
 246         return ECORE_SUCCESS;
 247 }
 248
 249 static void ecore_mcp_mb_unlock(struct ecore_hwfn *p_hwfn, u32 cmd)
 250 {
 251         if (cmd != DRV_MSG_CODE_LOAD_REQ && cmd != DRV_MSG_CODE_UNLOAD_REQ)
 252                 OSAL_SPIN_UNLOCK(&p_hwfn->mcp_info->lock);
 253 }
 254
 255 enum _ecore_status_t ecore_mcp_reset(struct ecore_hwfn *p_hwfn,
 256                                      struct ecore_ptt *p_ptt)
 257 {
 258         u32 seq = ++p_hwfn->mcp_info->drv_mb_seq;
 259         u32 delay = CHIP_MCP_RESP_ITER_US;
 260         u32 org_mcp_reset_seq, cnt = 0;
 261         enum _ecore_status_t rc = ECORE_SUCCESS;
 262
 263 #ifndef ASIC_ONLY
 264         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev))
 265                 delay = EMUL_MCP_RESP_ITER_US;
 266 #endif
 267
 268         /* Ensure that only a single thread is accessing the mailbox at a
 269          * certain time.
 270          */
 271         rc = ecore_mcp_mb_lock(p_hwfn, DRV_MSG_CODE_MCP_RESET);
 272         if (rc != ECORE_SUCCESS)
 273                 return rc;
 274
 275         /* Set drv command along with the updated sequence */
 276         org_mcp_reset_seq = ecore_rd(p_hwfn, p_ptt, MISCS_REG_GENERIC_POR_0);
 277         DRV_MB_WR(p_hwfn, p_ptt, drv_mb_header, (DRV_MSG_CODE_MCP_RESET | seq));
 278
 279         do {
 280                 /* Wait for MFW response */
 281                 OSAL_UDELAY(delay);
 282                 /* Give the FW up to 500 second (50*1000*10usec) */
 283         } while ((org_mcp_reset_seq == ecore_rd(p_hwfn, p_ptt,
 284                                                 MISCS_REG_GENERIC_POR_0)) &&
 285                  (cnt++ < ECORE_MCP_RESET_RETRIES));
 286
 287         if (org_mcp_reset_seq !=
 288             ecore_rd(p_hwfn, p_ptt, MISCS_REG_GENERIC_POR_0)) {
 289                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 290                            "MCP was reset after %d usec\n", cnt * delay);
 291         } else {
 292                 DP_ERR(p_hwfn, "Failed to reset MCP\n");
 293                 rc = ECORE_AGAIN;
 294         }
 295
 296         ecore_mcp_mb_unlock(p_hwfn, DRV_MSG_CODE_MCP_RESET);
 297
 298         return rc;
 299 }
 300
 301 static enum _ecore_status_t ecore_do_mcp_cmd(struct ecore_hwfn *p_hwfn,
 302                                              struct ecore_ptt *p_ptt,
 303                                              u32 cmd, u32 param,
 304                                              u32 *o_mcp_resp,
 305                                              u32 *o_mcp_param)
 306 {
 307         u32 delay = CHIP_MCP_RESP_ITER_US;
 308         u32 max_retries = ECORE_DRV_MB_MAX_RETRIES;
 309         u32 seq, cnt = 1, actual_mb_seq;
 310         enum _ecore_status_t rc = ECORE_SUCCESS;
 311
 312 #ifndef ASIC_ONLY
 313         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev))
 314                 delay = EMUL_MCP_RESP_ITER_US;
 315         /* There is a built-in delay of 100usec in each MFW response read */
 316         if (CHIP_REV_IS_FPGA(p_hwfn->p_dev))
 317                 max_retries /= 10;
 318 #endif
 319
 320         /* Get actual driver mailbox sequence */
 321         actual_mb_seq = DRV_MB_RD(p_hwfn, p_ptt, drv_mb_header) &
 322             DRV_MSG_SEQ_NUMBER_MASK;
 323
 324         /* Use MCP history register to check if MCP reset occurred between
 325          * init time and now.
 326          */
 327         if (p_hwfn->mcp_info->mcp_hist !=
 328             ecore_rd(p_hwfn, p_ptt, MISCS_REG_GENERIC_POR_0)) {
 329                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "Rereading MCP offsets\n");
 330                 ecore_load_mcp_offsets(p_hwfn, p_ptt);
 331                 ecore_mcp_cmd_port_init(p_hwfn, p_ptt);
 332         }
 333         seq = ++p_hwfn->mcp_info->drv_mb_seq;
 334
 335         /* Set drv param */
 336         DRV_MB_WR(p_hwfn, p_ptt, drv_mb_param, param);
 337
 338         /* Set drv command along with the updated sequence */
 339         DRV_MB_WR(p_hwfn, p_ptt, drv_mb_header, (cmd | seq));
 340
 341         do {
 342                 /* Wait for MFW response */
 343                 OSAL_UDELAY(delay);
 344                 *o_mcp_resp = DRV_MB_RD(p_hwfn, p_ptt, fw_mb_header);
 345
 346                 /* Give the FW up to 5 second (500*10ms) */
 347         } while ((seq != (*o_mcp_resp & FW_MSG_SEQ_NUMBER_MASK)) &&
 348                  (cnt++ < max_retries));
 349
 350         /* Is this a reply to our command? */
 351         if (seq == (*o_mcp_resp & FW_MSG_SEQ_NUMBER_MASK)) {
 352                 *o_mcp_resp &= FW_MSG_CODE_MASK;
 353                 /* Get the MCP param */
 354                 *o_mcp_param = DRV_MB_RD(p_hwfn, p_ptt, fw_mb_param);
 355         } else {
 356                 /* FW BUG! */
 357                 DP_ERR(p_hwfn, "MFW failed to respond [cmd 0x%x param 0x%x]\n",
 358                        cmd, param);
 359                 *o_mcp_resp = 0;
 360                 rc = ECORE_AGAIN;
 361                 ecore_hw_err_notify(p_hwfn, ECORE_HW_ERR_MFW_RESP_FAIL);
 362         }
 363         return rc;
 364 }
 365
 366 static enum _ecore_status_t
 367 ecore_mcp_cmd_and_union(struct ecore_hwfn *p_hwfn,
 368                         struct ecore_ptt *p_ptt,
 369                         struct ecore_mcp_mb_params *p_mb_params)
 370 {
 371         union drv_union_data union_data;
 372         u32 union_data_addr;
 373         enum _ecore_status_t rc;
 374
 375         /* MCP not initialized */
 376         if (!ecore_mcp_is_init(p_hwfn)) {
 377                 DP_NOTICE(p_hwfn, true, "MFW is not initialized !\n");
 378                 return ECORE_BUSY;
 379         }
 380
 381         if (p_mb_params->data_src_size > sizeof(union_data) ||
 382             p_mb_params->data_dst_size > sizeof(union_data)) {
 383                 DP_ERR(p_hwfn,
 384                        "The provided size is larger than the union data size [src_size %u, dst_size %u, union_data_size %zu]\n",
 385                        p_mb_params->data_src_size, p_mb_params->data_dst_size,
 386                        sizeof(union_data));
 387                 return ECORE_INVAL;
 388         }
 389
 390         union_data_addr = p_hwfn->mcp_info->drv_mb_addr +
 391                           OFFSETOF(struct public_drv_mb, union_data);
 392
 393         /* Ensure that only a single thread is accessing the mailbox at a
 394          * certain time.
 395          */
 396         rc = ecore_mcp_mb_lock(p_hwfn, p_mb_params->cmd);
 397         if (rc != ECORE_SUCCESS)
 398                 return rc;
 399
 400         OSAL_MEM_ZERO(&union_data, sizeof(union_data));
 401         if (p_mb_params->p_data_src != OSAL_NULL && p_mb_params->data_src_size)
 402                 OSAL_MEMCPY(&union_data, p_mb_params->p_data_src,
 403                             p_mb_params->data_src_size);
 404         ecore_memcpy_to(p_hwfn, p_ptt, union_data_addr, &union_data,
 405                         sizeof(union_data));
 406
 407         rc = ecore_do_mcp_cmd(p_hwfn, p_ptt, p_mb_params->cmd,
 408                               p_mb_params->param, &p_mb_params->mcp_resp,
 409                               &p_mb_params->mcp_param);
 410
 411         if (p_mb_params->p_data_dst != OSAL_NULL &&
 412             p_mb_params->data_dst_size)
 413                 ecore_memcpy_from(p_hwfn, p_ptt, p_mb_params->p_data_dst,
 414                                   union_data_addr, p_mb_params->data_dst_size);
 415
 416         ecore_mcp_mb_unlock(p_hwfn, p_mb_params->cmd);
 417
 418         return rc;
 419 }
 420
 421 enum _ecore_status_t ecore_mcp_cmd(struct ecore_hwfn *p_hwfn,
 422                                    struct ecore_ptt *p_ptt, u32 cmd, u32 param,
 423                                    u32 *o_mcp_resp, u32 *o_mcp_param)
 424 {
 425         struct ecore_mcp_mb_params mb_params;
 426         enum _ecore_status_t rc;
 427
 428 #ifndef ASIC_ONLY
 429         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
 430                 if (cmd == DRV_MSG_CODE_UNLOAD_REQ) {
 431                         loaded--;
 432                         loaded_port[p_hwfn->port_id]--;
 433                         DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "Unload cnt: 0x%x\n",
 434                                    loaded);
 435                 }
 436                 return ECORE_SUCCESS;
 437         }
 438 #endif
 439
 440         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
 441         mb_params.cmd = cmd;
 442         mb_params.param = param;
 443         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
 444         if (rc != ECORE_SUCCESS)
 445                 return rc;
 446
 447         *o_mcp_resp = mb_params.mcp_resp;
 448         *o_mcp_param = mb_params.mcp_param;
 449
 450         return ECORE_SUCCESS;
 451 }
 452
 453 enum _ecore_status_t ecore_mcp_nvm_wr_cmd(struct ecore_hwfn *p_hwfn,
 454                                           struct ecore_ptt *p_ptt,
 455                                           u32 cmd,
 456                                           u32 param,
 457                                           u32 *o_mcp_resp,
 458                                           u32 *o_mcp_param,
 459                                           u32 i_txn_size, u32 *i_buf)
 460 {
 461         struct ecore_mcp_mb_params mb_params;
 462         enum _ecore_status_t rc;
 463
 464         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
 465         mb_params.cmd = cmd;
 466         mb_params.param = param;
 467         mb_params.p_data_src = i_buf;
 468         mb_params.data_src_size = (u8)i_txn_size;
 469         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
 470         if (rc != ECORE_SUCCESS)
 471                 return rc;
 472
 473         *o_mcp_resp = mb_params.mcp_resp;
 474         *o_mcp_param = mb_params.mcp_param;
 475
 476         return ECORE_SUCCESS;
 477 }
 478
 479 enum _ecore_status_t ecore_mcp_nvm_rd_cmd(struct ecore_hwfn *p_hwfn,
 480                                           struct ecore_ptt *p_ptt,
 481                                           u32 cmd,
 482                                           u32 param,
 483                                           u32 *o_mcp_resp,
 484                                           u32 *o_mcp_param,
 485                                           u32 *o_txn_size, u32 *o_buf)
 486 {
 487         struct ecore_mcp_mb_params mb_params;
 488         u8 raw_data[MCP_DRV_NVM_BUF_LEN];
 489         enum _ecore_status_t rc;
 490
 491         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
 492         mb_params.cmd = cmd;
 493         mb_params.param = param;
 494         mb_params.p_data_dst = raw_data;
 495
 496         /* Use the maximal value since the actual one is part of the response */
 497         mb_params.data_dst_size = MCP_DRV_NVM_BUF_LEN;
 498
 499         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
 500         if (rc != ECORE_SUCCESS)
 501                 return rc;
 502
 503         *o_mcp_resp = mb_params.mcp_resp;
 504         *o_mcp_param = mb_params.mcp_param;
 505
 506         *o_txn_size = *o_mcp_param;
 507         /* @DPDK */
 508         OSAL_MEMCPY(o_buf, raw_data, RTE_MIN(*o_txn_size, MCP_DRV_NVM_BUF_LEN));
 509
 510         return ECORE_SUCCESS;
 511 }
 512
 513 #ifndef ASIC_ONLY
 514 static void ecore_mcp_mf_workaround(struct ecore_hwfn *p_hwfn,
 515                                     u32 *p_load_code)
 516 {
 517         static int load_phase = FW_MSG_CODE_DRV_LOAD_ENGINE;
 518
 519         if (!loaded)
 520                 load_phase = FW_MSG_CODE_DRV_LOAD_ENGINE;
 521         else if (!loaded_port[p_hwfn->port_id])
 522                 load_phase = FW_MSG_CODE_DRV_LOAD_PORT;
 523         else
 524                 load_phase = FW_MSG_CODE_DRV_LOAD_FUNCTION;
 525
 526         /* On CMT, always tell that it's engine */
 527         if (p_hwfn->p_dev->num_hwfns > 1)
 528                 load_phase = FW_MSG_CODE_DRV_LOAD_ENGINE;
 529
 530         *p_load_code = load_phase;
 531         loaded++;
 532         loaded_port[p_hwfn->port_id]++;
 533
 534         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 535                    "Load phase: %x load cnt: 0x%x port id=%d port_load=%d\n",
 536                    *p_load_code, loaded, p_hwfn->port_id,
 537                    loaded_port[p_hwfn->port_id]);
 538 }
 539 #endif
 540
 541 static bool
 542 ecore_mcp_can_force_load(u8 drv_role, u8 exist_drv_role,
 543                          enum ecore_override_force_load override_force_load)
 544 {
 545         bool can_force_load = false;
 546
 547         switch (override_force_load) {
 548         case ECORE_OVERRIDE_FORCE_LOAD_ALWAYS:
 549                 can_force_load = true;
 550                 break;
 551         case ECORE_OVERRIDE_FORCE_LOAD_NEVER:
 552                 can_force_load = false;
 553                 break;
 554         default:
 555                 can_force_load = (drv_role == DRV_ROLE_OS &&
 556                                   exist_drv_role == DRV_ROLE_PREBOOT) ||
 557                                  (drv_role == DRV_ROLE_KDUMP &&
 558                                   exist_drv_role == DRV_ROLE_OS);
 559                 break;
 560         }
 561
 562         return can_force_load;
 563 }
 564
 565 static enum _ecore_status_t ecore_mcp_cancel_load_req(struct ecore_hwfn *p_hwfn,
 566                                                       struct ecore_ptt *p_ptt)
 567 {
 568         u32 resp = 0, param = 0;
 569         enum _ecore_status_t rc;
 570
 571         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_CANCEL_LOAD_REQ, 0,
 572                            &resp, &param);
 573         if (rc != ECORE_SUCCESS)
 574                 DP_NOTICE(p_hwfn, false,
 575                           "Failed to send cancel load request, rc = %d\n", rc);
 576
 577         return rc;
 578 }
 579
 580 #define CONFIG_ECORE_L2_BITMAP_IDX      (0x1 << 0)
 581 #define CONFIG_ECORE_SRIOV_BITMAP_IDX   (0x1 << 1)
 582 #define CONFIG_ECORE_ROCE_BITMAP_IDX    (0x1 << 2)
 583 #define CONFIG_ECORE_IWARP_BITMAP_IDX   (0x1 << 3)
 584 #define CONFIG_ECORE_FCOE_BITMAP_IDX    (0x1 << 4)
 585 #define CONFIG_ECORE_ISCSI_BITMAP_IDX   (0x1 << 5)
 586 #define CONFIG_ECORE_LL2_BITMAP_IDX     (0x1 << 6)
 587
 588 static u32 ecore_get_config_bitmap(void)
 589 {
 590         u32 config_bitmap = 0x0;
 591
 592 #ifdef CONFIG_ECORE_L2
 593         config_bitmap |= CONFIG_ECORE_L2_BITMAP_IDX;
 594 #endif
 595 #ifdef CONFIG_ECORE_SRIOV
 596         config_bitmap |= CONFIG_ECORE_SRIOV_BITMAP_IDX;
 597 #endif
 598 #ifdef CONFIG_ECORE_ROCE
 599         config_bitmap |= CONFIG_ECORE_ROCE_BITMAP_IDX;
 600 #endif
 601 #ifdef CONFIG_ECORE_IWARP
 602         config_bitmap |= CONFIG_ECORE_IWARP_BITMAP_IDX;
 603 #endif
 604 #ifdef CONFIG_ECORE_FCOE
 605         config_bitmap |= CONFIG_ECORE_FCOE_BITMAP_IDX;
 606 #endif
 607 #ifdef CONFIG_ECORE_ISCSI
 608         config_bitmap |= CONFIG_ECORE_ISCSI_BITMAP_IDX;
 609 #endif
 610 #ifdef CONFIG_ECORE_LL2
 611         config_bitmap |= CONFIG_ECORE_LL2_BITMAP_IDX;
 612 #endif
 613
 614         return config_bitmap;
 615 }
 616
 617 struct ecore_load_req_in_params {
 618         u8 hsi_ver;
 619 #define ECORE_LOAD_REQ_HSI_VER_DEFAULT  0
 620 #define ECORE_LOAD_REQ_HSI_VER_1        1
 621         u32 drv_ver_0;
 622         u32 drv_ver_1;
 623         u32 fw_ver;
 624         u8 drv_role;
 625         u8 timeout_val;
 626         u8 force_cmd;
 627         bool avoid_eng_reset;
 628 };
 629
 630 struct ecore_load_req_out_params {
 631         u32 load_code;
 632         u32 exist_drv_ver_0;
 633         u32 exist_drv_ver_1;
 634         u32 exist_fw_ver;
 635         u8 exist_drv_role;
 636         u8 mfw_hsi_ver;
 637         bool drv_exists;
 638 };
 639
 640 static enum _ecore_status_t
 641 __ecore_mcp_load_req(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
 642                      struct ecore_load_req_in_params *p_in_params,
 643                      struct ecore_load_req_out_params *p_out_params)
 644 {
 645         struct ecore_mcp_mb_params mb_params;
 646         struct load_req_stc load_req;
 647         struct load_rsp_stc load_rsp;
 648         u32 hsi_ver;
 649         enum _ecore_status_t rc;
 650
 651         OSAL_MEM_ZERO(&load_req, sizeof(load_req));
 652         load_req.drv_ver_0 = p_in_params->drv_ver_0;
 653         load_req.drv_ver_1 = p_in_params->drv_ver_1;
 654         load_req.fw_ver = p_in_params->fw_ver;
 655         ECORE_MFW_SET_FIELD(load_req.misc0, LOAD_REQ_ROLE,
 656                             p_in_params->drv_role);
 657         ECORE_MFW_SET_FIELD(load_req.misc0, LOAD_REQ_LOCK_TO,
 658                             p_in_params->timeout_val);
 659         ECORE_MFW_SET_FIELD(load_req.misc0, LOAD_REQ_FORCE,
 660                             p_in_params->force_cmd);
 661         ECORE_MFW_SET_FIELD(load_req.misc0, LOAD_REQ_FLAGS0,
 662                             p_in_params->avoid_eng_reset);
 663
 664         hsi_ver = (p_in_params->hsi_ver == ECORE_LOAD_REQ_HSI_VER_DEFAULT) ?
 665                   DRV_ID_MCP_HSI_VER_CURRENT :
 666                   (p_in_params->hsi_ver << DRV_ID_MCP_HSI_VER_SHIFT);
 667
 668         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
 669         mb_params.cmd = DRV_MSG_CODE_LOAD_REQ;
 670         mb_params.param = PDA_COMP | hsi_ver | p_hwfn->p_dev->drv_type;
 671         mb_params.p_data_src = &load_req;
 672         mb_params.data_src_size = sizeof(load_req);
 673         mb_params.p_data_dst = &load_rsp;
 674         mb_params.data_dst_size = sizeof(load_rsp);
 675
 676         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 677                    "Load Request: param 0x%08x [init_hw %d, drv_type %d, hsi_ver %d, pda 0x%04x]\n",
 678                    mb_params.param,
 679                    ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_DRV_INIT_HW),
 680                    ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_DRV_TYPE),
 681                    ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_MCP_HSI_VER),
 682                    ECORE_MFW_GET_FIELD(mb_params.param, DRV_ID_PDA_COMP_VER));
 683
 684         if (p_in_params->hsi_ver != ECORE_LOAD_REQ_HSI_VER_1)
 685                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 686                            "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",
 687                            load_req.drv_ver_0, load_req.drv_ver_1,
 688                            load_req.fw_ver, load_req.misc0,
 689                            ECORE_MFW_GET_FIELD(load_req.misc0, LOAD_REQ_ROLE),
 690                            ECORE_MFW_GET_FIELD(load_req.misc0,
 691                                                LOAD_REQ_LOCK_TO),
 692                            ECORE_MFW_GET_FIELD(load_req.misc0, LOAD_REQ_FORCE),
 693                            ECORE_MFW_GET_FIELD(load_req.misc0,
 694                                                LOAD_REQ_FLAGS0));
 695
 696         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
 697         if (rc != ECORE_SUCCESS) {
 698                 DP_NOTICE(p_hwfn, false,
 699                           "Failed to send load request, rc = %d\n", rc);
 700                 return rc;
 701         }
 702
 703         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 704                    "Load Response: resp 0x%08x\n", mb_params.mcp_resp);
 705         p_out_params->load_code = mb_params.mcp_resp;
 706
 707         if (p_in_params->hsi_ver != ECORE_LOAD_REQ_HSI_VER_1 &&
 708             p_out_params->load_code != FW_MSG_CODE_DRV_LOAD_REFUSED_HSI_1) {
 709                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 710                            "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",
 711                            load_rsp.drv_ver_0, load_rsp.drv_ver_1,
 712                            load_rsp.fw_ver, load_rsp.misc0,
 713                            ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_ROLE),
 714                            ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_HSI),
 715                            ECORE_MFW_GET_FIELD(load_rsp.misc0,
 716                                                LOAD_RSP_FLAGS0));
 717
 718                 p_out_params->exist_drv_ver_0 = load_rsp.drv_ver_0;
 719                 p_out_params->exist_drv_ver_1 = load_rsp.drv_ver_1;
 720                 p_out_params->exist_fw_ver = load_rsp.fw_ver;
 721                 p_out_params->exist_drv_role =
 722                         ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_ROLE);
 723                 p_out_params->mfw_hsi_ver =
 724                         ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_HSI);
 725                 p_out_params->drv_exists =
 726                         ECORE_MFW_GET_FIELD(load_rsp.misc0, LOAD_RSP_FLAGS0) &
 727                         LOAD_RSP_FLAGS0_DRV_EXISTS;
 728         }
 729
 730         return ECORE_SUCCESS;
 731 }
 732
 733 static void ecore_get_mfw_drv_role(struct ecore_hwfn *p_hwfn,
 734                                    enum ecore_drv_role drv_role,
 735                                    u8 *p_mfw_drv_role)
 736 {
 737         switch (drv_role) {
 738         case ECORE_DRV_ROLE_OS:
 739                 *p_mfw_drv_role = DRV_ROLE_OS;
 740                 break;
 741         case ECORE_DRV_ROLE_KDUMP:
 742                 *p_mfw_drv_role = DRV_ROLE_KDUMP;
 743                 break;
 744         }
 745 }
 746
 747 enum ecore_load_req_force {
 748         ECORE_LOAD_REQ_FORCE_NONE,
 749         ECORE_LOAD_REQ_FORCE_PF,
 750         ECORE_LOAD_REQ_FORCE_ALL,
 751 };
 752
 753 static void ecore_get_mfw_force_cmd(struct ecore_hwfn *p_hwfn,
 754                                     enum ecore_load_req_force force_cmd,
 755                                     u8 *p_mfw_force_cmd)
 756 {
 757         switch (force_cmd) {
 758         case ECORE_LOAD_REQ_FORCE_NONE:
 759                 *p_mfw_force_cmd = LOAD_REQ_FORCE_NONE;
 760                 break;
 761         case ECORE_LOAD_REQ_FORCE_PF:
 762                 *p_mfw_force_cmd = LOAD_REQ_FORCE_PF;
 763                 break;
 764         case ECORE_LOAD_REQ_FORCE_ALL:
 765                 *p_mfw_force_cmd = LOAD_REQ_FORCE_ALL;
 766                 break;
 767         }
 768 }
 769
 770 enum _ecore_status_t ecore_mcp_load_req(struct ecore_hwfn *p_hwfn,
 771                                         struct ecore_ptt *p_ptt,
 772                                         struct ecore_load_req_params *p_params)
 773 {
 774         struct ecore_load_req_out_params out_params;
 775         struct ecore_load_req_in_params in_params;
 776         u8 mfw_drv_role = 0, mfw_force_cmd;
 777         enum _ecore_status_t rc;
 778
 779 #ifndef ASIC_ONLY
 780         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
 781                 ecore_mcp_mf_workaround(p_hwfn, &p_params->load_code);
 782                 return ECORE_SUCCESS;
 783         }
 784 #endif
 785
 786         OSAL_MEM_ZERO(&in_params, sizeof(in_params));
 787         in_params.hsi_ver = ECORE_LOAD_REQ_HSI_VER_DEFAULT;
 788         in_params.drv_ver_0 = ECORE_VERSION;
 789         in_params.drv_ver_1 = ecore_get_config_bitmap();
 790         in_params.fw_ver = STORM_FW_VERSION;
 791         ecore_get_mfw_drv_role(p_hwfn, p_params->drv_role, &mfw_drv_role);
 792         in_params.drv_role = mfw_drv_role;
 793         in_params.timeout_val = p_params->timeout_val;
 794         ecore_get_mfw_force_cmd(p_hwfn, ECORE_LOAD_REQ_FORCE_NONE,
 795                                 &mfw_force_cmd);
 796         in_params.force_cmd = mfw_force_cmd;
 797         in_params.avoid_eng_reset = p_params->avoid_eng_reset;
 798
 799         OSAL_MEM_ZERO(&out_params, sizeof(out_params));
 800         rc = __ecore_mcp_load_req(p_hwfn, p_ptt, &in_params, &out_params);
 801         if (rc != ECORE_SUCCESS)
 802                 return rc;
 803
 804         /* First handle cases where another load request should/might be sent:
 805          * - MFW expects the old interface [HSI version = 1]
 806          * - MFW responds that a force load request is required
 807          */
 808         if (out_params.load_code == FW_MSG_CODE_DRV_LOAD_REFUSED_HSI_1) {
 809                 DP_INFO(p_hwfn,
 810                         "MFW refused a load request due to HSI > 1. Resending with HSI = 1.\n");
 811
 812                 /* The previous load request set the mailbox blocking */
 813                 p_hwfn->mcp_info->block_mb_sending = false;
 814
 815                 in_params.hsi_ver = ECORE_LOAD_REQ_HSI_VER_1;
 816                 OSAL_MEM_ZERO(&out_params, sizeof(out_params));
 817                 rc = __ecore_mcp_load_req(p_hwfn, p_ptt, &in_params,
 818                                           &out_params);
 819                 if (rc != ECORE_SUCCESS)
 820                         return rc;
 821         } else if (out_params.load_code ==
 822                    FW_MSG_CODE_DRV_LOAD_REFUSED_REQUIRES_FORCE) {
 823                 /* The previous load request set the mailbox blocking */
 824                 p_hwfn->mcp_info->block_mb_sending = false;
 825
 826                 if (ecore_mcp_can_force_load(in_params.drv_role,
 827                                              out_params.exist_drv_role,
 828                                              p_params->override_force_load)) {
 829                         DP_INFO(p_hwfn,
 830                                 "A force load is required [{role, fw_ver, drv_ver}: loading={%d, 0x%08x, 0x%08x_%08x}, existing={%d, 0x%08x, 0x%08x_%08x}]\n",
 831                                 in_params.drv_role, in_params.fw_ver,
 832                                 in_params.drv_ver_0, in_params.drv_ver_1,
 833                                 out_params.exist_drv_role,
 834                                 out_params.exist_fw_ver,
 835                                 out_params.exist_drv_ver_0,
 836                                 out_params.exist_drv_ver_1);
 837
 838                         ecore_get_mfw_force_cmd(p_hwfn,
 839                                                 ECORE_LOAD_REQ_FORCE_ALL,
 840                                                 &mfw_force_cmd);
 841
 842                         in_params.force_cmd = mfw_force_cmd;
 843                         OSAL_MEM_ZERO(&out_params, sizeof(out_params));
 844                         rc = __ecore_mcp_load_req(p_hwfn, p_ptt, &in_params,
 845                                                   &out_params);
 846                         if (rc != ECORE_SUCCESS)
 847                                 return rc;
 848                 } else {
 849                         DP_NOTICE(p_hwfn, false,
 850                                   "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}] - Avoid\n",
 851                                   in_params.drv_role, in_params.fw_ver,
 852                                   in_params.drv_ver_0, in_params.drv_ver_1,
 853                                   out_params.exist_drv_role,
 854                                   out_params.exist_fw_ver,
 855                                   out_params.exist_drv_ver_0,
 856                                   out_params.exist_drv_ver_1);
 857
 858                         ecore_mcp_cancel_load_req(p_hwfn, p_ptt);
 859                         return ECORE_BUSY;
 860                 }
 861         }
 862
 863         /* Now handle the other types of responses.
 864          * The "REFUSED_HSI_1" and "REFUSED_REQUIRES_FORCE" responses are not
 865          * expected here after the additional revised load requests were sent.
 866          */
 867         switch (out_params.load_code) {
 868         case FW_MSG_CODE_DRV_LOAD_ENGINE:
 869         case FW_MSG_CODE_DRV_LOAD_PORT:
 870         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
 871                 if (out_params.mfw_hsi_ver != ECORE_LOAD_REQ_HSI_VER_1 &&
 872                     out_params.drv_exists) {
 873                         /* The role and fw/driver version match, but the PF is
 874                          * already loaded and has not been unloaded gracefully.
 875                          * This is unexpected since a quasi-FLR request was
 876                          * previously sent as part of ecore_hw_prepare().
 877                          */
 878                         DP_NOTICE(p_hwfn, false,
 879                                   "PF is already loaded - shouldn't have got here since a quasi-FLR request was previously sent!\n");
 880                         return ECORE_INVAL;
 881                 }
 882                 break;
 883         default:
 884                 DP_NOTICE(p_hwfn, false,
 885                           "Unexpected refusal to load request [resp 0x%08x]. Aborting.\n",
 886                           out_params.load_code);
 887                 return ECORE_BUSY;
 888         }
 889
 890         p_params->load_code = out_params.load_code;
 891
 892         return ECORE_SUCCESS;
 893 }
 894
 895 enum _ecore_status_t ecore_mcp_load_done(struct ecore_hwfn *p_hwfn,
 896                                          struct ecore_ptt *p_ptt)
 897 {
 898         u32 resp = 0, param = 0;
 899         enum _ecore_status_t rc;
 900
 901         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_LOAD_DONE, 0, &resp,
 902                            &param);
 903         if (rc != ECORE_SUCCESS) {
 904                 DP_NOTICE(p_hwfn, false,
 905                           "Failed to send a LOAD_DONE command, rc = %d\n", rc);
 906                 return rc;
 907         }
 908
 909 #define FW_MB_PARAM_LOAD_DONE_DID_EFUSE_ERROR     (1 << 0)
 910
 911         /* Check if there is a DID mismatch between nvm-cfg/efuse */
 912         if (param & FW_MB_PARAM_LOAD_DONE_DID_EFUSE_ERROR)
 913                 DP_NOTICE(p_hwfn, false,
 914                           "warning: device configuration is not supported on this board type. The device may not function as expected.\n");
 915
 916         return ECORE_SUCCESS;
 917 }
 918
 919 enum _ecore_status_t ecore_mcp_unload_req(struct ecore_hwfn *p_hwfn,
 920                                           struct ecore_ptt *p_ptt)
 921 {
 922         u32 wol_param, mcp_resp, mcp_param;
 923
 924         /* @DPDK */
 925         wol_param = DRV_MB_PARAM_UNLOAD_WOL_MCP;
 926
 927         return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_UNLOAD_REQ, wol_param,
 928                              &mcp_resp, &mcp_param);
 929 }
 930
 931 enum _ecore_status_t ecore_mcp_unload_done(struct ecore_hwfn *p_hwfn,
 932                                            struct ecore_ptt *p_ptt)
 933 {
 934         struct ecore_mcp_mb_params mb_params;
 935         struct mcp_mac wol_mac;
 936
 937         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
 938         mb_params.cmd = DRV_MSG_CODE_UNLOAD_DONE;
 939
 940         return ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
 941 }
 942
 943 static void ecore_mcp_handle_vf_flr(struct ecore_hwfn *p_hwfn,
 944                                     struct ecore_ptt *p_ptt)
 945 {
 946         u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
 947                                         PUBLIC_PATH);
 948         u32 mfw_path_offsize = ecore_rd(p_hwfn, p_ptt, addr);
 949         u32 path_addr = SECTION_ADDR(mfw_path_offsize,
 950                                      ECORE_PATH_ID(p_hwfn));
 951         u32 disabled_vfs[VF_MAX_STATIC / 32];
 952         int i;
 953
 954         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 955                    "Reading Disabled VF information from [offset %08x],"
 956                    " path_addr %08x\n",
 957                    mfw_path_offsize, path_addr);
 958
 959         for (i = 0; i < (VF_MAX_STATIC / 32); i++) {
 960                 disabled_vfs[i] = ecore_rd(p_hwfn, p_ptt,
 961                                            path_addr +
 962                                            OFFSETOF(struct public_path,
 963                                                     mcp_vf_disabled) +
 964                                            sizeof(u32) * i);
 965                 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_IOV),
 966                            "FLR-ed VFs [%08x,...,%08x] - %08x\n",
 967                            i * 32, (i + 1) * 32 - 1, disabled_vfs[i]);
 968         }
 969
 970         if (ecore_iov_mark_vf_flr(p_hwfn, disabled_vfs))
 971                 OSAL_VF_FLR_UPDATE(p_hwfn);
 972 }
 973
 974 enum _ecore_status_t ecore_mcp_ack_vf_flr(struct ecore_hwfn *p_hwfn,
 975                                           struct ecore_ptt *p_ptt,
 976                                           u32 *vfs_to_ack)
 977 {
 978         u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
 979                                         PUBLIC_FUNC);
 980         u32 mfw_func_offsize = ecore_rd(p_hwfn, p_ptt, addr);
 981         u32 func_addr = SECTION_ADDR(mfw_func_offsize,
 982                                      MCP_PF_ID(p_hwfn));
 983         struct ecore_mcp_mb_params mb_params;
 984         enum _ecore_status_t rc;
 985         int i;
 986
 987         for (i = 0; i < (VF_MAX_STATIC / 32); i++)
 988                 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_IOV),
 989                            "Acking VFs [%08x,...,%08x] - %08x\n",
 990                            i * 32, (i + 1) * 32 - 1, vfs_to_ack[i]);
 991
 992         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
 993         mb_params.cmd = DRV_MSG_CODE_VF_DISABLED_DONE;
 994         mb_params.p_data_src = vfs_to_ack;
 995         mb_params.data_src_size = VF_MAX_STATIC / 8;
 996         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt,
 997                                      &mb_params);
 998         if (rc != ECORE_SUCCESS) {
 999                 DP_NOTICE(p_hwfn, false,
1000                           "Failed to pass ACK for VF flr to MFW\n");
1001                 return ECORE_TIMEOUT;
1002         }
1003
1004         /* TMP - clear the ACK bits; should be done by MFW */
1005         for (i = 0; i < (VF_MAX_STATIC / 32); i++)
1006                 ecore_wr(p_hwfn, p_ptt,
1007                          func_addr +
1008                          OFFSETOF(struct public_func, drv_ack_vf_disabled) +
1009                          i * sizeof(u32), 0);
1010
1011         return rc;
1012 }
1013
1014 static void ecore_mcp_handle_transceiver_change(struct ecore_hwfn *p_hwfn,
1015                                                 struct ecore_ptt *p_ptt)
1016 {
1017         u32 transceiver_state;
1018
1019         transceiver_state = ecore_rd(p_hwfn, p_ptt,
1020                                      p_hwfn->mcp_info->port_addr +
1021                                      OFFSETOF(struct public_port,
1022                                               transceiver_data));
1023
1024         DP_VERBOSE(p_hwfn, (ECORE_MSG_HW | ECORE_MSG_SP),
1025                    "Received transceiver state update [0x%08x] from mfw"
1026                    " [Addr 0x%x]\n",
1027                    transceiver_state, (u32)(p_hwfn->mcp_info->port_addr +
1028                                             OFFSETOF(struct public_port,
1029                                                      transceiver_data)));
1030
1031         transceiver_state = GET_FIELD(transceiver_state, ETH_TRANSCEIVER_STATE);
1032
1033         if (transceiver_state == ETH_TRANSCEIVER_STATE_PRESENT)
1034                 DP_NOTICE(p_hwfn, false, "Transceiver is present.\n");
1035         else
1036                 DP_NOTICE(p_hwfn, false, "Transceiver is unplugged.\n");
1037 }
1038
1039 static void ecore_mcp_handle_link_change(struct ecore_hwfn *p_hwfn,
1040                                          struct ecore_ptt *p_ptt,
1041                                          bool b_reset)
1042 {
1043         struct ecore_mcp_link_state *p_link;
1044         u8 max_bw, min_bw;
1045         u32 status = 0;
1046
1047         p_link = &p_hwfn->mcp_info->link_output;
1048         OSAL_MEMSET(p_link, 0, sizeof(*p_link));
1049         if (!b_reset) {
1050                 status = ecore_rd(p_hwfn, p_ptt,
1051                                   p_hwfn->mcp_info->port_addr +
1052                                   OFFSETOF(struct public_port, link_status));
1053                 DP_VERBOSE(p_hwfn, (ECORE_MSG_LINK | ECORE_MSG_SP),
1054                            "Received link update [0x%08x] from mfw"
1055                            " [Addr 0x%x]\n",
1056                            status, (u32)(p_hwfn->mcp_info->port_addr +
1057                                           OFFSETOF(struct public_port,
1058                                                    link_status)));
1059         } else {
1060                 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK,
1061                            "Resetting link indications\n");
1062                 return;
1063         }
1064
1065         if (p_hwfn->b_drv_link_init)
1066                 p_link->link_up = !!(status & LINK_STATUS_LINK_UP);
1067         else
1068                 p_link->link_up = false;
1069
1070         p_link->full_duplex = true;
1071         switch ((status & LINK_STATUS_SPEED_AND_DUPLEX_MASK)) {
1072         case LINK_STATUS_SPEED_AND_DUPLEX_100G:
1073                 p_link->speed = 100000;
1074                 break;
1075         case LINK_STATUS_SPEED_AND_DUPLEX_50G:
1076                 p_link->speed = 50000;
1077                 break;
1078         case LINK_STATUS_SPEED_AND_DUPLEX_40G:
1079                 p_link->speed = 40000;
1080                 break;
1081         case LINK_STATUS_SPEED_AND_DUPLEX_25G:
1082                 p_link->speed = 25000;
1083                 break;
1084         case LINK_STATUS_SPEED_AND_DUPLEX_20G:
1085                 p_link->speed = 20000;
1086                 break;
1087         case LINK_STATUS_SPEED_AND_DUPLEX_10G:
1088                 p_link->speed = 10000;
1089                 break;
1090         case LINK_STATUS_SPEED_AND_DUPLEX_1000THD:
1091                 p_link->full_duplex = false;
1092                 /* Fall-through */
1093         case LINK_STATUS_SPEED_AND_DUPLEX_1000TFD:
1094                 p_link->speed = 1000;
1095                 break;
1096         default:
1097                 p_link->speed = 0;
1098         }
1099
1100         /* We never store total line speed as p_link->speed is
1101          * again changes according to bandwidth allocation.
1102          */
1103         if (p_link->link_up && p_link->speed)
1104                 p_link->line_speed = p_link->speed;
1105         else
1106                 p_link->line_speed = 0;
1107
1108         max_bw = p_hwfn->mcp_info->func_info.bandwidth_max;
1109         min_bw = p_hwfn->mcp_info->func_info.bandwidth_min;
1110
1111         /* Max bandwidth configuration */
1112         __ecore_configure_pf_max_bandwidth(p_hwfn, p_ptt,
1113                                            p_link, max_bw);
1114
1115         /* Mintz bandwidth configuration */
1116         __ecore_configure_pf_min_bandwidth(p_hwfn, p_ptt,
1117                                            p_link, min_bw);
1118         ecore_configure_vp_wfq_on_link_change(p_hwfn->p_dev, p_ptt,
1119                                               p_link->min_pf_rate);
1120
1121         p_link->an = !!(status & LINK_STATUS_AUTO_NEGOTIATE_ENABLED);
1122         p_link->an_complete = !!(status & LINK_STATUS_AUTO_NEGOTIATE_COMPLETE);
1123         p_link->parallel_detection = !!(status &
1124                                          LINK_STATUS_PARALLEL_DETECTION_USED);
1125         p_link->pfc_enabled = !!(status & LINK_STATUS_PFC_ENABLED);
1126
1127         p_link->partner_adv_speed |=
1128             (status & LINK_STATUS_LINK_PARTNER_1000TFD_CAPABLE) ?
1129             ECORE_LINK_PARTNER_SPEED_1G_FD : 0;
1130         p_link->partner_adv_speed |=
1131             (status & LINK_STATUS_LINK_PARTNER_1000THD_CAPABLE) ?
1132             ECORE_LINK_PARTNER_SPEED_1G_HD : 0;
1133         p_link->partner_adv_speed |=
1134             (status & LINK_STATUS_LINK_PARTNER_10G_CAPABLE) ?
1135             ECORE_LINK_PARTNER_SPEED_10G : 0;
1136         p_link->partner_adv_speed |=
1137             (status & LINK_STATUS_LINK_PARTNER_20G_CAPABLE) ?
1138             ECORE_LINK_PARTNER_SPEED_20G : 0;
1139         p_link->partner_adv_speed |=
1140             (status & LINK_STATUS_LINK_PARTNER_25G_CAPABLE) ?
1141             ECORE_LINK_PARTNER_SPEED_25G : 0;
1142         p_link->partner_adv_speed |=
1143             (status & LINK_STATUS_LINK_PARTNER_40G_CAPABLE) ?
1144             ECORE_LINK_PARTNER_SPEED_40G : 0;
1145         p_link->partner_adv_speed |=
1146             (status & LINK_STATUS_LINK_PARTNER_50G_CAPABLE) ?
1147             ECORE_LINK_PARTNER_SPEED_50G : 0;
1148         p_link->partner_adv_speed |=
1149             (status & LINK_STATUS_LINK_PARTNER_100G_CAPABLE) ?
1150             ECORE_LINK_PARTNER_SPEED_100G : 0;
1151
1152         p_link->partner_tx_flow_ctrl_en =
1153             !!(status & LINK_STATUS_TX_FLOW_CONTROL_ENABLED);
1154         p_link->partner_rx_flow_ctrl_en =
1155             !!(status & LINK_STATUS_RX_FLOW_CONTROL_ENABLED);
1156
1157         switch (status & LINK_STATUS_LINK_PARTNER_FLOW_CONTROL_MASK) {
1158         case LINK_STATUS_LINK_PARTNER_SYMMETRIC_PAUSE:
1159                 p_link->partner_adv_pause = ECORE_LINK_PARTNER_SYMMETRIC_PAUSE;
1160                 break;
1161         case LINK_STATUS_LINK_PARTNER_ASYMMETRIC_PAUSE:
1162                 p_link->partner_adv_pause = ECORE_LINK_PARTNER_ASYMMETRIC_PAUSE;
1163                 break;
1164         case LINK_STATUS_LINK_PARTNER_BOTH_PAUSE:
1165                 p_link->partner_adv_pause = ECORE_LINK_PARTNER_BOTH_PAUSE;
1166                 break;
1167         default:
1168                 p_link->partner_adv_pause = 0;
1169         }
1170
1171         p_link->sfp_tx_fault = !!(status & LINK_STATUS_SFP_TX_FAULT);
1172
1173         OSAL_LINK_UPDATE(p_hwfn);
1174 }
1175
1176 enum _ecore_status_t ecore_mcp_set_link(struct ecore_hwfn *p_hwfn,
1177                                         struct ecore_ptt *p_ptt, bool b_up)
1178 {
1179         struct ecore_mcp_link_params *params = &p_hwfn->mcp_info->link_input;
1180         struct ecore_mcp_mb_params mb_params;
1181         struct eth_phy_cfg phy_cfg;
1182         enum _ecore_status_t rc = ECORE_SUCCESS;
1183         u32 cmd;
1184
1185 #ifndef ASIC_ONLY
1186         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev))
1187                 return ECORE_SUCCESS;
1188 #endif
1189
1190         /* Set the shmem configuration according to params */
1191         OSAL_MEM_ZERO(&phy_cfg, sizeof(phy_cfg));
1192         cmd = b_up ? DRV_MSG_CODE_INIT_PHY : DRV_MSG_CODE_LINK_RESET;
1193         if (!params->speed.autoneg)
1194                 phy_cfg.speed = params->speed.forced_speed;
1195         phy_cfg.pause |= (params->pause.autoneg) ? ETH_PAUSE_AUTONEG : 0;
1196         phy_cfg.pause |= (params->pause.forced_rx) ? ETH_PAUSE_RX : 0;
1197         phy_cfg.pause |= (params->pause.forced_tx) ? ETH_PAUSE_TX : 0;
1198         phy_cfg.adv_speed = params->speed.advertised_speeds;
1199         phy_cfg.loopback_mode = params->loopback_mode;
1200         p_hwfn->b_drv_link_init = b_up;
1201
1202         if (b_up)
1203                 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK,
1204                            "Configuring Link: Speed 0x%08x, Pause 0x%08x, adv_speed 0x%08x, loopback 0x%08x\n",
1205                            phy_cfg.speed, phy_cfg.pause, phy_cfg.adv_speed,
1206                            phy_cfg.loopback_mode);
1207         else
1208                 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK, "Resetting link\n");
1209
1210         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1211         mb_params.cmd = cmd;
1212         mb_params.p_data_src = &phy_cfg;
1213         mb_params.data_src_size = sizeof(phy_cfg);
1214         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1215
1216         /* if mcp fails to respond we must abort */
1217         if (rc != ECORE_SUCCESS) {
1218                 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
1219                 return rc;
1220         }
1221
1222         /* Reset the link status if needed */
1223         if (!b_up)
1224                 ecore_mcp_handle_link_change(p_hwfn, p_ptt, true);
1225
1226         return rc;
1227 }
1228
1229 u32 ecore_get_process_kill_counter(struct ecore_hwfn *p_hwfn,
1230                                    struct ecore_ptt *p_ptt)
1231 {
1232         u32 path_offsize_addr, path_offsize, path_addr, proc_kill_cnt;
1233
1234         /* TODO - Add support for VFs */
1235         if (IS_VF(p_hwfn->p_dev))
1236                 return ECORE_INVAL;
1237
1238         path_offsize_addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1239                                                  PUBLIC_PATH);
1240         path_offsize = ecore_rd(p_hwfn, p_ptt, path_offsize_addr);
1241         path_addr = SECTION_ADDR(path_offsize, ECORE_PATH_ID(p_hwfn));
1242
1243         proc_kill_cnt = ecore_rd(p_hwfn, p_ptt,
1244                                  path_addr +
1245                                  OFFSETOF(struct public_path, process_kill)) &
1246             PROCESS_KILL_COUNTER_MASK;
1247
1248         return proc_kill_cnt;
1249 }
1250
1251 static void ecore_mcp_handle_process_kill(struct ecore_hwfn *p_hwfn,
1252                                           struct ecore_ptt *p_ptt)
1253 {
1254         struct ecore_dev *p_dev = p_hwfn->p_dev;
1255         u32 proc_kill_cnt;
1256
1257         /* Prevent possible attentions/interrupts during the recovery handling
1258          * and till its load phase, during which they will be re-enabled.
1259          */
1260         ecore_int_igu_disable_int(p_hwfn, p_ptt);
1261
1262         DP_NOTICE(p_hwfn, false, "Received a process kill indication\n");
1263
1264         /* The following operations should be done once, and thus in CMT mode
1265          * are carried out by only the first HW function.
1266          */
1267         if (p_hwfn != ECORE_LEADING_HWFN(p_dev))
1268                 return;
1269
1270         if (p_dev->recov_in_prog) {
1271                 DP_NOTICE(p_hwfn, false,
1272                           "Ignoring the indication since a recovery"
1273                           " process is already in progress\n");
1274                 return;
1275         }
1276
1277         p_dev->recov_in_prog = true;
1278
1279         proc_kill_cnt = ecore_get_process_kill_counter(p_hwfn, p_ptt);
1280         DP_NOTICE(p_hwfn, false, "Process kill counter: %d\n", proc_kill_cnt);
1281
1282         OSAL_SCHEDULE_RECOVERY_HANDLER(p_hwfn);
1283 }
1284
1285 static void ecore_mcp_send_protocol_stats(struct ecore_hwfn *p_hwfn,
1286                                           struct ecore_ptt *p_ptt,
1287                                           enum MFW_DRV_MSG_TYPE type)
1288 {
1289         enum ecore_mcp_protocol_type stats_type;
1290         union ecore_mcp_protocol_stats stats;
1291         struct ecore_mcp_mb_params mb_params;
1292         u32 hsi_param;
1293         enum _ecore_status_t rc;
1294
1295         switch (type) {
1296         case MFW_DRV_MSG_GET_LAN_STATS:
1297                 stats_type = ECORE_MCP_LAN_STATS;
1298                 hsi_param = DRV_MSG_CODE_STATS_TYPE_LAN;
1299                 break;
1300         default:
1301                 DP_INFO(p_hwfn, "Invalid protocol type %d\n", type);
1302                 return;
1303         }
1304
1305         OSAL_GET_PROTOCOL_STATS(p_hwfn->p_dev, stats_type, &stats);
1306
1307         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1308         mb_params.cmd = DRV_MSG_CODE_GET_STATS;
1309         mb_params.param = hsi_param;
1310         mb_params.p_data_src = &stats;
1311         mb_params.data_src_size = sizeof(stats);
1312         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1313         if (rc != ECORE_SUCCESS)
1314                 DP_ERR(p_hwfn, "Failed to send protocol stats, rc = %d\n", rc);
1315 }
1316
1317 static void ecore_read_pf_bandwidth(struct ecore_hwfn *p_hwfn,
1318                                     struct public_func *p_shmem_info)
1319 {
1320         struct ecore_mcp_function_info *p_info;
1321
1322         p_info = &p_hwfn->mcp_info->func_info;
1323
1324         /* TODO - bandwidth min/max should have valid values of 1-100,
1325          * as well as some indication that the feature is disabled.
1326          * Until MFW/qlediag enforce those limitations, Assume THERE IS ALWAYS
1327          * limit and correct value to min `1' and max `100' if limit isn't in
1328          * range.
1329          */
1330         p_info->bandwidth_min = (p_shmem_info->config &
1331                                  FUNC_MF_CFG_MIN_BW_MASK) >>
1332             FUNC_MF_CFG_MIN_BW_SHIFT;
1333         if (p_info->bandwidth_min < 1 || p_info->bandwidth_min > 100) {
1334                 DP_INFO(p_hwfn,
1335                         "bandwidth minimum out of bounds [%02x]. Set to 1\n",
1336                         p_info->bandwidth_min);
1337                 p_info->bandwidth_min = 1;
1338         }
1339
1340         p_info->bandwidth_max = (p_shmem_info->config &
1341                                  FUNC_MF_CFG_MAX_BW_MASK) >>
1342             FUNC_MF_CFG_MAX_BW_SHIFT;
1343         if (p_info->bandwidth_max < 1 || p_info->bandwidth_max > 100) {
1344                 DP_INFO(p_hwfn,
1345                         "bandwidth maximum out of bounds [%02x]. Set to 100\n",
1346                         p_info->bandwidth_max);
1347                 p_info->bandwidth_max = 100;
1348         }
1349 }
1350
1351 static u32 ecore_mcp_get_shmem_func(struct ecore_hwfn *p_hwfn,
1352                                     struct ecore_ptt *p_ptt,
1353                                     struct public_func *p_data,
1354                                     int pfid)
1355 {
1356         u32 addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1357                                         PUBLIC_FUNC);
1358         u32 mfw_path_offsize = ecore_rd(p_hwfn, p_ptt, addr);
1359         u32 func_addr = SECTION_ADDR(mfw_path_offsize, pfid);
1360         u32 i, size;
1361
1362         OSAL_MEM_ZERO(p_data, sizeof(*p_data));
1363
1364         size = OSAL_MIN_T(u32, sizeof(*p_data),
1365                           SECTION_SIZE(mfw_path_offsize));
1366         for (i = 0; i < size / sizeof(u32); i++)
1367                 ((u32 *)p_data)[i] = ecore_rd(p_hwfn, p_ptt,
1368                                               func_addr + (i << 2));
1369
1370         return size;
1371 }
1372
1373 static void
1374 ecore_mcp_update_bw(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt)
1375 {
1376         struct ecore_mcp_function_info *p_info;
1377         struct public_func shmem_info;
1378         u32 resp = 0, param = 0;
1379
1380         ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info, MCP_PF_ID(p_hwfn));
1381
1382         ecore_read_pf_bandwidth(p_hwfn, &shmem_info);
1383
1384         p_info = &p_hwfn->mcp_info->func_info;
1385
1386         ecore_configure_pf_min_bandwidth(p_hwfn->p_dev, p_info->bandwidth_min);
1387
1388         ecore_configure_pf_max_bandwidth(p_hwfn->p_dev, p_info->bandwidth_max);
1389
1390         /* Acknowledge the MFW */
1391         ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BW_UPDATE_ACK, 0, &resp,
1392                       &param);
1393 }
1394
1395 static void ecore_mcp_handle_fan_failure(struct ecore_hwfn *p_hwfn,
1396                                          struct ecore_ptt *p_ptt)
1397 {
1398         /* A single notification should be sent to upper driver in CMT mode */
1399         if (p_hwfn != ECORE_LEADING_HWFN(p_hwfn->p_dev))
1400                 return;
1401
1402         DP_NOTICE(p_hwfn, false,
1403                   "Fan failure was detected on the network interface card"
1404                   " and it's going to be shut down.\n");
1405
1406         ecore_hw_err_notify(p_hwfn, ECORE_HW_ERR_FAN_FAIL);
1407 }
1408
1409 struct ecore_mdump_cmd_params {
1410         u32 cmd;
1411         void *p_data_src;
1412         u8 data_src_size;
1413         void *p_data_dst;
1414         u8 data_dst_size;
1415         u32 mcp_resp;
1416 };
1417
1418 static enum _ecore_status_t
1419 ecore_mcp_mdump_cmd(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
1420                     struct ecore_mdump_cmd_params *p_mdump_cmd_params)
1421 {
1422         struct ecore_mcp_mb_params mb_params;
1423         enum _ecore_status_t rc;
1424
1425         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
1426         mb_params.cmd = DRV_MSG_CODE_MDUMP_CMD;
1427         mb_params.param = p_mdump_cmd_params->cmd;
1428         mb_params.p_data_src = p_mdump_cmd_params->p_data_src;
1429         mb_params.data_src_size = p_mdump_cmd_params->data_src_size;
1430         mb_params.p_data_dst = p_mdump_cmd_params->p_data_dst;
1431         mb_params.data_dst_size = p_mdump_cmd_params->data_dst_size;
1432         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1433         if (rc != ECORE_SUCCESS)
1434                 return rc;
1435
1436         p_mdump_cmd_params->mcp_resp = mb_params.mcp_resp;
1437         if (p_mdump_cmd_params->mcp_resp == FW_MSG_CODE_MDUMP_INVALID_CMD) {
1438                 DP_NOTICE(p_hwfn, false,
1439                           "MFW claims that the mdump command is illegal [mdump_cmd 0x%x]\n",
1440                           p_mdump_cmd_params->cmd);
1441                 rc = ECORE_INVAL;
1442         }
1443
1444         return rc;
1445 }
1446
1447 static enum _ecore_status_t ecore_mcp_mdump_ack(struct ecore_hwfn *p_hwfn,
1448                                                 struct ecore_ptt *p_ptt)
1449 {
1450         struct ecore_mdump_cmd_params mdump_cmd_params;
1451
1452         OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1453         mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_ACK;
1454
1455         return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1456 }
1457
1458 enum _ecore_status_t ecore_mcp_mdump_set_values(struct ecore_hwfn *p_hwfn,
1459                                                 struct ecore_ptt *p_ptt,
1460                                                 u32 epoch)
1461 {
1462         struct ecore_mdump_cmd_params mdump_cmd_params;
1463
1464         OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1465         mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_SET_VALUES;
1466         mdump_cmd_params.p_data_src = &epoch;
1467         mdump_cmd_params.data_src_size = sizeof(epoch);
1468
1469         return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1470 }
1471
1472 enum _ecore_status_t ecore_mcp_mdump_trigger(struct ecore_hwfn *p_hwfn,
1473                                              struct ecore_ptt *p_ptt)
1474 {
1475         struct ecore_mdump_cmd_params mdump_cmd_params;
1476
1477         OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1478         mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_TRIGGER;
1479
1480         return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1481 }
1482
1483 static enum _ecore_status_t
1484 ecore_mcp_mdump_get_config(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
1485                            struct mdump_config_stc *p_mdump_config)
1486 {
1487         struct ecore_mdump_cmd_params mdump_cmd_params;
1488         enum _ecore_status_t rc;
1489
1490         OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1491         mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_GET_CONFIG;
1492         mdump_cmd_params.p_data_dst = p_mdump_config;
1493         mdump_cmd_params.data_dst_size = sizeof(*p_mdump_config);
1494
1495         rc = ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1496         if (rc != ECORE_SUCCESS)
1497                 return rc;
1498
1499         if (mdump_cmd_params.mcp_resp == FW_MSG_CODE_UNSUPPORTED) {
1500                 DP_INFO(p_hwfn,
1501                         "The mdump command is not supported by the MFW\n");
1502                 return ECORE_NOTIMPL;
1503         }
1504
1505         if (mdump_cmd_params.mcp_resp != FW_MSG_CODE_OK) {
1506                 DP_NOTICE(p_hwfn, false,
1507                           "Failed to get the mdump configuration and logs info [mcp_resp 0x%x]\n",
1508                           mdump_cmd_params.mcp_resp);
1509                 rc = ECORE_UNKNOWN_ERROR;
1510         }
1511
1512         return rc;
1513 }
1514
1515 enum _ecore_status_t
1516 ecore_mcp_mdump_get_info(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
1517                          struct ecore_mdump_info *p_mdump_info)
1518 {
1519         u32 addr, global_offsize, global_addr;
1520         struct mdump_config_stc mdump_config;
1521         enum _ecore_status_t rc;
1522
1523         OSAL_MEMSET(p_mdump_info, 0, sizeof(*p_mdump_info));
1524
1525         addr = SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->public_base,
1526                                     PUBLIC_GLOBAL);
1527         global_offsize = ecore_rd(p_hwfn, p_ptt, addr);
1528         global_addr = SECTION_ADDR(global_offsize, 0);
1529         p_mdump_info->reason = ecore_rd(p_hwfn, p_ptt,
1530                                         global_addr +
1531                                         OFFSETOF(struct public_global,
1532                                                  mdump_reason));
1533
1534         if (p_mdump_info->reason) {
1535                 rc = ecore_mcp_mdump_get_config(p_hwfn, p_ptt, &mdump_config);
1536                 if (rc != ECORE_SUCCESS)
1537                         return rc;
1538
1539                 p_mdump_info->version = mdump_config.version;
1540                 p_mdump_info->config = mdump_config.config;
1541                 p_mdump_info->epoch = mdump_config.epoc;
1542                 p_mdump_info->num_of_logs = mdump_config.num_of_logs;
1543                 p_mdump_info->valid_logs = mdump_config.valid_logs;
1544
1545                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1546                            "MFW mdump info: reason %d, version 0x%x, config 0x%x, epoch 0x%x, num_of_logs 0x%x, valid_logs 0x%x\n",
1547                            p_mdump_info->reason, p_mdump_info->version,
1548                            p_mdump_info->config, p_mdump_info->epoch,
1549                            p_mdump_info->num_of_logs, p_mdump_info->valid_logs);
1550         } else {
1551                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1552                            "MFW mdump info: reason %d\n", p_mdump_info->reason);
1553         }
1554
1555         return ECORE_SUCCESS;
1556 }
1557
1558 enum _ecore_status_t ecore_mcp_mdump_clear_logs(struct ecore_hwfn *p_hwfn,
1559                                                 struct ecore_ptt *p_ptt)
1560 {
1561         struct ecore_mdump_cmd_params mdump_cmd_params;
1562
1563         OSAL_MEM_ZERO(&mdump_cmd_params, sizeof(mdump_cmd_params));
1564         mdump_cmd_params.cmd = DRV_MSG_CODE_MDUMP_CLEAR_LOGS;
1565
1566         return ecore_mcp_mdump_cmd(p_hwfn, p_ptt, &mdump_cmd_params);
1567 }
1568
1569 static void ecore_mcp_handle_critical_error(struct ecore_hwfn *p_hwfn,
1570                                             struct ecore_ptt *p_ptt)
1571 {
1572         /* In CMT mode - no need for more than a single acknowledgment to the
1573          * MFW, and no more than a single notification to the upper driver.
1574          */
1575         if (p_hwfn != ECORE_LEADING_HWFN(p_hwfn->p_dev))
1576                 return;
1577
1578         DP_NOTICE(p_hwfn, false,
1579                   "Received a critical error notification from the MFW!\n");
1580
1581         if (p_hwfn->p_dev->allow_mdump) {
1582                 DP_NOTICE(p_hwfn, false,
1583                           "Not acknowledging the notification to allow the MFW crash dump\n");
1584                 return;
1585         }
1586
1587         ecore_mcp_mdump_ack(p_hwfn, p_ptt);
1588         ecore_hw_err_notify(p_hwfn, ECORE_HW_ERR_HW_ATTN);
1589 }
1590
1591 enum _ecore_status_t ecore_mcp_handle_events(struct ecore_hwfn *p_hwfn,
1592                                              struct ecore_ptt *p_ptt)
1593 {
1594         struct ecore_mcp_info *info = p_hwfn->mcp_info;
1595         enum _ecore_status_t rc = ECORE_SUCCESS;
1596         bool found = false;
1597         u16 i;
1598
1599         DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "Received message from MFW\n");
1600
1601         /* Read Messages from MFW */
1602         ecore_mcp_read_mb(p_hwfn, p_ptt);
1603
1604         /* Compare current messages to old ones */
1605         for (i = 0; i < info->mfw_mb_length; i++) {
1606                 if (info->mfw_mb_cur[i] == info->mfw_mb_shadow[i])
1607                         continue;
1608
1609                 found = true;
1610
1611                 DP_VERBOSE(p_hwfn, ECORE_MSG_LINK,
1612                            "Msg [%d] - old CMD 0x%02x, new CMD 0x%02x\n",
1613                            i, info->mfw_mb_shadow[i], info->mfw_mb_cur[i]);
1614
1615                 switch (i) {
1616                 case MFW_DRV_MSG_LINK_CHANGE:
1617                         ecore_mcp_handle_link_change(p_hwfn, p_ptt, false);
1618                         break;
1619                 case MFW_DRV_MSG_VF_DISABLED:
1620                         ecore_mcp_handle_vf_flr(p_hwfn, p_ptt);
1621                         break;
1622                 case MFW_DRV_MSG_LLDP_DATA_UPDATED:
1623                         ecore_dcbx_mib_update_event(p_hwfn, p_ptt,
1624                                                     ECORE_DCBX_REMOTE_LLDP_MIB);
1625                         break;
1626                 case MFW_DRV_MSG_DCBX_REMOTE_MIB_UPDATED:
1627                         ecore_dcbx_mib_update_event(p_hwfn, p_ptt,
1628                                                     ECORE_DCBX_REMOTE_MIB);
1629                         break;
1630                 case MFW_DRV_MSG_DCBX_OPERATIONAL_MIB_UPDATED:
1631                         ecore_dcbx_mib_update_event(p_hwfn, p_ptt,
1632                                                     ECORE_DCBX_OPERATIONAL_MIB);
1633                         break;
1634                 case MFW_DRV_MSG_TRANSCEIVER_STATE_CHANGE:
1635                         ecore_mcp_handle_transceiver_change(p_hwfn, p_ptt);
1636                         break;
1637                 case MFW_DRV_MSG_ERROR_RECOVERY:
1638                         ecore_mcp_handle_process_kill(p_hwfn, p_ptt);
1639                         break;
1640                 case MFW_DRV_MSG_GET_LAN_STATS:
1641                 case MFW_DRV_MSG_GET_FCOE_STATS:
1642                 case MFW_DRV_MSG_GET_ISCSI_STATS:
1643                 case MFW_DRV_MSG_GET_RDMA_STATS:
1644                         ecore_mcp_send_protocol_stats(p_hwfn, p_ptt, i);
1645                         break;
1646                 case MFW_DRV_MSG_BW_UPDATE:
1647                         ecore_mcp_update_bw(p_hwfn, p_ptt);
1648                         break;
1649                 case MFW_DRV_MSG_FAILURE_DETECTED:
1650                         ecore_mcp_handle_fan_failure(p_hwfn, p_ptt);
1651                         break;
1652                 case MFW_DRV_MSG_CRITICAL_ERROR_OCCURRED:
1653                         ecore_mcp_handle_critical_error(p_hwfn, p_ptt);
1654                         break;
1655                 default:
1656                         DP_INFO(p_hwfn, "Unimplemented MFW message %d\n", i);
1657                         rc = ECORE_INVAL;
1658                 }
1659         }
1660
1661         /* ACK everything */
1662         for (i = 0; i < MFW_DRV_MSG_MAX_DWORDS(info->mfw_mb_length); i++) {
1663                 OSAL_BE32 val = OSAL_CPU_TO_BE32(((u32 *)info->mfw_mb_cur)[i]);
1664
1665                 /* MFW expect answer in BE, so we force write in that format */
1666                 ecore_wr(p_hwfn, p_ptt,
1667                          info->mfw_mb_addr + sizeof(u32) +
1668                          MFW_DRV_MSG_MAX_DWORDS(info->mfw_mb_length) *
1669                          sizeof(u32) + i * sizeof(u32), val);
1670         }
1671
1672         if (!found) {
1673                 DP_NOTICE(p_hwfn, false,
1674                           "Received an MFW message indication but no"
1675                           " new message!\n");
1676                 rc = ECORE_INVAL;
1677         }
1678
1679         /* Copy the new mfw messages into the shadow */
1680         OSAL_MEMCPY(info->mfw_mb_shadow, info->mfw_mb_cur, info->mfw_mb_length);
1681
1682         return rc;
1683 }
1684
1685 enum _ecore_status_t ecore_mcp_get_mfw_ver(struct ecore_hwfn *p_hwfn,
1686                                            struct ecore_ptt *p_ptt,
1687                                            u32 *p_mfw_ver,
1688                                            u32 *p_running_bundle_id)
1689 {
1690         u32 global_offsize;
1691
1692 #ifndef ASIC_ONLY
1693         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
1694                 DP_NOTICE(p_hwfn, false, "Emulation - can't get MFW version\n");
1695                 return ECORE_SUCCESS;
1696         }
1697 #endif
1698
1699         if (IS_VF(p_hwfn->p_dev)) {
1700                 if (p_hwfn->vf_iov_info) {
1701                         struct pfvf_acquire_resp_tlv *p_resp;
1702
1703                         p_resp = &p_hwfn->vf_iov_info->acquire_resp;
1704                         *p_mfw_ver = p_resp->pfdev_info.mfw_ver;
1705                         return ECORE_SUCCESS;
1706                 } else {
1707                         DP_VERBOSE(p_hwfn, ECORE_MSG_IOV,
1708                                    "VF requested MFW version prior to ACQUIRE\n");
1709                         return ECORE_INVAL;
1710                 }
1711         }
1712
1713         global_offsize = ecore_rd(p_hwfn, p_ptt,
1714                                   SECTION_OFFSIZE_ADDR(p_hwfn->mcp_info->
1715                                                        public_base,
1716                                                        PUBLIC_GLOBAL));
1717         *p_mfw_ver =
1718             ecore_rd(p_hwfn, p_ptt,
1719                      SECTION_ADDR(global_offsize,
1720                                   0) + OFFSETOF(struct public_global, mfw_ver));
1721
1722         if (p_running_bundle_id != OSAL_NULL) {
1723                 *p_running_bundle_id = ecore_rd(p_hwfn, p_ptt,
1724                                                 SECTION_ADDR(global_offsize,
1725                                                              0) +
1726                                                 OFFSETOF(struct public_global,
1727                                                          running_bundle_id));
1728         }
1729
1730         return ECORE_SUCCESS;
1731 }
1732
1733 enum _ecore_status_t ecore_mcp_get_media_type(struct ecore_dev *p_dev,
1734                                               u32 *p_media_type)
1735 {
1736         struct ecore_hwfn *p_hwfn = &p_dev->hwfns[0];
1737         struct ecore_ptt *p_ptt;
1738
1739         /* TODO - Add support for VFs */
1740         if (IS_VF(p_dev))
1741                 return ECORE_INVAL;
1742
1743         if (!ecore_mcp_is_init(p_hwfn)) {
1744                 DP_NOTICE(p_hwfn, true, "MFW is not initialized !\n");
1745                 return ECORE_BUSY;
1746         }
1747
1748         *p_media_type = MEDIA_UNSPECIFIED;
1749
1750         p_ptt = ecore_ptt_acquire(p_hwfn);
1751         if (!p_ptt)
1752                 return ECORE_BUSY;
1753
1754         *p_media_type = ecore_rd(p_hwfn, p_ptt, p_hwfn->mcp_info->port_addr +
1755                                  OFFSETOF(struct public_port, media_type));
1756
1757         ecore_ptt_release(p_hwfn, p_ptt);
1758
1759         return ECORE_SUCCESS;
1760 }
1761
1762 /* @DPDK */
1763 /* Old MFW has a global configuration for all PFs regarding RDMA support */
1764 static void
1765 ecore_mcp_get_shmem_proto_legacy(struct ecore_hwfn *p_hwfn,
1766                                  enum ecore_pci_personality *p_proto)
1767 {
1768         *p_proto = ECORE_PCI_ETH;
1769
1770         DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
1771                    "According to Legacy capabilities, L2 personality is %08x\n",
1772                    (u32)*p_proto);
1773 }
1774
1775 /* @DPDK */
1776 static enum _ecore_status_t
1777 ecore_mcp_get_shmem_proto_mfw(struct ecore_hwfn *p_hwfn,
1778                               struct ecore_ptt *p_ptt,
1779                               enum ecore_pci_personality *p_proto)
1780 {
1781         u32 resp = 0, param = 0;
1782         enum _ecore_status_t rc;
1783
1784         DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
1785                    "According to capabilities, L2 personality is %08x [resp %08x param %08x]\n",
1786                    (u32)*p_proto, resp, param);
1787         return ECORE_SUCCESS;
1788 }
1789
1790 static enum _ecore_status_t
1791 ecore_mcp_get_shmem_proto(struct ecore_hwfn *p_hwfn,
1792                           struct public_func *p_info,
1793                           struct ecore_ptt *p_ptt,
1794                           enum ecore_pci_personality *p_proto)
1795 {
1796         enum _ecore_status_t rc = ECORE_SUCCESS;
1797
1798         switch (p_info->config & FUNC_MF_CFG_PROTOCOL_MASK) {
1799         case FUNC_MF_CFG_PROTOCOL_ETHERNET:
1800                 if (ecore_mcp_get_shmem_proto_mfw(p_hwfn, p_ptt, p_proto) !=
1801                     ECORE_SUCCESS)
1802                         ecore_mcp_get_shmem_proto_legacy(p_hwfn, p_proto);
1803                 break;
1804         default:
1805                 rc = ECORE_INVAL;
1806         }
1807
1808         return rc;
1809 }
1810
1811 enum _ecore_status_t ecore_mcp_fill_shmem_func_info(struct ecore_hwfn *p_hwfn,
1812                                                     struct ecore_ptt *p_ptt)
1813 {
1814         struct ecore_mcp_function_info *info;
1815         struct public_func shmem_info;
1816
1817         ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info, MCP_PF_ID(p_hwfn));
1818         info = &p_hwfn->mcp_info->func_info;
1819
1820         info->pause_on_host = (shmem_info.config &
1821                                FUNC_MF_CFG_PAUSE_ON_HOST_RING) ? 1 : 0;
1822
1823         if (ecore_mcp_get_shmem_proto(p_hwfn, &shmem_info, p_ptt,
1824                                       &info->protocol)) {
1825                 DP_ERR(p_hwfn, "Unknown personality %08x\n",
1826                        (u32)(shmem_info.config & FUNC_MF_CFG_PROTOCOL_MASK));
1827                 return ECORE_INVAL;
1828         }
1829
1830         ecore_read_pf_bandwidth(p_hwfn, &shmem_info);
1831
1832         if (shmem_info.mac_upper || shmem_info.mac_lower) {
1833                 info->mac[0] = (u8)(shmem_info.mac_upper >> 8);
1834                 info->mac[1] = (u8)(shmem_info.mac_upper);
1835                 info->mac[2] = (u8)(shmem_info.mac_lower >> 24);
1836                 info->mac[3] = (u8)(shmem_info.mac_lower >> 16);
1837                 info->mac[4] = (u8)(shmem_info.mac_lower >> 8);
1838                 info->mac[5] = (u8)(shmem_info.mac_lower);
1839         } else {
1840                 /* TODO - are there protocols for which there's no MAC? */
1841                 DP_NOTICE(p_hwfn, false, "MAC is 0 in shmem\n");
1842         }
1843
1844         /* TODO - are these calculations true for BE machine? */
1845         info->wwn_port = (u64)shmem_info.fcoe_wwn_port_name_upper |
1846                          (((u64)shmem_info.fcoe_wwn_port_name_lower) << 32);
1847         info->wwn_node = (u64)shmem_info.fcoe_wwn_node_name_upper |
1848                          (((u64)shmem_info.fcoe_wwn_node_name_lower) << 32);
1849
1850         info->ovlan = (u16)(shmem_info.ovlan_stag & FUNC_MF_CFG_OV_STAG_MASK);
1851
1852         info->mtu = (u16)shmem_info.mtu_size;
1853
1854         if (info->mtu == 0)
1855                 info->mtu = 1500;
1856
1857         info->mtu = (u16)shmem_info.mtu_size;
1858
1859         DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_IFUP),
1860                    "Read configuration from shmem: pause_on_host %02x"
1861                     " protocol %02x BW [%02x - %02x]"
1862                     " MAC %02x:%02x:%02x:%02x:%02x:%02x wwn port %lx"
1863                     " node %lx ovlan %04x\n",
1864                    info->pause_on_host, info->protocol,
1865                    info->bandwidth_min, info->bandwidth_max,
1866                    info->mac[0], info->mac[1], info->mac[2],
1867                    info->mac[3], info->mac[4], info->mac[5],
1868                    (unsigned long)info->wwn_port,
1869                    (unsigned long)info->wwn_node, info->ovlan);
1870
1871         return ECORE_SUCCESS;
1872 }
1873
1874 struct ecore_mcp_link_params
1875 *ecore_mcp_get_link_params(struct ecore_hwfn *p_hwfn)
1876 {
1877         if (!p_hwfn || !p_hwfn->mcp_info)
1878                 return OSAL_NULL;
1879         return &p_hwfn->mcp_info->link_input;
1880 }
1881
1882 struct ecore_mcp_link_state
1883 *ecore_mcp_get_link_state(struct ecore_hwfn *p_hwfn)
1884 {
1885         if (!p_hwfn || !p_hwfn->mcp_info)
1886                 return OSAL_NULL;
1887
1888 #ifndef ASIC_ONLY
1889         if (CHIP_REV_IS_SLOW(p_hwfn->p_dev)) {
1890                 DP_INFO(p_hwfn, "Non-ASIC - always notify that link is up\n");
1891                 p_hwfn->mcp_info->link_output.link_up = true;
1892         }
1893 #endif
1894
1895         return &p_hwfn->mcp_info->link_output;
1896 }
1897
1898 struct ecore_mcp_link_capabilities
1899 *ecore_mcp_get_link_capabilities(struct ecore_hwfn *p_hwfn)
1900 {
1901         if (!p_hwfn || !p_hwfn->mcp_info)
1902                 return OSAL_NULL;
1903         return &p_hwfn->mcp_info->link_capabilities;
1904 }
1905
1906 enum _ecore_status_t ecore_mcp_drain(struct ecore_hwfn *p_hwfn,
1907                                      struct ecore_ptt *p_ptt)
1908 {
1909         u32 resp = 0, param = 0;
1910         enum _ecore_status_t rc;
1911
1912         rc = ecore_mcp_cmd(p_hwfn, p_ptt,
1913                            DRV_MSG_CODE_NIG_DRAIN, 1000, &resp, &param);
1914
1915         /* Wait for the drain to complete before returning */
1916         OSAL_MSLEEP(1020);
1917
1918         return rc;
1919 }
1920
1921 const struct ecore_mcp_function_info
1922 *ecore_mcp_get_function_info(struct ecore_hwfn *p_hwfn)
1923 {
1924         if (!p_hwfn || !p_hwfn->mcp_info)
1925                 return OSAL_NULL;
1926         return &p_hwfn->mcp_info->func_info;
1927 }
1928
1929 enum _ecore_status_t ecore_mcp_nvm_command(struct ecore_hwfn *p_hwfn,
1930                                            struct ecore_ptt *p_ptt,
1931                                            struct ecore_mcp_nvm_params *params)
1932 {
1933         enum _ecore_status_t rc;
1934
1935         switch (params->type) {
1936         case ECORE_MCP_NVM_RD:
1937                 rc = ecore_mcp_nvm_rd_cmd(p_hwfn, p_ptt, params->nvm_common.cmd,
1938                                           params->nvm_common.offset,
1939                                           &params->nvm_common.resp,
1940                                           &params->nvm_common.param,
1941                                           params->nvm_rd.buf_size,
1942                                           params->nvm_rd.buf);
1943                 break;
1944         case ECORE_MCP_CMD:
1945                 rc = ecore_mcp_cmd(p_hwfn, p_ptt, params->nvm_common.cmd,
1946                                    params->nvm_common.offset,
1947                                    &params->nvm_common.resp,
1948                                    &params->nvm_common.param);
1949                 break;
1950         case ECORE_MCP_NVM_WR:
1951                 rc = ecore_mcp_nvm_wr_cmd(p_hwfn, p_ptt, params->nvm_common.cmd,
1952                                           params->nvm_common.offset,
1953                                           &params->nvm_common.resp,
1954                                           &params->nvm_common.param,
1955                                           params->nvm_wr.buf_size,
1956                                           params->nvm_wr.buf);
1957                 break;
1958         default:
1959                 rc = ECORE_NOTIMPL;
1960                 break;
1961         }
1962         return rc;
1963 }
1964
1965 int ecore_mcp_get_personality_cnt(struct ecore_hwfn *p_hwfn,
1966                                   struct ecore_ptt *p_ptt, u32 personalities)
1967 {
1968         enum ecore_pci_personality protocol = ECORE_PCI_DEFAULT;
1969         struct public_func shmem_info;
1970         int i, count = 0, num_pfs;
1971
1972         num_pfs = NUM_OF_ENG_PFS(p_hwfn->p_dev);
1973
1974         for (i = 0; i < num_pfs; i++) {
1975                 ecore_mcp_get_shmem_func(p_hwfn, p_ptt, &shmem_info,
1976                                          MCP_PF_ID_BY_REL(p_hwfn, i));
1977                 if (shmem_info.config & FUNC_MF_CFG_FUNC_HIDE)
1978                         continue;
1979
1980                 if (ecore_mcp_get_shmem_proto(p_hwfn, &shmem_info, p_ptt,
1981                                               &protocol) !=
1982                     ECORE_SUCCESS)
1983                         continue;
1984
1985                 if ((1 << ((u32)protocol)) & personalities)
1986                         count++;
1987         }
1988
1989         return count;
1990 }
1991
1992 enum _ecore_status_t ecore_mcp_get_flash_size(struct ecore_hwfn *p_hwfn,
1993                                               struct ecore_ptt *p_ptt,
1994                                               u32 *p_flash_size)
1995 {
1996         u32 flash_size;
1997
1998 #ifndef ASIC_ONLY
1999         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev)) {
2000                 DP_NOTICE(p_hwfn, false, "Emulation - can't get flash size\n");
2001                 return ECORE_INVAL;
2002         }
2003 #endif
2004
2005         if (IS_VF(p_hwfn->p_dev))
2006                 return ECORE_INVAL;
2007
2008         flash_size = ecore_rd(p_hwfn, p_ptt, MCP_REG_NVM_CFG4);
2009         flash_size = (flash_size & MCP_REG_NVM_CFG4_FLASH_SIZE) >>
2010             MCP_REG_NVM_CFG4_FLASH_SIZE_SHIFT;
2011         flash_size = (1 << (flash_size + MCP_BYTES_PER_MBIT_SHIFT));
2012
2013         *p_flash_size = flash_size;
2014
2015         return ECORE_SUCCESS;
2016 }
2017
2018 enum _ecore_status_t ecore_start_recovery_process(struct ecore_hwfn *p_hwfn,
2019                                                   struct ecore_ptt *p_ptt)
2020 {
2021         struct ecore_dev *p_dev = p_hwfn->p_dev;
2022
2023         if (p_dev->recov_in_prog) {
2024                 DP_NOTICE(p_hwfn, false,
2025                           "Avoid triggering a recovery since such a process"
2026                           " is already in progress\n");
2027                 return ECORE_AGAIN;
2028         }
2029
2030         DP_NOTICE(p_hwfn, false, "Triggering a recovery process\n");
2031         ecore_wr(p_hwfn, p_ptt, MISC_REG_AEU_GENERAL_ATTN_35, 0x1);
2032
2033         return ECORE_SUCCESS;
2034 }
2035
2036 enum _ecore_status_t ecore_mcp_config_vf_msix(struct ecore_hwfn *p_hwfn,
2037                                               struct ecore_ptt *p_ptt,
2038                                               u8 vf_id, u8 num)
2039 {
2040         u32 resp = 0, param = 0, rc_param = 0;
2041         enum _ecore_status_t rc;
2042
2043 /* Only Leader can configure MSIX, and need to take CMT into account */
2044
2045         if (!IS_LEAD_HWFN(p_hwfn))
2046                 return ECORE_SUCCESS;
2047         num *= p_hwfn->p_dev->num_hwfns;
2048
2049         param |= (vf_id << DRV_MB_PARAM_CFG_VF_MSIX_VF_ID_SHIFT) &
2050             DRV_MB_PARAM_CFG_VF_MSIX_VF_ID_MASK;
2051         param |= (num << DRV_MB_PARAM_CFG_VF_MSIX_SB_NUM_SHIFT) &
2052             DRV_MB_PARAM_CFG_VF_MSIX_SB_NUM_MASK;
2053
2054         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_CFG_VF_MSIX, param,
2055                            &resp, &rc_param);
2056
2057         if (resp != FW_MSG_CODE_DRV_CFG_VF_MSIX_DONE) {
2058                 DP_NOTICE(p_hwfn, true, "VF[%d]: MFW failed to set MSI-X\n",
2059                           vf_id);
2060                 rc = ECORE_INVAL;
2061         } else {
2062                 DP_VERBOSE(p_hwfn, ECORE_MSG_IOV,
2063                            "Requested 0x%02x MSI-x interrupts from VF 0x%02x\n",
2064                             num, vf_id);
2065         }
2066
2067         return rc;
2068 }
2069
2070 enum _ecore_status_t
2071 ecore_mcp_send_drv_version(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2072                            struct ecore_mcp_drv_version *p_ver)
2073 {
2074         struct ecore_mcp_mb_params mb_params;
2075         struct drv_version_stc drv_version;
2076         u32 num_words, i;
2077         void *p_name;
2078         OSAL_BE32 val;
2079         enum _ecore_status_t rc;
2080
2081 #ifndef ASIC_ONLY
2082         if (CHIP_REV_IS_SLOW(p_hwfn->p_dev))
2083                 return ECORE_SUCCESS;
2084 #endif
2085
2086         OSAL_MEM_ZERO(&drv_version, sizeof(drv_version));
2087         drv_version.version = p_ver->version;
2088         num_words = (MCP_DRV_VER_STR_SIZE - 4) / 4;
2089         for (i = 0; i < num_words; i++) {
2090                 /* The driver name is expected to be in a big-endian format */
2091                 p_name = &p_ver->name[i * sizeof(u32)];
2092                 val = OSAL_CPU_TO_BE32(*(u32 *)p_name);
2093                 *(u32 *)&drv_version.name[i * sizeof(u32)] = val;
2094         }
2095
2096         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
2097         mb_params.cmd = DRV_MSG_CODE_SET_VERSION;
2098         mb_params.p_data_src = &drv_version;
2099         mb_params.data_src_size = sizeof(drv_version);
2100         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
2101         if (rc != ECORE_SUCCESS)
2102                 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2103
2104         return rc;
2105 }
2106
2107 enum _ecore_status_t ecore_mcp_halt(struct ecore_hwfn *p_hwfn,
2108                                     struct ecore_ptt *p_ptt)
2109 {
2110         enum _ecore_status_t rc;
2111         u32 resp = 0, param = 0;
2112
2113         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MCP_HALT, 0, &resp,
2114                            &param);
2115         if (rc != ECORE_SUCCESS)
2116                 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2117
2118         return rc;
2119 }
2120
2121 enum _ecore_status_t ecore_mcp_resume(struct ecore_hwfn *p_hwfn,
2122                                       struct ecore_ptt *p_ptt)
2123 {
2124         u32 value, cpu_mode;
2125
2126         ecore_wr(p_hwfn, p_ptt, MCP_REG_CPU_STATE, 0xffffffff);
2127
2128         value = ecore_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);
2129         value &= ~MCP_REG_CPU_MODE_SOFT_HALT;
2130         ecore_wr(p_hwfn, p_ptt, MCP_REG_CPU_MODE, value);
2131         cpu_mode = ecore_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);
2132
2133         return (cpu_mode & MCP_REG_CPU_MODE_SOFT_HALT) ? -1 : 0;
2134 }
2135
2136 enum _ecore_status_t
2137 ecore_mcp_ov_update_current_config(struct ecore_hwfn *p_hwfn,
2138                                    struct ecore_ptt *p_ptt,
2139                                    enum ecore_ov_client client)
2140 {
2141         enum _ecore_status_t rc;
2142         u32 resp = 0, param = 0;
2143         u32 drv_mb_param;
2144
2145         switch (client) {
2146         case ECORE_OV_CLIENT_DRV:
2147                 drv_mb_param = DRV_MB_PARAM_OV_CURR_CFG_OS;
2148                 break;
2149         case ECORE_OV_CLIENT_USER:
2150                 drv_mb_param = DRV_MB_PARAM_OV_CURR_CFG_OTHER;
2151                 break;
2152         case ECORE_OV_CLIENT_VENDOR_SPEC:
2153                 drv_mb_param = DRV_MB_PARAM_OV_CURR_CFG_VENDOR_SPEC;
2154                 break;
2155         default:
2156                 DP_NOTICE(p_hwfn, true, "Invalid client type %d\n", client);
2157                 return ECORE_INVAL;
2158         }
2159
2160         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OV_UPDATE_CURR_CFG,
2161                            drv_mb_param, &resp, &param);
2162         if (rc != ECORE_SUCCESS)
2163                 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2164
2165         return rc;
2166 }
2167
2168 enum _ecore_status_t
2169 ecore_mcp_ov_update_driver_state(struct ecore_hwfn *p_hwfn,
2170                                  struct ecore_ptt *p_ptt,
2171                                  enum ecore_ov_driver_state drv_state)
2172 {
2173         enum _ecore_status_t rc;
2174         u32 resp = 0, param = 0;
2175         u32 drv_mb_param;
2176
2177         switch (drv_state) {
2178         case ECORE_OV_DRIVER_STATE_NOT_LOADED:
2179                 drv_mb_param = DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE_NOT_LOADED;
2180                 break;
2181         case ECORE_OV_DRIVER_STATE_DISABLED:
2182                 drv_mb_param = DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE_DISABLED;
2183                 break;
2184         case ECORE_OV_DRIVER_STATE_ACTIVE:
2185                 drv_mb_param = DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE_ACTIVE;
2186                 break;
2187         default:
2188                 DP_NOTICE(p_hwfn, true, "Invalid driver state %d\n", drv_state);
2189                 return ECORE_INVAL;
2190         }
2191
2192         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_OV_UPDATE_DRIVER_STATE,
2193                            drv_mb_param, &resp, &param);
2194         if (rc != ECORE_SUCCESS)
2195                 DP_ERR(p_hwfn, "Failed to send driver state\n");
2196
2197         return rc;
2198 }
2199
2200 enum _ecore_status_t
2201 ecore_mcp_ov_get_fc_npiv(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2202                          struct ecore_fc_npiv_tbl *p_table)
2203 {
2204         return 0;
2205 }
2206
2207 enum _ecore_status_t
2208 ecore_mcp_ov_update_mtu(struct ecore_hwfn *p_hwfn,
2209                         struct ecore_ptt *p_ptt, u16 mtu)
2210 {
2211         return 0;
2212 }
2213
2214 enum _ecore_status_t ecore_mcp_set_led(struct ecore_hwfn *p_hwfn,
2215                                        struct ecore_ptt *p_ptt,
2216                                        enum ecore_led_mode mode)
2217 {
2218         u32 resp = 0, param = 0, drv_mb_param;
2219         enum _ecore_status_t rc;
2220
2221         switch (mode) {
2222         case ECORE_LED_MODE_ON:
2223                 drv_mb_param = DRV_MB_PARAM_SET_LED_MODE_ON;
2224                 break;
2225         case ECORE_LED_MODE_OFF:
2226                 drv_mb_param = DRV_MB_PARAM_SET_LED_MODE_OFF;
2227                 break;
2228         case ECORE_LED_MODE_RESTORE:
2229                 drv_mb_param = DRV_MB_PARAM_SET_LED_MODE_OPER;
2230                 break;
2231         default:
2232                 DP_NOTICE(p_hwfn, true, "Invalid LED mode %d\n", mode);
2233                 return ECORE_INVAL;
2234         }
2235
2236         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_SET_LED_MODE,
2237                            drv_mb_param, &resp, &param);
2238         if (rc != ECORE_SUCCESS)
2239                 DP_ERR(p_hwfn, "MCP response failure, aborting\n");
2240
2241         return rc;
2242 }
2243
2244 enum _ecore_status_t ecore_mcp_mask_parities(struct ecore_hwfn *p_hwfn,
2245                                              struct ecore_ptt *p_ptt,
2246                                              u32 mask_parities)
2247 {
2248         enum _ecore_status_t rc;
2249         u32 resp = 0, param = 0;
2250
2251         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MASK_PARITIES,
2252                            mask_parities, &resp, &param);
2253
2254         if (rc != ECORE_SUCCESS) {
2255                 DP_ERR(p_hwfn,
2256                        "MCP response failure for mask parities, aborting\n");
2257         } else if (resp != FW_MSG_CODE_OK) {
2258                 DP_ERR(p_hwfn,
2259                        "MCP did not ack mask parity request. Old MFW?\n");
2260                 rc = ECORE_INVAL;
2261         }
2262
2263         return rc;
2264 }
2265
2266 enum _ecore_status_t ecore_mcp_nvm_read(struct ecore_dev *p_dev, u32 addr,
2267                                         u8 *p_buf, u32 len)
2268 {
2269         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2270         u32 bytes_left, offset, bytes_to_copy, buf_size;
2271         struct ecore_mcp_nvm_params params;
2272         struct ecore_ptt *p_ptt;
2273         enum _ecore_status_t rc = ECORE_SUCCESS;
2274
2275         p_ptt = ecore_ptt_acquire(p_hwfn);
2276         if (!p_ptt)
2277                 return ECORE_BUSY;
2278
2279         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2280         bytes_left = len;
2281         offset = 0;
2282         params.type = ECORE_MCP_NVM_RD;
2283         params.nvm_rd.buf_size = &buf_size;
2284         params.nvm_common.cmd = DRV_MSG_CODE_NVM_READ_NVRAM;
2285         while (bytes_left > 0) {
2286                 bytes_to_copy = OSAL_MIN_T(u32, bytes_left,
2287                                            MCP_DRV_NVM_BUF_LEN);
2288                 params.nvm_common.offset = (addr + offset) |
2289                     (bytes_to_copy << DRV_MB_PARAM_NVM_LEN_SHIFT);
2290                 params.nvm_rd.buf = (u32 *)(p_buf + offset);
2291                 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2292                 if (rc != ECORE_SUCCESS || (params.nvm_common.resp !=
2293                                             FW_MSG_CODE_NVM_OK)) {
2294                         DP_NOTICE(p_dev, false, "MCP command rc = %d\n", rc);
2295                         break;
2296                 }
2297
2298                 /* This can be a lengthy process, and it's possible scheduler
2299                  * isn't preemptible. Sleep a bit to prevent CPU hogging.
2300                  */
2301                 if (bytes_left % 0x1000 <
2302                     (bytes_left - *params.nvm_rd.buf_size) % 0x1000)
2303                         OSAL_MSLEEP(1);
2304
2305                 offset += *params.nvm_rd.buf_size;
2306                 bytes_left -= *params.nvm_rd.buf_size;
2307         }
2308
2309         p_dev->mcp_nvm_resp = params.nvm_common.resp;
2310         ecore_ptt_release(p_hwfn, p_ptt);
2311
2312         return rc;
2313 }
2314
2315 enum _ecore_status_t ecore_mcp_phy_read(struct ecore_dev *p_dev, u32 cmd,
2316                                         u32 addr, u8 *p_buf, u32 len)
2317 {
2318         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2319         struct ecore_mcp_nvm_params params;
2320         struct ecore_ptt *p_ptt;
2321         enum _ecore_status_t rc;
2322
2323         p_ptt = ecore_ptt_acquire(p_hwfn);
2324         if (!p_ptt)
2325                 return ECORE_BUSY;
2326
2327         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2328         params.type = ECORE_MCP_NVM_RD;
2329         params.nvm_rd.buf_size = &len;
2330         params.nvm_common.cmd = (cmd == ECORE_PHY_CORE_READ) ?
2331             DRV_MSG_CODE_PHY_CORE_READ : DRV_MSG_CODE_PHY_RAW_READ;
2332         params.nvm_common.offset = addr;
2333         params.nvm_rd.buf = (u32 *)p_buf;
2334         rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2335         if (rc != ECORE_SUCCESS)
2336                 DP_NOTICE(p_dev, false, "MCP command rc = %d\n", rc);
2337
2338         p_dev->mcp_nvm_resp = params.nvm_common.resp;
2339         ecore_ptt_release(p_hwfn, p_ptt);
2340
2341         return rc;
2342 }
2343
2344 enum _ecore_status_t ecore_mcp_nvm_resp(struct ecore_dev *p_dev, u8 *p_buf)
2345 {
2346         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2347         struct ecore_mcp_nvm_params params;
2348         struct ecore_ptt *p_ptt;
2349
2350         p_ptt = ecore_ptt_acquire(p_hwfn);
2351         if (!p_ptt)
2352                 return ECORE_BUSY;
2353
2354         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2355         OSAL_MEMCPY(p_buf, &p_dev->mcp_nvm_resp, sizeof(p_dev->mcp_nvm_resp));
2356         ecore_ptt_release(p_hwfn, p_ptt);
2357
2358         return ECORE_SUCCESS;
2359 }
2360
2361 enum _ecore_status_t ecore_mcp_nvm_del_file(struct ecore_dev *p_dev, u32 addr)
2362 {
2363         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2364         struct ecore_mcp_nvm_params params;
2365         struct ecore_ptt *p_ptt;
2366         enum _ecore_status_t rc;
2367
2368         p_ptt = ecore_ptt_acquire(p_hwfn);
2369         if (!p_ptt)
2370                 return ECORE_BUSY;
2371         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2372         params.type = ECORE_MCP_CMD;
2373         params.nvm_common.cmd = DRV_MSG_CODE_NVM_DEL_FILE;
2374         params.nvm_common.offset = addr;
2375         rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2376         p_dev->mcp_nvm_resp = params.nvm_common.resp;
2377         ecore_ptt_release(p_hwfn, p_ptt);
2378
2379         return rc;
2380 }
2381
2382 enum _ecore_status_t ecore_mcp_nvm_put_file_begin(struct ecore_dev *p_dev,
2383                                                   u32 addr)
2384 {
2385         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2386         struct ecore_mcp_nvm_params params;
2387         struct ecore_ptt *p_ptt;
2388         enum _ecore_status_t rc;
2389
2390         p_ptt = ecore_ptt_acquire(p_hwfn);
2391         if (!p_ptt)
2392                 return ECORE_BUSY;
2393         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2394         params.type = ECORE_MCP_CMD;
2395         params.nvm_common.cmd = DRV_MSG_CODE_NVM_PUT_FILE_BEGIN;
2396         params.nvm_common.offset = addr;
2397         rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2398         p_dev->mcp_nvm_resp = params.nvm_common.resp;
2399         ecore_ptt_release(p_hwfn, p_ptt);
2400
2401         return rc;
2402 }
2403
2404 /* rc receives ECORE_INVAL as default parameter because
2405  * it might not enter the while loop if the len is 0
2406  */
2407 enum _ecore_status_t ecore_mcp_nvm_write(struct ecore_dev *p_dev, u32 cmd,
2408                                          u32 addr, u8 *p_buf, u32 len)
2409 {
2410         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2411         enum _ecore_status_t rc = ECORE_INVAL;
2412         struct ecore_mcp_nvm_params params;
2413         struct ecore_ptt *p_ptt;
2414         u32 buf_idx, buf_size;
2415
2416         p_ptt = ecore_ptt_acquire(p_hwfn);
2417         if (!p_ptt)
2418                 return ECORE_BUSY;
2419
2420         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2421         params.type = ECORE_MCP_NVM_WR;
2422         if (cmd == ECORE_PUT_FILE_DATA)
2423                 params.nvm_common.cmd = DRV_MSG_CODE_NVM_PUT_FILE_DATA;
2424         else
2425                 params.nvm_common.cmd = DRV_MSG_CODE_NVM_WRITE_NVRAM;
2426         buf_idx = 0;
2427         while (buf_idx < len) {
2428                 buf_size = OSAL_MIN_T(u32, (len - buf_idx),
2429                                       MCP_DRV_NVM_BUF_LEN);
2430                 params.nvm_common.offset = ((buf_size <<
2431                                              DRV_MB_PARAM_NVM_LEN_SHIFT)
2432                                             | addr) + buf_idx;
2433                 params.nvm_wr.buf_size = buf_size;
2434                 params.nvm_wr.buf = (u32 *)&p_buf[buf_idx];
2435                 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2436                 if (rc != ECORE_SUCCESS ||
2437                     ((params.nvm_common.resp != FW_MSG_CODE_NVM_OK) &&
2438                      (params.nvm_common.resp !=
2439                       FW_MSG_CODE_NVM_PUT_FILE_FINISH_OK)))
2440                         DP_NOTICE(p_dev, false, "MCP command rc = %d\n", rc);
2441
2442                 /* This can be a lengthy process, and it's possible scheduler
2443                  * isn't preemptible. Sleep a bit to prevent CPU hogging.
2444                  */
2445                 if (buf_idx % 0x1000 >
2446                     (buf_idx + buf_size) % 0x1000)
2447                         OSAL_MSLEEP(1);
2448
2449                 buf_idx += buf_size;
2450         }
2451
2452         p_dev->mcp_nvm_resp = params.nvm_common.resp;
2453         ecore_ptt_release(p_hwfn, p_ptt);
2454
2455         return rc;
2456 }
2457
2458 enum _ecore_status_t ecore_mcp_phy_write(struct ecore_dev *p_dev, u32 cmd,
2459                                          u32 addr, u8 *p_buf, u32 len)
2460 {
2461         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2462         struct ecore_mcp_nvm_params params;
2463         struct ecore_ptt *p_ptt;
2464         enum _ecore_status_t rc;
2465
2466         p_ptt = ecore_ptt_acquire(p_hwfn);
2467         if (!p_ptt)
2468                 return ECORE_BUSY;
2469
2470         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2471         params.type = ECORE_MCP_NVM_WR;
2472         params.nvm_wr.buf_size = len;
2473         params.nvm_common.cmd = (cmd == ECORE_PHY_CORE_WRITE) ?
2474             DRV_MSG_CODE_PHY_CORE_WRITE : DRV_MSG_CODE_PHY_RAW_WRITE;
2475         params.nvm_common.offset = addr;
2476         params.nvm_wr.buf = (u32 *)p_buf;
2477         rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2478         if (rc != ECORE_SUCCESS)
2479                 DP_NOTICE(p_dev, false, "MCP command rc = %d\n", rc);
2480         p_dev->mcp_nvm_resp = params.nvm_common.resp;
2481         ecore_ptt_release(p_hwfn, p_ptt);
2482
2483         return rc;
2484 }
2485
2486 enum _ecore_status_t ecore_mcp_nvm_set_secure_mode(struct ecore_dev *p_dev,
2487                                                    u32 addr)
2488 {
2489         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2490         struct ecore_mcp_nvm_params params;
2491         struct ecore_ptt *p_ptt;
2492         enum _ecore_status_t rc;
2493
2494         p_ptt = ecore_ptt_acquire(p_hwfn);
2495         if (!p_ptt)
2496                 return ECORE_BUSY;
2497
2498         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2499         params.type = ECORE_MCP_CMD;
2500         params.nvm_common.cmd = DRV_MSG_CODE_SET_SECURE_MODE;
2501         params.nvm_common.offset = addr;
2502         rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2503         p_dev->mcp_nvm_resp = params.nvm_common.resp;
2504         ecore_ptt_release(p_hwfn, p_ptt);
2505
2506         return rc;
2507 }
2508
2509 enum _ecore_status_t ecore_mcp_phy_sfp_read(struct ecore_hwfn *p_hwfn,
2510                                             struct ecore_ptt *p_ptt,
2511                                             u32 port, u32 addr, u32 offset,
2512                                             u32 len, u8 *p_buf)
2513 {
2514         struct ecore_mcp_nvm_params params;
2515         enum _ecore_status_t rc;
2516         u32 bytes_left, bytes_to_copy, buf_size;
2517
2518         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2519         params.nvm_common.offset =
2520                 (port << DRV_MB_PARAM_TRANSCEIVER_PORT_SHIFT) |
2521                 (addr << DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_SHIFT);
2522         addr = offset;
2523         offset = 0;
2524         bytes_left = len;
2525         params.type = ECORE_MCP_NVM_RD;
2526         params.nvm_rd.buf_size = &buf_size;
2527         params.nvm_common.cmd = DRV_MSG_CODE_TRANSCEIVER_READ;
2528         while (bytes_left > 0) {
2529                 bytes_to_copy = OSAL_MIN_T(u32, bytes_left,
2530                                            MAX_I2C_TRANSACTION_SIZE);
2531                 params.nvm_rd.buf = (u32 *)(p_buf + offset);
2532                 params.nvm_common.offset &=
2533                         (DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_MASK |
2534                          DRV_MB_PARAM_TRANSCEIVER_PORT_MASK);
2535                 params.nvm_common.offset |=
2536                         ((addr + offset) <<
2537                          DRV_MB_PARAM_TRANSCEIVER_OFFSET_SHIFT);
2538                 params.nvm_common.offset |=
2539                         (bytes_to_copy << DRV_MB_PARAM_TRANSCEIVER_SIZE_SHIFT);
2540                 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2541                 if ((params.nvm_common.resp & FW_MSG_CODE_MASK) ==
2542                     FW_MSG_CODE_TRANSCEIVER_NOT_PRESENT) {
2543                         return ECORE_NODEV;
2544                 } else if ((params.nvm_common.resp & FW_MSG_CODE_MASK) !=
2545                            FW_MSG_CODE_TRANSCEIVER_DIAG_OK)
2546                         return ECORE_UNKNOWN_ERROR;
2547
2548                 offset += *params.nvm_rd.buf_size;
2549                 bytes_left -= *params.nvm_rd.buf_size;
2550         }
2551
2552         return ECORE_SUCCESS;
2553 }
2554
2555 enum _ecore_status_t ecore_mcp_phy_sfp_write(struct ecore_hwfn *p_hwfn,
2556                                              struct ecore_ptt *p_ptt,
2557                                              u32 port, u32 addr, u32 offset,
2558                                              u32 len, u8 *p_buf)
2559 {
2560         struct ecore_mcp_nvm_params params;
2561         enum _ecore_status_t rc;
2562         u32 buf_idx, buf_size;
2563
2564         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2565         params.nvm_common.offset =
2566                 (port << DRV_MB_PARAM_TRANSCEIVER_PORT_SHIFT) |
2567                 (addr << DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_SHIFT);
2568         params.type = ECORE_MCP_NVM_WR;
2569         params.nvm_common.cmd = DRV_MSG_CODE_TRANSCEIVER_WRITE;
2570         buf_idx = 0;
2571         while (buf_idx < len) {
2572                 buf_size = OSAL_MIN_T(u32, (len - buf_idx),
2573                                       MAX_I2C_TRANSACTION_SIZE);
2574                 params.nvm_common.offset &=
2575                         (DRV_MB_PARAM_TRANSCEIVER_I2C_ADDRESS_MASK |
2576                          DRV_MB_PARAM_TRANSCEIVER_PORT_MASK);
2577                 params.nvm_common.offset |=
2578                         ((offset + buf_idx) <<
2579                          DRV_MB_PARAM_TRANSCEIVER_OFFSET_SHIFT);
2580                 params.nvm_common.offset |=
2581                         (buf_size << DRV_MB_PARAM_TRANSCEIVER_SIZE_SHIFT);
2582                 params.nvm_wr.buf_size = buf_size;
2583                 params.nvm_wr.buf = (u32 *)&p_buf[buf_idx];
2584                 rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2585                 if ((params.nvm_common.resp & FW_MSG_CODE_MASK) ==
2586                     FW_MSG_CODE_TRANSCEIVER_NOT_PRESENT) {
2587                         return ECORE_NODEV;
2588                 } else if ((params.nvm_common.resp & FW_MSG_CODE_MASK) !=
2589                            FW_MSG_CODE_TRANSCEIVER_DIAG_OK)
2590                         return ECORE_UNKNOWN_ERROR;
2591
2592                 buf_idx += buf_size;
2593         }
2594
2595         return ECORE_SUCCESS;
2596 }
2597
2598 enum _ecore_status_t ecore_mcp_gpio_read(struct ecore_hwfn *p_hwfn,
2599                                          struct ecore_ptt *p_ptt,
2600                                          u16 gpio, u32 *gpio_val)
2601 {
2602         enum _ecore_status_t rc = ECORE_SUCCESS;
2603         u32 drv_mb_param = 0, rsp;
2604
2605         drv_mb_param = (gpio << DRV_MB_PARAM_GPIO_NUMBER_SHIFT);
2606
2607         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GPIO_READ,
2608                            drv_mb_param, &rsp, gpio_val);
2609
2610         if (rc != ECORE_SUCCESS)
2611                 return rc;
2612
2613         if ((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_GPIO_OK)
2614                 return ECORE_UNKNOWN_ERROR;
2615
2616         return ECORE_SUCCESS;
2617 }
2618
2619 enum _ecore_status_t ecore_mcp_gpio_write(struct ecore_hwfn *p_hwfn,
2620                                           struct ecore_ptt *p_ptt,
2621                                           u16 gpio, u16 gpio_val)
2622 {
2623         enum _ecore_status_t rc = ECORE_SUCCESS;
2624         u32 drv_mb_param = 0, param, rsp;
2625
2626         drv_mb_param = (gpio << DRV_MB_PARAM_GPIO_NUMBER_SHIFT) |
2627                 (gpio_val << DRV_MB_PARAM_GPIO_VALUE_SHIFT);
2628
2629         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GPIO_WRITE,
2630                            drv_mb_param, &rsp, &param);
2631
2632         if (rc != ECORE_SUCCESS)
2633                 return rc;
2634
2635         if ((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_GPIO_OK)
2636                 return ECORE_UNKNOWN_ERROR;
2637
2638         return ECORE_SUCCESS;
2639 }
2640
2641 enum _ecore_status_t ecore_mcp_gpio_info(struct ecore_hwfn *p_hwfn,
2642                                          struct ecore_ptt *p_ptt,
2643                                          u16 gpio, u32 *gpio_direction,
2644                                          u32 *gpio_ctrl)
2645 {
2646         u32 drv_mb_param = 0, rsp, val = 0;
2647         enum _ecore_status_t rc = ECORE_SUCCESS;
2648
2649         drv_mb_param = gpio << DRV_MB_PARAM_GPIO_NUMBER_SHIFT;
2650
2651         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GPIO_INFO,
2652                            drv_mb_param, &rsp, &val);
2653         if (rc != ECORE_SUCCESS)
2654                 return rc;
2655
2656         *gpio_direction = (val & DRV_MB_PARAM_GPIO_DIRECTION_MASK) >>
2657                            DRV_MB_PARAM_GPIO_DIRECTION_SHIFT;
2658         *gpio_ctrl = (val & DRV_MB_PARAM_GPIO_CTRL_MASK) >>
2659                       DRV_MB_PARAM_GPIO_CTRL_SHIFT;
2660
2661         if ((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_GPIO_OK)
2662                 return ECORE_UNKNOWN_ERROR;
2663
2664         return ECORE_SUCCESS;
2665 }
2666
2667 enum _ecore_status_t ecore_mcp_bist_register_test(struct ecore_hwfn *p_hwfn,
2668                                                   struct ecore_ptt *p_ptt)
2669 {
2670         u32 drv_mb_param = 0, rsp, param;
2671         enum _ecore_status_t rc = ECORE_SUCCESS;
2672
2673         drv_mb_param = (DRV_MB_PARAM_BIST_REGISTER_TEST <<
2674                         DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
2675
2676         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BIST_TEST,
2677                            drv_mb_param, &rsp, &param);
2678
2679         if (rc != ECORE_SUCCESS)
2680                 return rc;
2681
2682         if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK) ||
2683             (param != DRV_MB_PARAM_BIST_RC_PASSED))
2684                 rc = ECORE_UNKNOWN_ERROR;
2685
2686         return rc;
2687 }
2688
2689 enum _ecore_status_t ecore_mcp_bist_clock_test(struct ecore_hwfn *p_hwfn,
2690                                                struct ecore_ptt *p_ptt)
2691 {
2692         u32 drv_mb_param, rsp, param;
2693         enum _ecore_status_t rc = ECORE_SUCCESS;
2694
2695         drv_mb_param = (DRV_MB_PARAM_BIST_CLOCK_TEST <<
2696                         DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
2697
2698         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BIST_TEST,
2699                            drv_mb_param, &rsp, &param);
2700
2701         if (rc != ECORE_SUCCESS)
2702                 return rc;
2703
2704         if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK) ||
2705             (param != DRV_MB_PARAM_BIST_RC_PASSED))
2706                 rc = ECORE_UNKNOWN_ERROR;
2707
2708         return rc;
2709 }
2710
2711 enum _ecore_status_t ecore_mcp_bist_nvm_test_get_num_images(
2712         struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, u32 *num_images)
2713 {
2714         u32 drv_mb_param = 0, rsp;
2715         enum _ecore_status_t rc = ECORE_SUCCESS;
2716
2717         drv_mb_param = (DRV_MB_PARAM_BIST_NVM_TEST_NUM_IMAGES <<
2718                         DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
2719
2720         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_BIST_TEST,
2721                            drv_mb_param, &rsp, num_images);
2722
2723         if (rc != ECORE_SUCCESS)
2724                 return rc;
2725
2726         if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK))
2727                 rc = ECORE_UNKNOWN_ERROR;
2728
2729         return rc;
2730 }
2731
2732 enum _ecore_status_t ecore_mcp_bist_nvm_test_get_image_att(
2733         struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
2734         struct bist_nvm_image_att *p_image_att, u32 image_index)
2735 {
2736         struct ecore_mcp_nvm_params params;
2737         enum _ecore_status_t rc;
2738         u32 buf_size;
2739
2740         OSAL_MEMSET(&params, 0, sizeof(struct ecore_mcp_nvm_params));
2741         params.nvm_common.offset = (DRV_MB_PARAM_BIST_NVM_TEST_IMAGE_BY_INDEX <<
2742                                     DRV_MB_PARAM_BIST_TEST_INDEX_SHIFT);
2743         params.nvm_common.offset |= (image_index <<
2744                                     DRV_MB_PARAM_BIST_TEST_IMAGE_INDEX_SHIFT);
2745
2746         params.type = ECORE_MCP_NVM_RD;
2747         params.nvm_rd.buf_size = &buf_size;
2748         params.nvm_common.cmd = DRV_MSG_CODE_BIST_TEST;
2749         params.nvm_rd.buf = (u32 *)p_image_att;
2750
2751         rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2752         if (rc != ECORE_SUCCESS)
2753                 return rc;
2754
2755         if (((params.nvm_common.resp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK) ||
2756             (p_image_att->return_code != 1))
2757                 rc = ECORE_UNKNOWN_ERROR;
2758
2759         return rc;
2760 }
2761
2762 enum _ecore_status_t
2763 ecore_mcp_get_temperature_info(struct ecore_hwfn *p_hwfn,
2764                                struct ecore_ptt *p_ptt,
2765                                struct ecore_temperature_info *p_temp_info)
2766 {
2767         struct ecore_temperature_sensor *p_temp_sensor;
2768         struct temperature_status_stc mfw_temp_info;
2769         struct ecore_mcp_mb_params mb_params;
2770         u32 val;
2771         enum _ecore_status_t rc;
2772         u8 i;
2773
2774         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
2775         mb_params.cmd = DRV_MSG_CODE_GET_TEMPERATURE;
2776         mb_params.p_data_dst = &mfw_temp_info;
2777         mb_params.data_dst_size = sizeof(mfw_temp_info);
2778         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
2779         if (rc != ECORE_SUCCESS)
2780                 return rc;
2781
2782         OSAL_BUILD_BUG_ON(ECORE_MAX_NUM_OF_SENSORS != MAX_NUM_OF_SENSORS);
2783         p_temp_info->num_sensors = OSAL_MIN_T(u32, mfw_temp_info.num_of_sensors,
2784                                               ECORE_MAX_NUM_OF_SENSORS);
2785         for (i = 0; i < p_temp_info->num_sensors; i++) {
2786                 val = mfw_temp_info.sensor[i];
2787                 p_temp_sensor = &p_temp_info->sensors[i];
2788                 p_temp_sensor->sensor_location = (val & SENSOR_LOCATION_MASK) >>
2789                                                  SENSOR_LOCATION_SHIFT;
2790                 p_temp_sensor->threshold_high = (val & THRESHOLD_HIGH_MASK) >>
2791                                                 THRESHOLD_HIGH_SHIFT;
2792                 p_temp_sensor->critical = (val & CRITICAL_TEMPERATURE_MASK) >>
2793                                           CRITICAL_TEMPERATURE_SHIFT;
2794                 p_temp_sensor->current_temp = (val & CURRENT_TEMP_MASK) >>
2795                                               CURRENT_TEMP_SHIFT;
2796         }
2797
2798         return ECORE_SUCCESS;
2799 }
2800
2801 enum _ecore_status_t ecore_mcp_get_mba_versions(
2802         struct ecore_hwfn *p_hwfn,
2803         struct ecore_ptt *p_ptt,
2804         struct ecore_mba_vers *p_mba_vers)
2805 {
2806         struct ecore_mcp_nvm_params params;
2807         enum _ecore_status_t rc;
2808         u32 buf_size;
2809
2810         OSAL_MEM_ZERO(&params, sizeof(params));
2811         params.type = ECORE_MCP_NVM_RD;
2812         params.nvm_common.cmd = DRV_MSG_CODE_GET_MBA_VERSION;
2813         params.nvm_common.offset = 0;
2814         params.nvm_rd.buf = &p_mba_vers->mba_vers[0];
2815         params.nvm_rd.buf_size = &buf_size;
2816         rc = ecore_mcp_nvm_command(p_hwfn, p_ptt, &params);
2817
2818         if (rc != ECORE_SUCCESS)
2819                 return rc;
2820
2821         if ((params.nvm_common.resp & FW_MSG_CODE_MASK) !=
2822             FW_MSG_CODE_NVM_OK)
2823                 rc = ECORE_UNKNOWN_ERROR;
2824
2825         if (buf_size != MCP_DRV_NVM_BUF_LEN)
2826                 rc = ECORE_UNKNOWN_ERROR;
2827
2828         return rc;
2829 }
2830
2831 enum _ecore_status_t ecore_mcp_mem_ecc_events(struct ecore_hwfn *p_hwfn,
2832                                               struct ecore_ptt *p_ptt,
2833                                               u64 *num_events)
2834 {
2835         u32 rsp;
2836
2837         return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MEM_ECC_EVENTS,
2838                              0, &rsp, (u32 *)num_events);
2839 }
2840
2841 static enum resource_id_enum
2842 ecore_mcp_get_mfw_res_id(enum ecore_resources res_id)
2843 {
2844         enum resource_id_enum mfw_res_id = RESOURCE_NUM_INVALID;
2845
2846         switch (res_id) {
2847         case ECORE_SB:
2848                 mfw_res_id = RESOURCE_NUM_SB_E;
2849                 break;
2850         case ECORE_L2_QUEUE:
2851                 mfw_res_id = RESOURCE_NUM_L2_QUEUE_E;
2852                 break;
2853         case ECORE_VPORT:
2854                 mfw_res_id = RESOURCE_NUM_VPORT_E;
2855                 break;
2856         case ECORE_RSS_ENG:
2857                 mfw_res_id = RESOURCE_NUM_RSS_ENGINES_E;
2858                 break;
2859         case ECORE_PQ:
2860                 mfw_res_id = RESOURCE_NUM_PQ_E;
2861                 break;
2862         case ECORE_RL:
2863                 mfw_res_id = RESOURCE_NUM_RL_E;
2864                 break;
2865         case ECORE_MAC:
2866         case ECORE_VLAN:
2867                 /* Each VFC resource can accommodate both a MAC and a VLAN */
2868                 mfw_res_id = RESOURCE_VFC_FILTER_E;
2869                 break;
2870         case ECORE_ILT:
2871                 mfw_res_id = RESOURCE_ILT_E;
2872                 break;
2873         case ECORE_LL2_QUEUE:
2874                 mfw_res_id = RESOURCE_LL2_QUEUE_E;
2875                 break;
2876         case ECORE_RDMA_CNQ_RAM:
2877         case ECORE_CMDQS_CQS:
2878                 /* CNQ/CMDQS are the same resource */
2879                 mfw_res_id = RESOURCE_CQS_E;
2880                 break;
2881         case ECORE_RDMA_STATS_QUEUE:
2882                 mfw_res_id = RESOURCE_RDMA_STATS_QUEUE_E;
2883                 break;
2884         case ECORE_BDQ:
2885                 mfw_res_id = RESOURCE_BDQ_E;
2886                 break;
2887         default:
2888                 break;
2889         }
2890
2891         return mfw_res_id;
2892 }
2893
2894 #define ECORE_RESC_ALLOC_VERSION_MAJOR  2
2895 #define ECORE_RESC_ALLOC_VERSION_MINOR  0
2896 #define ECORE_RESC_ALLOC_VERSION                                \
2897         ((ECORE_RESC_ALLOC_VERSION_MAJOR <<                     \
2898           DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MAJOR_SHIFT) |    \
2899          (ECORE_RESC_ALLOC_VERSION_MINOR <<                     \
2900           DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MINOR_SHIFT))
2901
2902 struct ecore_resc_alloc_in_params {
2903         u32 cmd;
2904         enum ecore_resources res_id;
2905         u32 resc_max_val;
2906 };
2907
2908 struct ecore_resc_alloc_out_params {
2909         u32 mcp_resp;
2910         u32 mcp_param;
2911         u32 resc_num;
2912         u32 resc_start;
2913         u32 vf_resc_num;
2914         u32 vf_resc_start;
2915         u32 flags;
2916 };
2917
2918 #define ECORE_RECOVERY_PROLOG_SLEEP_MS  100
2919
2920 enum _ecore_status_t ecore_recovery_prolog(struct ecore_dev *p_dev)
2921 {
2922         struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
2923         struct ecore_ptt *p_ptt = p_hwfn->p_main_ptt;
2924         enum _ecore_status_t rc;
2925
2926         /* Allow ongoing PCIe transactions to complete */
2927         OSAL_MSLEEP(ECORE_RECOVERY_PROLOG_SLEEP_MS);
2928
2929         /* Clear the PF's internal FID_enable in the PXP */
2930         rc = ecore_pglueb_set_pfid_enable(p_hwfn, p_ptt, false);
2931         if (rc != ECORE_SUCCESS)
2932                 DP_NOTICE(p_hwfn, false,
2933                           "ecore_pglueb_set_pfid_enable() failed. rc = %d.\n",
2934                           rc);
2935
2936         return rc;
2937 }
2938
2939 static enum _ecore_status_t
2940 ecore_mcp_resc_allocation_msg(struct ecore_hwfn *p_hwfn,
2941                               struct ecore_ptt *p_ptt,
2942                               struct ecore_resc_alloc_in_params *p_in_params,
2943                               struct ecore_resc_alloc_out_params *p_out_params)
2944 {
2945         struct ecore_mcp_mb_params mb_params;
2946         struct resource_info mfw_resc_info;
2947         enum _ecore_status_t rc;
2948
2949         OSAL_MEM_ZERO(&mfw_resc_info, sizeof(mfw_resc_info));
2950
2951         mfw_resc_info.res_id = ecore_mcp_get_mfw_res_id(p_in_params->res_id);
2952         if (mfw_resc_info.res_id == RESOURCE_NUM_INVALID) {
2953                 DP_ERR(p_hwfn,
2954                        "Failed to match resource %d [%s] with the MFW resources\n",
2955                        p_in_params->res_id,
2956                        ecore_hw_get_resc_name(p_in_params->res_id));
2957                 return ECORE_INVAL;
2958         }
2959
2960         switch (p_in_params->cmd) {
2961         case DRV_MSG_SET_RESOURCE_VALUE_MSG:
2962                 mfw_resc_info.size = p_in_params->resc_max_val;
2963                 /* Fallthrough */
2964         case DRV_MSG_GET_RESOURCE_ALLOC_MSG:
2965                 break;
2966         default:
2967                 DP_ERR(p_hwfn, "Unexpected resource alloc command [0x%08x]\n",
2968                        p_in_params->cmd);
2969                 return ECORE_INVAL;
2970         }
2971
2972         OSAL_MEM_ZERO(&mb_params, sizeof(mb_params));
2973         mb_params.cmd = p_in_params->cmd;
2974         mb_params.param = ECORE_RESC_ALLOC_VERSION;
2975         mb_params.p_data_src = &mfw_resc_info;
2976         mb_params.data_src_size = sizeof(mfw_resc_info);
2977         mb_params.p_data_dst = mb_params.p_data_src;
2978         mb_params.data_dst_size = mb_params.data_src_size;
2979
2980         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
2981                    "Resource message request: cmd 0x%08x, res_id %d [%s], hsi_version %d.%d, val 0x%x\n",
2982                    p_in_params->cmd, p_in_params->res_id,
2983                    ecore_hw_get_resc_name(p_in_params->res_id),
2984                    ECORE_MFW_GET_FIELD(mb_params.param,
2985                            DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MAJOR),
2986                    ECORE_MFW_GET_FIELD(mb_params.param,
2987                            DRV_MB_PARAM_RESOURCE_ALLOC_VERSION_MINOR),
2988                    p_in_params->resc_max_val);
2989
2990         rc = ecore_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
2991         if (rc != ECORE_SUCCESS)
2992                 return rc;
2993
2994         p_out_params->mcp_resp = mb_params.mcp_resp;
2995         p_out_params->mcp_param = mb_params.mcp_param;
2996         p_out_params->resc_num = mfw_resc_info.size;
2997         p_out_params->resc_start = mfw_resc_info.offset;
2998         p_out_params->vf_resc_num = mfw_resc_info.vf_size;
2999         p_out_params->vf_resc_start = mfw_resc_info.vf_offset;
3000         p_out_params->flags = mfw_resc_info.flags;
3001
3002         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3003                    "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",
3004                    ECORE_MFW_GET_FIELD(p_out_params->mcp_param,
3005                            FW_MB_PARAM_RESOURCE_ALLOC_VERSION_MAJOR),
3006                    ECORE_MFW_GET_FIELD(p_out_params->mcp_param,
3007                            FW_MB_PARAM_RESOURCE_ALLOC_VERSION_MINOR),
3008                    p_out_params->resc_num, p_out_params->resc_start,
3009                    p_out_params->vf_resc_num, p_out_params->vf_resc_start,
3010                    p_out_params->flags);
3011
3012         return ECORE_SUCCESS;
3013 }
3014
3015 enum _ecore_status_t
3016 ecore_mcp_set_resc_max_val(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3017                            enum ecore_resources res_id, u32 resc_max_val,
3018                            u32 *p_mcp_resp)
3019 {
3020         struct ecore_resc_alloc_out_params out_params;
3021         struct ecore_resc_alloc_in_params in_params;
3022         enum _ecore_status_t rc;
3023
3024         OSAL_MEM_ZERO(&in_params, sizeof(in_params));
3025         in_params.cmd = DRV_MSG_SET_RESOURCE_VALUE_MSG;
3026         in_params.res_id = res_id;
3027         in_params.resc_max_val = resc_max_val;
3028         OSAL_MEM_ZERO(&out_params, sizeof(out_params));
3029         rc = ecore_mcp_resc_allocation_msg(p_hwfn, p_ptt, &in_params,
3030                                            &out_params);
3031         if (rc != ECORE_SUCCESS)
3032                 return rc;
3033
3034         *p_mcp_resp = out_params.mcp_resp;
3035
3036         return ECORE_SUCCESS;
3037 }
3038
3039 enum _ecore_status_t
3040 ecore_mcp_get_resc_info(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3041                         enum ecore_resources res_id, u32 *p_mcp_resp,
3042                         u32 *p_resc_num, u32 *p_resc_start)
3043 {
3044         struct ecore_resc_alloc_out_params out_params;
3045         struct ecore_resc_alloc_in_params in_params;
3046         enum _ecore_status_t rc;
3047
3048         OSAL_MEM_ZERO(&in_params, sizeof(in_params));
3049         in_params.cmd = DRV_MSG_GET_RESOURCE_ALLOC_MSG;
3050         in_params.res_id = res_id;
3051         OSAL_MEM_ZERO(&out_params, sizeof(out_params));
3052         rc = ecore_mcp_resc_allocation_msg(p_hwfn, p_ptt, &in_params,
3053                                            &out_params);
3054         if (rc != ECORE_SUCCESS)
3055                 return rc;
3056
3057         *p_mcp_resp = out_params.mcp_resp;
3058
3059         if (*p_mcp_resp == FW_MSG_CODE_RESOURCE_ALLOC_OK) {
3060                 *p_resc_num = out_params.resc_num;
3061                 *p_resc_start = out_params.resc_start;
3062         }
3063
3064         return ECORE_SUCCESS;
3065 }
3066
3067 enum _ecore_status_t ecore_mcp_initiate_pf_flr(struct ecore_hwfn *p_hwfn,
3068                                                struct ecore_ptt *p_ptt)
3069 {
3070         u32 mcp_resp, mcp_param;
3071
3072         return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_INITIATE_PF_FLR, 0,
3073                              &mcp_resp, &mcp_param);
3074 }
3075
3076 static enum _ecore_status_t ecore_mcp_resource_cmd(struct ecore_hwfn *p_hwfn,
3077                                                    struct ecore_ptt *p_ptt,
3078                                                    u32 param, u32 *p_mcp_resp,
3079                                                    u32 *p_mcp_param)
3080 {
3081         enum _ecore_status_t rc;
3082
3083         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_RESOURCE_CMD, param,
3084                            p_mcp_resp, p_mcp_param);
3085         if (rc != ECORE_SUCCESS)
3086                 return rc;
3087
3088         if (*p_mcp_resp == FW_MSG_CODE_UNSUPPORTED) {
3089                 DP_INFO(p_hwfn,
3090                         "The resource command is unsupported by the MFW\n");
3091                 return ECORE_NOTIMPL;
3092         }
3093
3094         if (*p_mcp_param == RESOURCE_OPCODE_UNKNOWN_CMD) {
3095                 u8 opcode = ECORE_MFW_GET_FIELD(param, RESOURCE_CMD_REQ_OPCODE);
3096
3097                 DP_NOTICE(p_hwfn, false,
3098                           "The resource command is unknown to the MFW [param 0x%08x, opcode %d]\n",
3099                           param, opcode);
3100                 return ECORE_INVAL;
3101         }
3102
3103         return rc;
3104 }
3105
3106 enum _ecore_status_t
3107 __ecore_mcp_resc_lock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3108                       struct ecore_resc_lock_params *p_params)
3109 {
3110         u32 param = 0, mcp_resp, mcp_param;
3111         u8 opcode;
3112         enum _ecore_status_t rc;
3113
3114         switch (p_params->timeout) {
3115         case ECORE_MCP_RESC_LOCK_TO_DEFAULT:
3116                 opcode = RESOURCE_OPCODE_REQ;
3117                 p_params->timeout = 0;
3118                 break;
3119         case ECORE_MCP_RESC_LOCK_TO_NONE:
3120                 opcode = RESOURCE_OPCODE_REQ_WO_AGING;
3121                 p_params->timeout = 0;
3122                 break;
3123         default:
3124                 opcode = RESOURCE_OPCODE_REQ_W_AGING;
3125                 break;
3126         }
3127
3128         ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_RESC, p_params->resource);
3129         ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_OPCODE, opcode);
3130         ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_AGE, p_params->timeout);
3131
3132         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3133                    "Resource lock request: param 0x%08x [age %d, opcode %d, resource %d]\n",
3134                    param, p_params->timeout, opcode, p_params->resource);
3135
3136         /* Attempt to acquire the resource */
3137         rc = ecore_mcp_resource_cmd(p_hwfn, p_ptt, param, &mcp_resp,
3138                                     &mcp_param);
3139         if (rc != ECORE_SUCCESS)
3140                 return rc;
3141
3142         /* Analyze the response */
3143         p_params->owner = ECORE_MFW_GET_FIELD(mcp_param,
3144                                              RESOURCE_CMD_RSP_OWNER);
3145         opcode = ECORE_MFW_GET_FIELD(mcp_param, RESOURCE_CMD_RSP_OPCODE);
3146
3147         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3148                    "Resource lock response: mcp_param 0x%08x [opcode %d, owner %d]\n",
3149                    mcp_param, opcode, p_params->owner);
3150
3151         switch (opcode) {
3152         case RESOURCE_OPCODE_GNT:
3153                 p_params->b_granted = true;
3154                 break;
3155         case RESOURCE_OPCODE_BUSY:
3156                 p_params->b_granted = false;
3157                 break;
3158         default:
3159                 DP_NOTICE(p_hwfn, false,
3160                           "Unexpected opcode in resource lock response [mcp_param 0x%08x, opcode %d]\n",
3161                           mcp_param, opcode);
3162                 return ECORE_INVAL;
3163         }
3164
3165         return ECORE_SUCCESS;
3166 }
3167
3168 enum _ecore_status_t
3169 ecore_mcp_resc_lock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3170                     struct ecore_resc_lock_params *p_params)
3171 {
3172         u32 retry_cnt = 0;
3173         enum _ecore_status_t rc;
3174
3175         do {
3176                 /* No need for an interval before the first iteration */
3177                 if (retry_cnt) {
3178                         if (p_params->sleep_b4_retry) {
3179                                 u16 retry_interval_in_ms =
3180                                         DIV_ROUND_UP(p_params->retry_interval,
3181                                                      1000);
3182
3183                                 OSAL_MSLEEP(retry_interval_in_ms);
3184                         } else {
3185                                 OSAL_UDELAY(p_params->retry_interval);
3186                         }
3187                 }
3188
3189                 rc = __ecore_mcp_resc_lock(p_hwfn, p_ptt, p_params);
3190                 if (rc != ECORE_SUCCESS)
3191                         return rc;
3192
3193                 if (p_params->b_granted)
3194                         break;
3195         } while (retry_cnt++ < p_params->retry_num);
3196
3197         return ECORE_SUCCESS;
3198 }
3199
3200 enum _ecore_status_t
3201 ecore_mcp_resc_unlock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
3202                       struct ecore_resc_unlock_params *p_params)
3203 {
3204         u32 param = 0, mcp_resp, mcp_param;
3205         u8 opcode;
3206         enum _ecore_status_t rc;
3207
3208         opcode = p_params->b_force ? RESOURCE_OPCODE_FORCE_RELEASE
3209                                    : RESOURCE_OPCODE_RELEASE;
3210         ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_RESC, p_params->resource);
3211         ECORE_MFW_SET_FIELD(param, RESOURCE_CMD_REQ_OPCODE, opcode);
3212
3213         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3214                    "Resource unlock request: param 0x%08x [opcode %d, resource %d]\n",
3215                    param, opcode, p_params->resource);
3216
3217         /* Attempt to release the resource */
3218         rc = ecore_mcp_resource_cmd(p_hwfn, p_ptt, param, &mcp_resp,
3219                                     &mcp_param);
3220         if (rc != ECORE_SUCCESS)
3221                 return rc;
3222
3223         /* Analyze the response */
3224         opcode = ECORE_MFW_GET_FIELD(mcp_param, RESOURCE_CMD_RSP_OPCODE);
3225
3226         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
3227                    "Resource unlock response: mcp_param 0x%08x [opcode %d]\n",
3228                    mcp_param, opcode);
3229
3230         switch (opcode) {
3231         case RESOURCE_OPCODE_RELEASED_PREVIOUS:
3232                 DP_INFO(p_hwfn,
3233                         "Resource unlock request for an already released resource [%d]\n",
3234                         p_params->resource);
3235                 /* Fallthrough */
3236         case RESOURCE_OPCODE_RELEASED:
3237                 p_params->b_released = true;
3238                 break;
3239         case RESOURCE_OPCODE_WRONG_OWNER:
3240                 p_params->b_released = false;
3241                 break;
3242         default:
3243                 DP_NOTICE(p_hwfn, false,
3244                           "Unexpected opcode in resource unlock response [mcp_param 0x%08x, opcode %d]\n",
3245                           mcp_param, opcode);
3246                 return ECORE_INVAL;
3247         }
3248
3249         return ECORE_SUCCESS;
3250 }
3251
3252 bool ecore_mcp_is_smart_an_supported(struct ecore_hwfn *p_hwfn)
3253 {
3254         return !!(p_hwfn->mcp_info->capabilities &
3255                   FW_MB_PARAM_FEATURE_SUPPORT_SMARTLINQ);
3256 }
3257
3258 enum _ecore_status_t ecore_mcp_get_capabilities(struct ecore_hwfn *p_hwfn,
3259                                                 struct ecore_ptt *p_ptt)
3260 {
3261         u32 mcp_resp;
3262         enum _ecore_status_t rc;
3263
3264         rc = ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_GET_MFW_FEATURE_SUPPORT,
3265                            0, &mcp_resp, &p_hwfn->mcp_info->capabilities);
3266         if (rc == ECORE_SUCCESS)
3267                 DP_VERBOSE(p_hwfn, (ECORE_MSG_SP | ECORE_MSG_PROBE),
3268                            "MFW supported features: %08x\n",
3269                            p_hwfn->mcp_info->capabilities);
3270
3271         return rc;
3272 }
3273
3274 enum _ecore_status_t ecore_mcp_set_capabilities(struct ecore_hwfn *p_hwfn,
3275                                                 struct ecore_ptt *p_ptt)
3276 {
3277         u32 mcp_resp, mcp_param, features;
3278
3279         features = DRV_MB_PARAM_FEATURE_SUPPORT_PORT_SMARTLINQ;
3280
3281         return ecore_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_FEATURE_SUPPORT,
3282                              features, &mcp_resp, &mcp_param);
3283 }