drivers/net/qede/base/ecore_l2.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
  11 #include "ecore.h"
  12 #include "ecore_status.h"
  13 #include "ecore_hsi_eth.h"
  14 #include "ecore_chain.h"
  15 #include "ecore_spq.h"
  16 #include "ecore_init_fw_funcs.h"
  17 #include "ecore_cxt.h"
  18 #include "ecore_l2.h"
  19 #include "ecore_sp_commands.h"
  20 #include "ecore_gtt_reg_addr.h"
  21 #include "ecore_iro.h"
  22 #include "reg_addr.h"
  23 #include "ecore_int.h"
  24 #include "ecore_hw.h"
  25 #include "ecore_vf.h"
  26 #include "ecore_sriov.h"
  27 #include "ecore_mcp.h"
  28
  29 #define ECORE_MAX_SGES_NUM 16
  30 #define CRC32_POLY 0x1edc6f41
  31
  32 struct ecore_l2_info {
  33         u32 queues;
  34         unsigned long **pp_qid_usage;
  35
  36         /* The lock is meant to synchronize access to the qid usage */
  37         osal_mutex_t lock;
  38 };
  39
  40 enum _ecore_status_t ecore_l2_alloc(struct ecore_hwfn *p_hwfn)
  41 {
  42         struct ecore_l2_info *p_l2_info;
  43         unsigned long **pp_qids;
  44         u32 i;
  45
  46         if (!ECORE_IS_L2_PERSONALITY(p_hwfn))
  47                 return ECORE_SUCCESS;
  48
  49         p_l2_info = OSAL_VZALLOC(p_hwfn->p_dev, sizeof(*p_l2_info));
  50         if (!p_l2_info)
  51                 return ECORE_NOMEM;
  52         p_hwfn->p_l2_info = p_l2_info;
  53
  54         if (IS_PF(p_hwfn->p_dev)) {
  55                 p_l2_info->queues = RESC_NUM(p_hwfn, ECORE_L2_QUEUE);
  56         } else {
  57                 u8 rx = 0, tx = 0;
  58
  59                 ecore_vf_get_num_rxqs(p_hwfn, &rx);
  60                 ecore_vf_get_num_txqs(p_hwfn, &tx);
  61
  62                 p_l2_info->queues = (u32)OSAL_MAX_T(u8, rx, tx);
  63         }
  64
  65         pp_qids = OSAL_VZALLOC(p_hwfn->p_dev,
  66                                sizeof(unsigned long *) *
  67                                p_l2_info->queues);
  68         if (pp_qids == OSAL_NULL)
  69                 return ECORE_NOMEM;
  70         p_l2_info->pp_qid_usage = pp_qids;
  71
  72         for (i = 0; i < p_l2_info->queues; i++) {
  73                 pp_qids[i] = OSAL_VZALLOC(p_hwfn->p_dev,
  74                                           MAX_QUEUES_PER_QZONE / 8);
  75                 if (pp_qids[i] == OSAL_NULL)
  76                         return ECORE_NOMEM;
  77         }
  78
  79 #ifdef CONFIG_ECORE_LOCK_ALLOC
  80         if (OSAL_MUTEX_ALLOC(p_hwfn, &p_l2_info->lock))
  81                 return ECORE_NOMEM;
  82 #endif
  83
  84         return ECORE_SUCCESS;
  85 }
  86
  87 void ecore_l2_setup(struct ecore_hwfn *p_hwfn)
  88 {
  89         if (!ECORE_IS_L2_PERSONALITY(p_hwfn))
  90                 return;
  91
  92         OSAL_MUTEX_INIT(&p_hwfn->p_l2_info->lock);
  93 }
  94
  95 void ecore_l2_free(struct ecore_hwfn *p_hwfn)
  96 {
  97         u32 i;
  98
  99         if (!ECORE_IS_L2_PERSONALITY(p_hwfn))
 100                 return;
 101
 102         if (p_hwfn->p_l2_info == OSAL_NULL)
 103                 return;
 104
 105         if (p_hwfn->p_l2_info->pp_qid_usage == OSAL_NULL)
 106                 goto out_l2_info;
 107
 108         /* Free until hit first uninitialized entry */
 109         for (i = 0; i < p_hwfn->p_l2_info->queues; i++) {
 110                 if (p_hwfn->p_l2_info->pp_qid_usage[i] == OSAL_NULL)
 111                         break;
 112                 OSAL_VFREE(p_hwfn->p_dev,
 113                            p_hwfn->p_l2_info->pp_qid_usage[i]);
 114                 p_hwfn->p_l2_info->pp_qid_usage[i] = OSAL_NULL;
 115         }
 116
 117 #ifdef CONFIG_ECORE_LOCK_ALLOC
 118         /* Lock is last to initialize, if everything else was */
 119         if (i == p_hwfn->p_l2_info->queues)
 120                 OSAL_MUTEX_DEALLOC(&p_hwfn->p_l2_info->lock);
 121 #endif
 122
 123         OSAL_VFREE(p_hwfn->p_dev, p_hwfn->p_l2_info->pp_qid_usage);
 124         p_hwfn->p_l2_info->pp_qid_usage = OSAL_NULL;
 125
 126 out_l2_info:
 127         OSAL_VFREE(p_hwfn->p_dev, p_hwfn->p_l2_info);
 128         p_hwfn->p_l2_info = OSAL_NULL;
 129 }
 130
 131 /* TODO - we'll need locking around these... */
 132 static bool ecore_eth_queue_qid_usage_add(struct ecore_hwfn *p_hwfn,
 133                                           struct ecore_queue_cid *p_cid)
 134 {
 135         struct ecore_l2_info *p_l2_info = p_hwfn->p_l2_info;
 136         u16 queue_id = p_cid->rel.queue_id;
 137         bool b_rc = true;
 138         u8 first;
 139
 140         OSAL_MUTEX_ACQUIRE(&p_l2_info->lock);
 141
 142         if (queue_id > p_l2_info->queues) {
 143                 DP_NOTICE(p_hwfn, true,
 144                           "Requested to increase usage for qzone %04x out of %08x\n",
 145                           queue_id, p_l2_info->queues);
 146                 b_rc = false;
 147                 goto out;
 148         }
 149
 150         first = (u8)OSAL_FIND_FIRST_ZERO_BIT(p_l2_info->pp_qid_usage[queue_id],
 151                                              MAX_QUEUES_PER_QZONE);
 152         if (first >= MAX_QUEUES_PER_QZONE) {
 153                 b_rc = false;
 154                 goto out;
 155         }
 156
 157         OSAL_SET_BIT(first, p_l2_info->pp_qid_usage[queue_id]);
 158         p_cid->qid_usage_idx = first;
 159
 160 out:
 161         OSAL_MUTEX_RELEASE(&p_l2_info->lock);
 162         return b_rc;
 163 }
 164
 165 static void ecore_eth_queue_qid_usage_del(struct ecore_hwfn *p_hwfn,
 166                                           struct ecore_queue_cid *p_cid)
 167 {
 168         OSAL_MUTEX_ACQUIRE(&p_hwfn->p_l2_info->lock);
 169
 170         OSAL_CLEAR_BIT(p_cid->qid_usage_idx,
 171                        p_hwfn->p_l2_info->pp_qid_usage[p_cid->rel.queue_id]);
 172
 173         OSAL_MUTEX_RELEASE(&p_hwfn->p_l2_info->lock);
 174 }
 175
 176 void ecore_eth_queue_cid_release(struct ecore_hwfn *p_hwfn,
 177                                  struct ecore_queue_cid *p_cid)
 178 {
 179         bool b_legacy_vf = !!(p_cid->vf_legacy &
 180                               ECORE_QCID_LEGACY_VF_CID);
 181
 182         /* VFs' CIDs are 0-based in PF-view, and uninitialized on VF.
 183          * For legacy vf-queues, the CID doesn't go through here.
 184          */
 185         if (IS_PF(p_hwfn->p_dev) && !b_legacy_vf)
 186                 _ecore_cxt_release_cid(p_hwfn, p_cid->cid, p_cid->vfid);
 187
 188         /* VFs maintain the index inside queue-zone on their own */
 189         if (p_cid->vfid == ECORE_QUEUE_CID_PF)
 190                 ecore_eth_queue_qid_usage_del(p_hwfn, p_cid);
 191
 192         OSAL_VFREE(p_hwfn->p_dev, p_cid);
 193 }
 194
 195 /* The internal is only meant to be directly called by PFs initializeing CIDs
 196  * for their VFs.
 197  */
 198 static struct ecore_queue_cid *
 199 _ecore_eth_queue_to_cid(struct ecore_hwfn *p_hwfn,
 200                         u16 opaque_fid, u32 cid,
 201                         struct ecore_queue_start_common_params *p_params,
 202                         bool b_is_rx,
 203                         struct ecore_queue_cid_vf_params *p_vf_params)
 204 {
 205         struct ecore_queue_cid *p_cid;
 206         enum _ecore_status_t rc;
 207
 208         p_cid = OSAL_VZALLOC(p_hwfn->p_dev, sizeof(*p_cid));
 209         if (p_cid == OSAL_NULL)
 210                 return OSAL_NULL;
 211
 212         p_cid->opaque_fid = opaque_fid;
 213         p_cid->cid = cid;
 214         p_cid->p_owner = p_hwfn;
 215
 216         /* Fill in parameters */
 217         p_cid->rel.vport_id = p_params->vport_id;
 218         p_cid->rel.queue_id = p_params->queue_id;
 219         p_cid->rel.stats_id = p_params->stats_id;
 220         p_cid->sb_igu_id = p_params->p_sb->igu_sb_id;
 221         p_cid->b_is_rx = b_is_rx;
 222         p_cid->sb_idx = p_params->sb_idx;
 223
 224         /* Fill-in bits related to VFs' queues if information was provided */
 225         if (p_vf_params != OSAL_NULL) {
 226                 p_cid->vfid = p_vf_params->vfid;
 227                 p_cid->vf_qid = p_vf_params->vf_qid;
 228                 p_cid->vf_legacy = p_vf_params->vf_legacy;
 229         } else {
 230                 p_cid->vfid = ECORE_QUEUE_CID_PF;
 231         }
 232
 233         /* Don't try calculating the absolute indices for VFs */
 234         if (IS_VF(p_hwfn->p_dev)) {
 235                 p_cid->abs = p_cid->rel;
 236
 237                 goto out;
 238         }
 239
 240         /* Calculate the engine-absolute indices of the resources.
 241          * This would guarantee they're valid later on.
 242          * In some cases [SBs] we already have the right values.
 243          */
 244         rc = ecore_fw_vport(p_hwfn, p_cid->rel.vport_id, &p_cid->abs.vport_id);
 245         if (rc != ECORE_SUCCESS)
 246                 goto fail;
 247
 248         rc = ecore_fw_l2_queue(p_hwfn, p_cid->rel.queue_id,
 249                                &p_cid->abs.queue_id);
 250         if (rc != ECORE_SUCCESS)
 251                 goto fail;
 252
 253         /* In case of a PF configuring its VF's queues, the stats-id is already
 254          * absolute [since there's a single index that's suitable per-VF].
 255          */
 256         if (p_cid->vfid == ECORE_QUEUE_CID_PF) {
 257                 rc = ecore_fw_vport(p_hwfn, p_cid->rel.stats_id,
 258                                     &p_cid->abs.stats_id);
 259                 if (rc != ECORE_SUCCESS)
 260                         goto fail;
 261         } else {
 262                 p_cid->abs.stats_id = p_cid->rel.stats_id;
 263         }
 264
 265 out:
 266         /* VF-images have provided the qid_usage_idx on their own.
 267          * Otherwise, we need to allocate a unique one.
 268          */
 269         if (!p_vf_params) {
 270                 if (!ecore_eth_queue_qid_usage_add(p_hwfn, p_cid))
 271                         goto fail;
 272         } else {
 273                 p_cid->qid_usage_idx = p_vf_params->qid_usage_idx;
 274         }
 275
 276         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 277                    "opaque_fid: %04x CID %08x vport %02x [%02x] qzone %04x.%02x [%04x] stats %02x [%02x] SB %04x PI %02x\n",
 278                    p_cid->opaque_fid, p_cid->cid,
 279                    p_cid->rel.vport_id, p_cid->abs.vport_id,
 280                    p_cid->rel.queue_id, p_cid->qid_usage_idx,
 281                    p_cid->abs.queue_id,
 282                    p_cid->rel.stats_id, p_cid->abs.stats_id,
 283                    p_cid->sb_igu_id, p_cid->sb_idx);
 284
 285         return p_cid;
 286
 287 fail:
 288         OSAL_VFREE(p_hwfn->p_dev, p_cid);
 289         return OSAL_NULL;
 290 }
 291
 292 struct ecore_queue_cid *
 293 ecore_eth_queue_to_cid(struct ecore_hwfn *p_hwfn, u16 opaque_fid,
 294                        struct ecore_queue_start_common_params *p_params,
 295                        bool b_is_rx,
 296                        struct ecore_queue_cid_vf_params *p_vf_params)
 297 {
 298         struct ecore_queue_cid *p_cid;
 299         u8 vfid = ECORE_CXT_PF_CID;
 300         bool b_legacy_vf = false;
 301         u32 cid = 0;
 302
 303         /* In case of legacy VFs, The CID can be derived from the additional
 304          * VF parameters - the VF assumes queue X uses CID X, so we can simply
 305          * use the vf_qid for this purpose as well.
 306          */
 307         if (p_vf_params) {
 308                 vfid = p_vf_params->vfid;
 309
 310                 if (p_vf_params->vf_legacy &
 311                     ECORE_QCID_LEGACY_VF_CID) {
 312                         b_legacy_vf = true;
 313                         cid = p_vf_params->vf_qid;
 314                 }
 315         }
 316
 317         /* Get a unique firmware CID for this queue, in case it's a PF.
 318          * VF's don't need a CID as the queue configuration will be done
 319          * by PF.
 320          */
 321         if (IS_PF(p_hwfn->p_dev) && !b_legacy_vf) {
 322                 if (_ecore_cxt_acquire_cid(p_hwfn, PROTOCOLID_ETH,
 323                                            &cid, vfid) != ECORE_SUCCESS) {
 324                         DP_NOTICE(p_hwfn, true, "Failed to acquire cid\n");
 325                         return OSAL_NULL;
 326                 }
 327         }
 328
 329         p_cid = _ecore_eth_queue_to_cid(p_hwfn, opaque_fid, cid,
 330                                         p_params, b_is_rx, p_vf_params);
 331         if ((p_cid == OSAL_NULL) && IS_PF(p_hwfn->p_dev) && !b_legacy_vf)
 332                 _ecore_cxt_release_cid(p_hwfn, cid, vfid);
 333
 334         return p_cid;
 335 }
 336
 337 static struct ecore_queue_cid *
 338 ecore_eth_queue_to_cid_pf(struct ecore_hwfn *p_hwfn, u16 opaque_fid,
 339                           bool b_is_rx,
 340                           struct ecore_queue_start_common_params *p_params)
 341 {
 342         return ecore_eth_queue_to_cid(p_hwfn, opaque_fid, p_params, b_is_rx,
 343                                       OSAL_NULL);
 344 }
 345
 346 enum _ecore_status_t
 347 ecore_sp_eth_vport_start(struct ecore_hwfn *p_hwfn,
 348                          struct ecore_sp_vport_start_params *p_params)
 349 {
 350         struct vport_start_ramrod_data *p_ramrod = OSAL_NULL;
 351         struct ecore_spq_entry *p_ent = OSAL_NULL;
 352         struct ecore_sp_init_data init_data;
 353         struct eth_vport_tpa_param *p_tpa;
 354         u16 rx_mode = 0, tx_err = 0;
 355         u8 abs_vport_id = 0;
 356         enum _ecore_status_t rc = ECORE_NOTIMPL;
 357
 358         rc = ecore_fw_vport(p_hwfn, p_params->vport_id, &abs_vport_id);
 359         if (rc != ECORE_SUCCESS)
 360                 return rc;
 361
 362         /* Get SPQ entry */
 363         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
 364         init_data.cid = ecore_spq_get_cid(p_hwfn);
 365         init_data.opaque_fid = p_params->opaque_fid;
 366         init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
 367
 368         rc = ecore_sp_init_request(p_hwfn, &p_ent,
 369                                    ETH_RAMROD_VPORT_START,
 370                                    PROTOCOLID_ETH, &init_data);
 371         if (rc != ECORE_SUCCESS)
 372                 return rc;
 373
 374         p_ramrod = &p_ent->ramrod.vport_start;
 375         p_ramrod->vport_id = abs_vport_id;
 376
 377         p_ramrod->mtu = OSAL_CPU_TO_LE16(p_params->mtu);
 378         p_ramrod->handle_ptp_pkts = p_params->handle_ptp_pkts;
 379         p_ramrod->inner_vlan_removal_en = p_params->remove_inner_vlan;
 380         p_ramrod->drop_ttl0_en = p_params->drop_ttl0;
 381         p_ramrod->untagged = p_params->only_untagged;
 382         p_ramrod->zero_placement_offset = p_params->zero_placement_offset;
 383
 384         SET_FIELD(rx_mode, ETH_VPORT_RX_MODE_UCAST_DROP_ALL, 1);
 385         SET_FIELD(rx_mode, ETH_VPORT_RX_MODE_MCAST_DROP_ALL, 1);
 386
 387         p_ramrod->rx_mode.state = OSAL_CPU_TO_LE16(rx_mode);
 388
 389         /* Handle requests for strict behavior on transmission errors */
 390         SET_FIELD(tx_err, ETH_TX_ERR_VALS_ILLEGAL_VLAN_MODE,
 391                   p_params->b_err_illegal_vlan_mode ?
 392                   ETH_TX_ERR_ASSERT_MALICIOUS : 0);
 393         SET_FIELD(tx_err, ETH_TX_ERR_VALS_PACKET_TOO_SMALL,
 394                   p_params->b_err_small_pkt ?
 395                   ETH_TX_ERR_ASSERT_MALICIOUS : 0);
 396         SET_FIELD(tx_err, ETH_TX_ERR_VALS_ANTI_SPOOFING_ERR,
 397                   p_params->b_err_anti_spoof ?
 398                   ETH_TX_ERR_ASSERT_MALICIOUS : 0);
 399         SET_FIELD(tx_err, ETH_TX_ERR_VALS_ILLEGAL_INBAND_TAGS,
 400                   p_params->b_err_illegal_inband_mode ?
 401                   ETH_TX_ERR_ASSERT_MALICIOUS : 0);
 402         SET_FIELD(tx_err, ETH_TX_ERR_VALS_VLAN_INSERTION_W_INBAND_TAG,
 403                   p_params->b_err_vlan_insert_with_inband ?
 404                   ETH_TX_ERR_ASSERT_MALICIOUS : 0);
 405         SET_FIELD(tx_err, ETH_TX_ERR_VALS_MTU_VIOLATION,
 406                   p_params->b_err_big_pkt ?
 407                   ETH_TX_ERR_ASSERT_MALICIOUS : 0);
 408         SET_FIELD(tx_err, ETH_TX_ERR_VALS_ILLEGAL_CONTROL_FRAME,
 409                   p_params->b_err_ctrl_frame ?
 410                   ETH_TX_ERR_ASSERT_MALICIOUS : 0);
 411         p_ramrod->tx_err_behav.values = OSAL_CPU_TO_LE16(tx_err);
 412
 413         /* TPA related fields */
 414         p_tpa = &p_ramrod->tpa_param;
 415         OSAL_MEMSET(p_tpa, 0, sizeof(struct eth_vport_tpa_param));
 416         p_tpa->max_buff_num = p_params->max_buffers_per_cqe;
 417
 418         switch (p_params->tpa_mode) {
 419         case ECORE_TPA_MODE_GRO:
 420                 p_tpa->tpa_max_aggs_num = ETH_TPA_MAX_AGGS_NUM;
 421                 p_tpa->tpa_max_size = (u16)-1;
 422                 p_tpa->tpa_min_size_to_cont = p_params->mtu / 2;
 423                 p_tpa->tpa_min_size_to_start = p_params->mtu / 2;
 424                 p_tpa->tpa_ipv4_en_flg = 1;
 425                 p_tpa->tpa_ipv6_en_flg = 1;
 426                 p_tpa->tpa_ipv4_tunn_en_flg = 1;
 427                 p_tpa->tpa_ipv6_tunn_en_flg = 1;
 428                 p_tpa->tpa_pkt_split_flg = 1;
 429                 p_tpa->tpa_gro_consistent_flg = 1;
 430                 break;
 431         default:
 432                 break;
 433         }
 434
 435         p_ramrod->tx_switching_en = p_params->tx_switching;
 436 #ifndef ASIC_ONLY
 437         if (CHIP_REV_IS_SLOW(p_hwfn->p_dev))
 438                 p_ramrod->tx_switching_en = 0;
 439 #endif
 440
 441         p_ramrod->ctl_frame_mac_check_en = !!p_params->check_mac;
 442         p_ramrod->ctl_frame_ethtype_check_en = !!p_params->check_ethtype;
 443
 444         /* Software Function ID in hwfn (PFs are 0 - 15, VFs are 16 - 135) */
 445         p_ramrod->sw_fid = ecore_concrete_to_sw_fid(p_params->concrete_fid);
 446
 447         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
 448 }
 449
 450 enum _ecore_status_t
 451 ecore_sp_vport_start(struct ecore_hwfn *p_hwfn,
 452                      struct ecore_sp_vport_start_params *p_params)
 453 {
 454         if (IS_VF(p_hwfn->p_dev))
 455                 return ecore_vf_pf_vport_start(p_hwfn, p_params->vport_id,
 456                                                p_params->mtu,
 457                                                p_params->remove_inner_vlan,
 458                                                p_params->tpa_mode,
 459                                                p_params->max_buffers_per_cqe,
 460                                                p_params->only_untagged);
 461
 462         return ecore_sp_eth_vport_start(p_hwfn, p_params);
 463 }
 464
 465 static enum _ecore_status_t
 466 ecore_sp_vport_update_rss(struct ecore_hwfn *p_hwfn,
 467                           struct vport_update_ramrod_data *p_ramrod,
 468                           struct ecore_rss_params *p_rss)
 469 {
 470         struct eth_vport_rss_config *p_config;
 471         u16 capabilities = 0;
 472         int i, table_size;
 473         enum _ecore_status_t rc = ECORE_SUCCESS;
 474
 475         if (!p_rss) {
 476                 p_ramrod->common.update_rss_flg = 0;
 477                 return rc;
 478         }
 479         p_config = &p_ramrod->rss_config;
 480
 481         OSAL_BUILD_BUG_ON(ECORE_RSS_IND_TABLE_SIZE !=
 482                           ETH_RSS_IND_TABLE_ENTRIES_NUM);
 483
 484         rc = ecore_fw_rss_eng(p_hwfn, p_rss->rss_eng_id, &p_config->rss_id);
 485         if (rc != ECORE_SUCCESS)
 486                 return rc;
 487
 488         p_ramrod->common.update_rss_flg = p_rss->update_rss_config;
 489         p_config->update_rss_capabilities = p_rss->update_rss_capabilities;
 490         p_config->update_rss_ind_table = p_rss->update_rss_ind_table;
 491         p_config->update_rss_key = p_rss->update_rss_key;
 492
 493         p_config->rss_mode = p_rss->rss_enable ?
 494             ETH_VPORT_RSS_MODE_REGULAR : ETH_VPORT_RSS_MODE_DISABLED;
 495
 496         p_config->capabilities = 0;
 497
 498         SET_FIELD(capabilities,
 499                   ETH_VPORT_RSS_CONFIG_IPV4_CAPABILITY,
 500                   !!(p_rss->rss_caps & ECORE_RSS_IPV4));
 501         SET_FIELD(capabilities,
 502                   ETH_VPORT_RSS_CONFIG_IPV6_CAPABILITY,
 503                   !!(p_rss->rss_caps & ECORE_RSS_IPV6));
 504         SET_FIELD(capabilities,
 505                   ETH_VPORT_RSS_CONFIG_IPV4_TCP_CAPABILITY,
 506                   !!(p_rss->rss_caps & ECORE_RSS_IPV4_TCP));
 507         SET_FIELD(capabilities,
 508                   ETH_VPORT_RSS_CONFIG_IPV6_TCP_CAPABILITY,
 509                   !!(p_rss->rss_caps & ECORE_RSS_IPV6_TCP));
 510         SET_FIELD(capabilities,
 511                   ETH_VPORT_RSS_CONFIG_IPV4_UDP_CAPABILITY,
 512                   !!(p_rss->rss_caps & ECORE_RSS_IPV4_UDP));
 513         SET_FIELD(capabilities,
 514                   ETH_VPORT_RSS_CONFIG_IPV6_UDP_CAPABILITY,
 515                   !!(p_rss->rss_caps & ECORE_RSS_IPV6_UDP));
 516         p_config->tbl_size = p_rss->rss_table_size_log;
 517         p_config->capabilities = OSAL_CPU_TO_LE16(capabilities);
 518
 519         DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
 520                    "update rss flag %d, rss_mode = %d, update_caps = %d, capabilities = %d, update_ind = %d, update_rss_key = %d\n",
 521                    p_ramrod->common.update_rss_flg,
 522                    p_config->rss_mode,
 523                    p_config->update_rss_capabilities,
 524                    p_config->capabilities,
 525                    p_config->update_rss_ind_table, p_config->update_rss_key);
 526
 527         table_size = OSAL_MIN_T(int, ECORE_RSS_IND_TABLE_SIZE,
 528                                 1 << p_config->tbl_size);
 529         for (i = 0; i < table_size; i++) {
 530                 struct ecore_queue_cid *p_queue = p_rss->rss_ind_table[i];
 531
 532                 if (!p_queue)
 533                         return ECORE_INVAL;
 534
 535                 p_config->indirection_table[i] =
 536                                 OSAL_CPU_TO_LE16(p_queue->abs.queue_id);
 537         }
 538
 539         DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
 540                    "Configured RSS indirection table [%d entries]:\n",
 541                    table_size);
 542         for (i = 0; i < ECORE_RSS_IND_TABLE_SIZE; i += 0x10) {
 543                 DP_VERBOSE(p_hwfn, ECORE_MSG_IFUP,
 544                            "%04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x\n",
 545                            OSAL_LE16_TO_CPU(p_config->indirection_table[i]),
 546                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 1]),
 547                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 2]),
 548                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 3]),
 549                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 4]),
 550                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 5]),
 551                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 6]),
 552                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 7]),
 553                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 8]),
 554                            OSAL_LE16_TO_CPU(p_config->indirection_table[i + 9]),
 555                           OSAL_LE16_TO_CPU(p_config->indirection_table[i + 10]),
 556                           OSAL_LE16_TO_CPU(p_config->indirection_table[i + 11]),
 557                           OSAL_LE16_TO_CPU(p_config->indirection_table[i + 12]),
 558                           OSAL_LE16_TO_CPU(p_config->indirection_table[i + 13]),
 559                           OSAL_LE16_TO_CPU(p_config->indirection_table[i + 14]),
 560                          OSAL_LE16_TO_CPU(p_config->indirection_table[i + 15]));
 561         }
 562
 563         for (i = 0; i < 10; i++)
 564                 p_config->rss_key[i] = OSAL_CPU_TO_LE32(p_rss->rss_key[i]);
 565
 566         return rc;
 567 }
 568
 569 static void
 570 ecore_sp_update_accept_mode(struct ecore_hwfn *p_hwfn,
 571                             struct vport_update_ramrod_data *p_ramrod,
 572                             struct ecore_filter_accept_flags accept_flags)
 573 {
 574         p_ramrod->common.update_rx_mode_flg =
 575                                         accept_flags.update_rx_mode_config;
 576         p_ramrod->common.update_tx_mode_flg =
 577                                         accept_flags.update_tx_mode_config;
 578
 579 #ifndef ASIC_ONLY
 580         /* On B0 emulation we cannot enable Tx, since this would cause writes
 581          * to PVFC HW block which isn't implemented in emulation.
 582          */
 583         if (CHIP_REV_IS_SLOW(p_hwfn->p_dev)) {
 584                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 585                            "Non-Asic - prevent Tx mode in vport update\n");
 586                 p_ramrod->common.update_tx_mode_flg = 0;
 587         }
 588 #endif
 589
 590         /* Set Rx mode accept flags */
 591         if (p_ramrod->common.update_rx_mode_flg) {
 592                 u8 accept_filter = accept_flags.rx_accept_filter;
 593                 u16 state = 0;
 594
 595                 SET_FIELD(state, ETH_VPORT_RX_MODE_UCAST_DROP_ALL,
 596                           !(!!(accept_filter & ECORE_ACCEPT_UCAST_MATCHED) ||
 597                            !!(accept_filter & ECORE_ACCEPT_UCAST_UNMATCHED)));
 598
 599                 SET_FIELD(state, ETH_VPORT_RX_MODE_UCAST_ACCEPT_UNMATCHED,
 600                           !!(accept_filter & ECORE_ACCEPT_UCAST_UNMATCHED));
 601
 602                 SET_FIELD(state, ETH_VPORT_RX_MODE_MCAST_DROP_ALL,
 603                           !(!!(accept_filter & ECORE_ACCEPT_MCAST_MATCHED) ||
 604                             !!(accept_filter & ECORE_ACCEPT_MCAST_UNMATCHED)));
 605
 606                 SET_FIELD(state, ETH_VPORT_RX_MODE_MCAST_ACCEPT_ALL,
 607                           (!!(accept_filter & ECORE_ACCEPT_MCAST_MATCHED) &&
 608                            !!(accept_filter & ECORE_ACCEPT_MCAST_UNMATCHED)));
 609
 610                 SET_FIELD(state, ETH_VPORT_RX_MODE_BCAST_ACCEPT_ALL,
 611                           !!(accept_filter & ECORE_ACCEPT_BCAST));
 612
 613                 p_ramrod->rx_mode.state = OSAL_CPU_TO_LE16(state);
 614                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 615                            "vport[%02x] p_ramrod->rx_mode.state = 0x%x\n",
 616                            p_ramrod->common.vport_id, state);
 617         }
 618
 619         /* Set Tx mode accept flags */
 620         if (p_ramrod->common.update_tx_mode_flg) {
 621                 u8 accept_filter = accept_flags.tx_accept_filter;
 622                 u16 state = 0;
 623
 624                 SET_FIELD(state, ETH_VPORT_TX_MODE_UCAST_DROP_ALL,
 625                           !!(accept_filter & ECORE_ACCEPT_NONE));
 626
 627                 SET_FIELD(state, ETH_VPORT_TX_MODE_MCAST_DROP_ALL,
 628                           !!(accept_filter & ECORE_ACCEPT_NONE));
 629
 630                 SET_FIELD(state, ETH_VPORT_TX_MODE_MCAST_ACCEPT_ALL,
 631                           (!!(accept_filter & ECORE_ACCEPT_MCAST_MATCHED) &&
 632                            !!(accept_filter & ECORE_ACCEPT_MCAST_UNMATCHED)));
 633
 634                 SET_FIELD(state, ETH_VPORT_TX_MODE_BCAST_ACCEPT_ALL,
 635                           !!(accept_filter & ECORE_ACCEPT_BCAST));
 636
 637                 p_ramrod->tx_mode.state = OSAL_CPU_TO_LE16(state);
 638                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 639                            "vport[%02x] p_ramrod->tx_mode.state = 0x%x\n",
 640                            p_ramrod->common.vport_id, state);
 641         }
 642 }
 643
 644 static void
 645 ecore_sp_vport_update_sge_tpa(struct vport_update_ramrod_data *p_ramrod,
 646                               struct ecore_sge_tpa_params *p_params)
 647 {
 648         struct eth_vport_tpa_param *p_tpa;
 649         u16 val;
 650
 651         if (!p_params) {
 652                 p_ramrod->common.update_tpa_param_flg = 0;
 653                 p_ramrod->common.update_tpa_en_flg = 0;
 654                 p_ramrod->common.update_tpa_param_flg = 0;
 655                 return;
 656         }
 657
 658         p_ramrod->common.update_tpa_en_flg = p_params->update_tpa_en_flg;
 659         p_tpa = &p_ramrod->tpa_param;
 660         p_tpa->tpa_ipv4_en_flg = p_params->tpa_ipv4_en_flg;
 661         p_tpa->tpa_ipv6_en_flg = p_params->tpa_ipv6_en_flg;
 662         p_tpa->tpa_ipv4_tunn_en_flg = p_params->tpa_ipv4_tunn_en_flg;
 663         p_tpa->tpa_ipv6_tunn_en_flg = p_params->tpa_ipv6_tunn_en_flg;
 664
 665         p_ramrod->common.update_tpa_param_flg = p_params->update_tpa_param_flg;
 666         p_tpa->max_buff_num = p_params->max_buffers_per_cqe;
 667         p_tpa->tpa_pkt_split_flg = p_params->tpa_pkt_split_flg;
 668         p_tpa->tpa_hdr_data_split_flg = p_params->tpa_hdr_data_split_flg;
 669         p_tpa->tpa_gro_consistent_flg = p_params->tpa_gro_consistent_flg;
 670         p_tpa->tpa_max_aggs_num = p_params->tpa_max_aggs_num;
 671         val = p_params->tpa_max_size;
 672         p_tpa->tpa_max_size = OSAL_CPU_TO_LE16(val);
 673         val = p_params->tpa_min_size_to_start;
 674         p_tpa->tpa_min_size_to_start = OSAL_CPU_TO_LE16(val);
 675         val = p_params->tpa_min_size_to_cont;
 676         p_tpa->tpa_min_size_to_cont = OSAL_CPU_TO_LE16(val);
 677 }
 678
 679 static void
 680 ecore_sp_update_mcast_bin(struct vport_update_ramrod_data *p_ramrod,
 681                           struct ecore_sp_vport_update_params *p_params)
 682 {
 683         int i;
 684
 685         OSAL_MEMSET(&p_ramrod->approx_mcast.bins, 0,
 686                     sizeof(p_ramrod->approx_mcast.bins));
 687
 688         if (!p_params->update_approx_mcast_flg)
 689                 return;
 690
 691         p_ramrod->common.update_approx_mcast_flg = 1;
 692         for (i = 0; i < ETH_MULTICAST_MAC_BINS_IN_REGS; i++) {
 693                 u32 *p_bins = (u32 *)p_params->bins;
 694
 695                 p_ramrod->approx_mcast.bins[i] = OSAL_CPU_TO_LE32(p_bins[i]);
 696         }
 697 }
 698
 699 enum _ecore_status_t
 700 ecore_sp_vport_update(struct ecore_hwfn *p_hwfn,
 701                       struct ecore_sp_vport_update_params *p_params,
 702                       enum spq_mode comp_mode,
 703                       struct ecore_spq_comp_cb *p_comp_data)
 704 {
 705         struct ecore_rss_params *p_rss_params = p_params->rss_params;
 706         struct vport_update_ramrod_data_cmn *p_cmn;
 707         struct ecore_sp_init_data init_data;
 708         struct vport_update_ramrod_data *p_ramrod = OSAL_NULL;
 709         struct ecore_spq_entry *p_ent = OSAL_NULL;
 710         u8 abs_vport_id = 0, val;
 711         enum _ecore_status_t rc = ECORE_NOTIMPL;
 712
 713         if (IS_VF(p_hwfn->p_dev)) {
 714                 rc = ecore_vf_pf_vport_update(p_hwfn, p_params);
 715                 return rc;
 716         }
 717
 718         rc = ecore_fw_vport(p_hwfn, p_params->vport_id, &abs_vport_id);
 719         if (rc != ECORE_SUCCESS)
 720                 return rc;
 721
 722         /* Get SPQ entry */
 723         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
 724         init_data.cid = ecore_spq_get_cid(p_hwfn);
 725         init_data.opaque_fid = p_params->opaque_fid;
 726         init_data.comp_mode = comp_mode;
 727         init_data.p_comp_data = p_comp_data;
 728
 729         rc = ecore_sp_init_request(p_hwfn, &p_ent,
 730                                    ETH_RAMROD_VPORT_UPDATE,
 731                                    PROTOCOLID_ETH, &init_data);
 732         if (rc != ECORE_SUCCESS)
 733                 return rc;
 734
 735         /* Copy input params to ramrod according to FW struct */
 736         p_ramrod = &p_ent->ramrod.vport_update;
 737         p_cmn = &p_ramrod->common;
 738
 739         p_cmn->vport_id = abs_vport_id;
 740
 741         p_cmn->rx_active_flg = p_params->vport_active_rx_flg;
 742         p_cmn->update_rx_active_flg = p_params->update_vport_active_rx_flg;
 743         p_cmn->tx_active_flg = p_params->vport_active_tx_flg;
 744         p_cmn->update_tx_active_flg = p_params->update_vport_active_tx_flg;
 745
 746         p_cmn->accept_any_vlan = p_params->accept_any_vlan;
 747         val = p_params->update_accept_any_vlan_flg;
 748         p_cmn->update_accept_any_vlan_flg = val;
 749
 750         p_cmn->inner_vlan_removal_en = p_params->inner_vlan_removal_flg;
 751         val = p_params->update_inner_vlan_removal_flg;
 752         p_cmn->update_inner_vlan_removal_en_flg = val;
 753
 754         p_cmn->default_vlan_en = p_params->default_vlan_enable_flg;
 755         val = p_params->update_default_vlan_enable_flg;
 756         p_cmn->update_default_vlan_en_flg = val;
 757
 758         p_cmn->default_vlan = OSAL_CPU_TO_LE16(p_params->default_vlan);
 759         p_cmn->update_default_vlan_flg = p_params->update_default_vlan_flg;
 760
 761         p_cmn->silent_vlan_removal_en = p_params->silent_vlan_removal_flg;
 762
 763         p_ramrod->common.tx_switching_en = p_params->tx_switching_flg;
 764
 765 #ifndef ASIC_ONLY
 766         if (CHIP_REV_IS_FPGA(p_hwfn->p_dev))
 767                 if (p_ramrod->common.tx_switching_en ||
 768                     p_ramrod->common.update_tx_switching_en_flg) {
 769                         DP_NOTICE(p_hwfn, false,
 770                                   "FPGA - why are we seeing tx-switching? Overriding it\n");
 771                         p_ramrod->common.tx_switching_en = 0;
 772                         p_ramrod->common.update_tx_switching_en_flg = 1;
 773                 }
 774 #endif
 775         p_cmn->update_tx_switching_en_flg = p_params->update_tx_switching_flg;
 776
 777         p_cmn->anti_spoofing_en = p_params->anti_spoofing_en;
 778         val = p_params->update_anti_spoofing_en_flg;
 779         p_ramrod->common.update_anti_spoofing_en_flg = val;
 780
 781         rc = ecore_sp_vport_update_rss(p_hwfn, p_ramrod, p_rss_params);
 782         if (rc != ECORE_SUCCESS) {
 783                 /* Return spq entry which is taken in ecore_sp_init_request()*/
 784                 ecore_spq_return_entry(p_hwfn, p_ent);
 785                 return rc;
 786         }
 787
 788         /* Update mcast bins for VFs, PF doesn't use this functionality */
 789         ecore_sp_update_mcast_bin(p_ramrod, p_params);
 790
 791         ecore_sp_update_accept_mode(p_hwfn, p_ramrod, p_params->accept_flags);
 792         ecore_sp_vport_update_sge_tpa(p_ramrod, p_params->sge_tpa_params);
 793         if (p_params->mtu) {
 794                 p_ramrod->common.update_mtu_flg = 1;
 795                 p_ramrod->common.mtu = OSAL_CPU_TO_LE16(p_params->mtu);
 796         }
 797
 798         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
 799 }
 800
 801 enum _ecore_status_t ecore_sp_vport_stop(struct ecore_hwfn *p_hwfn,
 802                                          u16 opaque_fid, u8 vport_id)
 803 {
 804         struct vport_stop_ramrod_data *p_ramrod;
 805         struct ecore_sp_init_data init_data;
 806         struct ecore_spq_entry *p_ent;
 807         u8 abs_vport_id = 0;
 808         enum _ecore_status_t rc;
 809
 810         if (IS_VF(p_hwfn->p_dev))
 811                 return ecore_vf_pf_vport_stop(p_hwfn);
 812
 813         rc = ecore_fw_vport(p_hwfn, vport_id, &abs_vport_id);
 814         if (rc != ECORE_SUCCESS)
 815                 return rc;
 816
 817         /* Get SPQ entry */
 818         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
 819         init_data.cid = ecore_spq_get_cid(p_hwfn);
 820         init_data.opaque_fid = opaque_fid;
 821         init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
 822
 823         rc = ecore_sp_init_request(p_hwfn, &p_ent,
 824                                    ETH_RAMROD_VPORT_STOP,
 825                                    PROTOCOLID_ETH, &init_data);
 826         if (rc != ECORE_SUCCESS)
 827                 return rc;
 828
 829         p_ramrod = &p_ent->ramrod.vport_stop;
 830         p_ramrod->vport_id = abs_vport_id;
 831
 832         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
 833 }
 834
 835 static enum _ecore_status_t
 836 ecore_vf_pf_accept_flags(struct ecore_hwfn *p_hwfn,
 837                          struct ecore_filter_accept_flags *p_accept_flags)
 838 {
 839         struct ecore_sp_vport_update_params s_params;
 840
 841         OSAL_MEMSET(&s_params, 0, sizeof(s_params));
 842         OSAL_MEMCPY(&s_params.accept_flags, p_accept_flags,
 843                     sizeof(struct ecore_filter_accept_flags));
 844
 845         return ecore_vf_pf_vport_update(p_hwfn, &s_params);
 846 }
 847
 848 enum _ecore_status_t
 849 ecore_filter_accept_cmd(struct ecore_dev *p_dev,
 850                         u8 vport,
 851                         struct ecore_filter_accept_flags accept_flags,
 852                         u8 update_accept_any_vlan,
 853                         u8 accept_any_vlan,
 854                         enum spq_mode comp_mode,
 855                         struct ecore_spq_comp_cb *p_comp_data)
 856 {
 857         struct ecore_sp_vport_update_params vport_update_params;
 858         int i, rc;
 859
 860         /* Prepare and send the vport rx_mode change */
 861         OSAL_MEMSET(&vport_update_params, 0, sizeof(vport_update_params));
 862         vport_update_params.vport_id = vport;
 863         vport_update_params.accept_flags = accept_flags;
 864         vport_update_params.update_accept_any_vlan_flg = update_accept_any_vlan;
 865         vport_update_params.accept_any_vlan = accept_any_vlan;
 866
 867         for_each_hwfn(p_dev, i) {
 868                 struct ecore_hwfn *p_hwfn = &p_dev->hwfns[i];
 869
 870                 vport_update_params.opaque_fid = p_hwfn->hw_info.opaque_fid;
 871
 872                 if (IS_VF(p_dev)) {
 873                         rc = ecore_vf_pf_accept_flags(p_hwfn, &accept_flags);
 874                         if (rc != ECORE_SUCCESS)
 875                                 return rc;
 876                         continue;
 877                 }
 878
 879                 rc = ecore_sp_vport_update(p_hwfn, &vport_update_params,
 880                                            comp_mode, p_comp_data);
 881                 if (rc != ECORE_SUCCESS) {
 882                         DP_ERR(p_dev, "Update rx_mode failed %d\n", rc);
 883                         return rc;
 884                 }
 885
 886                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 887                            "Accept filter configured, flags = [Rx]%x [Tx]%x\n",
 888                            accept_flags.rx_accept_filter,
 889                            accept_flags.tx_accept_filter);
 890
 891                 if (update_accept_any_vlan)
 892                         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 893                                    "accept_any_vlan=%d configured\n",
 894                                    accept_any_vlan);
 895         }
 896
 897         return 0;
 898 }
 899
 900 enum _ecore_status_t
 901 ecore_eth_rxq_start_ramrod(struct ecore_hwfn *p_hwfn,
 902                            struct ecore_queue_cid *p_cid,
 903                            u16 bd_max_bytes,
 904                            dma_addr_t bd_chain_phys_addr,
 905                            dma_addr_t cqe_pbl_addr,
 906                            u16 cqe_pbl_size)
 907 {
 908         struct rx_queue_start_ramrod_data *p_ramrod = OSAL_NULL;
 909         struct ecore_spq_entry *p_ent = OSAL_NULL;
 910         struct ecore_sp_init_data init_data;
 911         enum _ecore_status_t rc = ECORE_NOTIMPL;
 912
 913         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 914                    "opaque_fid=0x%x, cid=0x%x, rx_qzone=0x%x, vport_id=0x%x, sb_id=0x%x\n",
 915                    p_cid->opaque_fid, p_cid->cid, p_cid->abs.queue_id,
 916                    p_cid->abs.vport_id, p_cid->sb_igu_id);
 917
 918         /* Get SPQ entry */
 919         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
 920         init_data.cid = p_cid->cid;
 921         init_data.opaque_fid = p_cid->opaque_fid;
 922         init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
 923
 924         rc = ecore_sp_init_request(p_hwfn, &p_ent,
 925                                    ETH_RAMROD_RX_QUEUE_START,
 926                                    PROTOCOLID_ETH, &init_data);
 927         if (rc != ECORE_SUCCESS)
 928                 return rc;
 929
 930         p_ramrod = &p_ent->ramrod.rx_queue_start;
 931
 932         p_ramrod->sb_id = OSAL_CPU_TO_LE16(p_cid->sb_igu_id);
 933         p_ramrod->sb_index = p_cid->sb_idx;
 934         p_ramrod->vport_id = p_cid->abs.vport_id;
 935         p_ramrod->stats_counter_id = p_cid->abs.stats_id;
 936         p_ramrod->rx_queue_id = OSAL_CPU_TO_LE16(p_cid->abs.queue_id);
 937         p_ramrod->complete_cqe_flg = 0;
 938         p_ramrod->complete_event_flg = 1;
 939
 940         p_ramrod->bd_max_bytes = OSAL_CPU_TO_LE16(bd_max_bytes);
 941         DMA_REGPAIR_LE(p_ramrod->bd_base, bd_chain_phys_addr);
 942
 943         p_ramrod->num_of_pbl_pages = OSAL_CPU_TO_LE16(cqe_pbl_size);
 944         DMA_REGPAIR_LE(p_ramrod->cqe_pbl_addr, cqe_pbl_addr);
 945
 946         if (p_cid->vfid != ECORE_QUEUE_CID_PF) {
 947                 bool b_legacy_vf = !!(p_cid->vf_legacy &
 948                                       ECORE_QCID_LEGACY_VF_RX_PROD);
 949
 950                 p_ramrod->vf_rx_prod_index = p_cid->vf_qid;
 951                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
 952                            "Queue%s is meant for VF rxq[%02x]\n",
 953                            b_legacy_vf ? " [legacy]" : "",
 954                            p_cid->vf_qid);
 955                 p_ramrod->vf_rx_prod_use_zone_a = b_legacy_vf;
 956         }
 957
 958         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
 959 }
 960
 961 static enum _ecore_status_t
 962 ecore_eth_pf_rx_queue_start(struct ecore_hwfn *p_hwfn,
 963                             struct ecore_queue_cid *p_cid,
 964                             u16 bd_max_bytes,
 965                             dma_addr_t bd_chain_phys_addr,
 966                             dma_addr_t cqe_pbl_addr,
 967                             u16 cqe_pbl_size,
 968                             void OSAL_IOMEM * *pp_prod)
 969 {
 970         u32 init_prod_val = 0;
 971
 972         *pp_prod = (u8 OSAL_IOMEM *)
 973                     p_hwfn->regview +
 974                     GTT_BAR0_MAP_REG_MSDM_RAM +
 975                     MSTORM_ETH_PF_PRODS_OFFSET(p_cid->abs.queue_id);
 976
 977         /* Init the rcq, rx bd and rx sge (if valid) producers to 0 */
 978         __internal_ram_wr(p_hwfn, *pp_prod, sizeof(u32),
 979                           (u32 *)(&init_prod_val));
 980
 981         return ecore_eth_rxq_start_ramrod(p_hwfn, p_cid,
 982                                           bd_max_bytes,
 983                                           bd_chain_phys_addr,
 984                                           cqe_pbl_addr, cqe_pbl_size);
 985 }
 986
 987 enum _ecore_status_t
 988 ecore_eth_rx_queue_start(struct ecore_hwfn *p_hwfn,
 989                          u16 opaque_fid,
 990                          struct ecore_queue_start_common_params *p_params,
 991                          u16 bd_max_bytes,
 992                          dma_addr_t bd_chain_phys_addr,
 993                          dma_addr_t cqe_pbl_addr,
 994                          u16 cqe_pbl_size,
 995                          struct ecore_rxq_start_ret_params *p_ret_params)
 996 {
 997         struct ecore_queue_cid *p_cid;
 998         enum _ecore_status_t rc;
 999
1000         /* Allocate a CID for the queue */
1001         p_cid = ecore_eth_queue_to_cid_pf(p_hwfn, opaque_fid, true, p_params);
1002         if (p_cid == OSAL_NULL)
1003                 return ECORE_NOMEM;
1004
1005         if (IS_PF(p_hwfn->p_dev))
1006                 rc = ecore_eth_pf_rx_queue_start(p_hwfn, p_cid,
1007                                                  bd_max_bytes,
1008                                                  bd_chain_phys_addr,
1009                                                  cqe_pbl_addr, cqe_pbl_size,
1010                                                  &p_ret_params->p_prod);
1011         else
1012                 rc = ecore_vf_pf_rxq_start(p_hwfn, p_cid,
1013                                            bd_max_bytes,
1014                                            bd_chain_phys_addr,
1015                                            cqe_pbl_addr,
1016                                            cqe_pbl_size,
1017                                            &p_ret_params->p_prod);
1018
1019         /* Provide the caller with a reference to as handler */
1020         if (rc != ECORE_SUCCESS)
1021                 ecore_eth_queue_cid_release(p_hwfn, p_cid);
1022         else
1023                 p_ret_params->p_handle = (void *)p_cid;
1024
1025         return rc;
1026 }
1027
1028 enum _ecore_status_t
1029 ecore_sp_eth_rx_queues_update(struct ecore_hwfn *p_hwfn,
1030                               void **pp_rxq_handles,
1031                               u8 num_rxqs,
1032                               u8 complete_cqe_flg,
1033                               u8 complete_event_flg,
1034                               enum spq_mode comp_mode,
1035                               struct ecore_spq_comp_cb *p_comp_data)
1036 {
1037         struct rx_queue_update_ramrod_data *p_ramrod = OSAL_NULL;
1038         struct ecore_spq_entry *p_ent = OSAL_NULL;
1039         struct ecore_sp_init_data init_data;
1040         struct ecore_queue_cid *p_cid;
1041         enum _ecore_status_t rc = ECORE_NOTIMPL;
1042         u8 i;
1043
1044         if (IS_VF(p_hwfn->p_dev))
1045                 return ecore_vf_pf_rxqs_update(p_hwfn,
1046                                                (struct ecore_queue_cid **)
1047                                                pp_rxq_handles,
1048                                                num_rxqs,
1049                                                complete_cqe_flg,
1050                                                complete_event_flg);
1051
1052         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
1053         init_data.comp_mode = comp_mode;
1054         init_data.p_comp_data = p_comp_data;
1055
1056         for (i = 0; i < num_rxqs; i++) {
1057                 p_cid = ((struct ecore_queue_cid **)pp_rxq_handles)[i];
1058
1059                 /* Get SPQ entry */
1060                 init_data.cid = p_cid->cid;
1061                 init_data.opaque_fid = p_cid->opaque_fid;
1062
1063                 rc = ecore_sp_init_request(p_hwfn, &p_ent,
1064                                            ETH_RAMROD_RX_QUEUE_UPDATE,
1065                                            PROTOCOLID_ETH, &init_data);
1066                 if (rc != ECORE_SUCCESS)
1067                         return rc;
1068
1069                 p_ramrod = &p_ent->ramrod.rx_queue_update;
1070                 p_ramrod->vport_id = p_cid->abs.vport_id;
1071
1072                 p_ramrod->rx_queue_id = OSAL_CPU_TO_LE16(p_cid->abs.queue_id);
1073                 p_ramrod->complete_cqe_flg = complete_cqe_flg;
1074                 p_ramrod->complete_event_flg = complete_event_flg;
1075
1076                 rc = ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1077                 if (rc != ECORE_SUCCESS)
1078                         return rc;
1079         }
1080
1081         return rc;
1082 }
1083
1084 static enum _ecore_status_t
1085 ecore_eth_pf_rx_queue_stop(struct ecore_hwfn *p_hwfn,
1086                            struct ecore_queue_cid *p_cid,
1087                            bool b_eq_completion_only,
1088                            bool b_cqe_completion)
1089 {
1090         struct rx_queue_stop_ramrod_data *p_ramrod = OSAL_NULL;
1091         struct ecore_spq_entry *p_ent = OSAL_NULL;
1092         struct ecore_sp_init_data init_data;
1093         enum _ecore_status_t rc;
1094
1095         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
1096         init_data.cid = p_cid->cid;
1097         init_data.opaque_fid = p_cid->opaque_fid;
1098         init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
1099
1100         rc = ecore_sp_init_request(p_hwfn, &p_ent,
1101                                    ETH_RAMROD_RX_QUEUE_STOP,
1102                                    PROTOCOLID_ETH, &init_data);
1103         if (rc != ECORE_SUCCESS)
1104                 return rc;
1105
1106         p_ramrod = &p_ent->ramrod.rx_queue_stop;
1107         p_ramrod->vport_id = p_cid->abs.vport_id;
1108         p_ramrod->rx_queue_id = OSAL_CPU_TO_LE16(p_cid->abs.queue_id);
1109
1110         /* Cleaning the queue requires the completion to arrive there.
1111          * In addition, VFs require the answer to come as eqe to PF.
1112          */
1113         p_ramrod->complete_cqe_flg = ((p_cid->vfid == ECORE_QUEUE_CID_PF) &&
1114                                       !b_eq_completion_only) ||
1115                                      b_cqe_completion;
1116         p_ramrod->complete_event_flg = (p_cid->vfid != ECORE_QUEUE_CID_PF) ||
1117                                        b_eq_completion_only;
1118
1119         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1120 }
1121
1122 enum _ecore_status_t ecore_eth_rx_queue_stop(struct ecore_hwfn *p_hwfn,
1123                                              void *p_rxq,
1124                                              bool eq_completion_only,
1125                                              bool cqe_completion)
1126 {
1127         struct ecore_queue_cid *p_cid = (struct ecore_queue_cid *)p_rxq;
1128         enum _ecore_status_t rc = ECORE_NOTIMPL;
1129
1130         if (IS_PF(p_hwfn->p_dev))
1131                 rc = ecore_eth_pf_rx_queue_stop(p_hwfn, p_cid,
1132                                                 eq_completion_only,
1133                                                 cqe_completion);
1134         else
1135                 rc = ecore_vf_pf_rxq_stop(p_hwfn, p_cid, cqe_completion);
1136
1137         if (rc == ECORE_SUCCESS)
1138                 ecore_eth_queue_cid_release(p_hwfn, p_cid);
1139         return rc;
1140 }
1141
1142 enum _ecore_status_t
1143 ecore_eth_txq_start_ramrod(struct ecore_hwfn *p_hwfn,
1144                            struct ecore_queue_cid *p_cid,
1145                            dma_addr_t pbl_addr, u16 pbl_size,
1146                            u16 pq_id)
1147 {
1148         struct tx_queue_start_ramrod_data *p_ramrod = OSAL_NULL;
1149         struct ecore_spq_entry *p_ent = OSAL_NULL;
1150         struct ecore_sp_init_data init_data;
1151         enum _ecore_status_t rc = ECORE_NOTIMPL;
1152
1153         /* Get SPQ entry */
1154         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
1155         init_data.cid = p_cid->cid;
1156         init_data.opaque_fid = p_cid->opaque_fid;
1157         init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
1158
1159         rc = ecore_sp_init_request(p_hwfn, &p_ent,
1160                                    ETH_RAMROD_TX_QUEUE_START,
1161                                    PROTOCOLID_ETH, &init_data);
1162         if (rc != ECORE_SUCCESS)
1163                 return rc;
1164
1165         p_ramrod = &p_ent->ramrod.tx_queue_start;
1166         p_ramrod->vport_id = p_cid->abs.vport_id;
1167
1168         p_ramrod->sb_id = OSAL_CPU_TO_LE16(p_cid->sb_igu_id);
1169         p_ramrod->sb_index = p_cid->sb_idx;
1170         p_ramrod->stats_counter_id = p_cid->abs.stats_id;
1171
1172         p_ramrod->queue_zone_id = OSAL_CPU_TO_LE16(p_cid->abs.queue_id);
1173         p_ramrod->same_as_last_id = OSAL_CPU_TO_LE16(p_cid->abs.queue_id);
1174
1175         p_ramrod->pbl_size = OSAL_CPU_TO_LE16(pbl_size);
1176         DMA_REGPAIR_LE(p_ramrod->pbl_base_addr, pbl_addr);
1177
1178         p_ramrod->qm_pq_id = OSAL_CPU_TO_LE16(pq_id);
1179
1180         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1181 }
1182
1183 static enum _ecore_status_t
1184 ecore_eth_pf_tx_queue_start(struct ecore_hwfn *p_hwfn,
1185                             struct ecore_queue_cid *p_cid,
1186                             u8 tc,
1187                             dma_addr_t pbl_addr, u16 pbl_size,
1188                             void OSAL_IOMEM * *pp_doorbell)
1189 {
1190         enum _ecore_status_t rc;
1191
1192         /* TODO - set tc in the pq_params for multi-cos */
1193         rc = ecore_eth_txq_start_ramrod(p_hwfn, p_cid,
1194                                         pbl_addr, pbl_size,
1195                                         ecore_get_cm_pq_idx_mcos(p_hwfn, tc));
1196         if (rc != ECORE_SUCCESS)
1197                 return rc;
1198
1199         /* Provide the caller with the necessary return values */
1200         *pp_doorbell = (u8 OSAL_IOMEM *)
1201                        p_hwfn->doorbells +
1202                        DB_ADDR(p_cid->cid, DQ_DEMS_LEGACY);
1203
1204         return ECORE_SUCCESS;
1205 }
1206
1207 enum _ecore_status_t
1208 ecore_eth_tx_queue_start(struct ecore_hwfn *p_hwfn, u16 opaque_fid,
1209                          struct ecore_queue_start_common_params *p_params,
1210                          u8 tc,
1211                          dma_addr_t pbl_addr, u16 pbl_size,
1212                          struct ecore_txq_start_ret_params *p_ret_params)
1213 {
1214         struct ecore_queue_cid *p_cid;
1215         enum _ecore_status_t rc;
1216
1217         p_cid = ecore_eth_queue_to_cid_pf(p_hwfn, opaque_fid, false, p_params);
1218         if (p_cid == OSAL_NULL)
1219                 return ECORE_INVAL;
1220
1221         if (IS_PF(p_hwfn->p_dev))
1222                 rc = ecore_eth_pf_tx_queue_start(p_hwfn, p_cid, tc,
1223                                                  pbl_addr, pbl_size,
1224                                                  &p_ret_params->p_doorbell);
1225         else
1226                 rc = ecore_vf_pf_txq_start(p_hwfn, p_cid,
1227                                            pbl_addr, pbl_size,
1228                                            &p_ret_params->p_doorbell);
1229
1230         if (rc != ECORE_SUCCESS)
1231                 ecore_eth_queue_cid_release(p_hwfn, p_cid);
1232         else
1233                 p_ret_params->p_handle = (void *)p_cid;
1234
1235         return rc;
1236 }
1237
1238 static enum _ecore_status_t
1239 ecore_eth_pf_tx_queue_stop(struct ecore_hwfn *p_hwfn,
1240                            struct ecore_queue_cid *p_cid)
1241 {
1242         struct ecore_spq_entry *p_ent = OSAL_NULL;
1243         struct ecore_sp_init_data init_data;
1244         enum _ecore_status_t rc;
1245
1246         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
1247         init_data.cid = p_cid->cid;
1248         init_data.opaque_fid = p_cid->opaque_fid;
1249         init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
1250
1251         rc = ecore_sp_init_request(p_hwfn, &p_ent,
1252                                    ETH_RAMROD_TX_QUEUE_STOP,
1253                                    PROTOCOLID_ETH, &init_data);
1254         if (rc != ECORE_SUCCESS)
1255                 return rc;
1256
1257         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1258 }
1259
1260 enum _ecore_status_t ecore_eth_tx_queue_stop(struct ecore_hwfn *p_hwfn,
1261                                              void *p_handle)
1262 {
1263         struct ecore_queue_cid *p_cid = (struct ecore_queue_cid *)p_handle;
1264         enum _ecore_status_t rc;
1265
1266         if (IS_PF(p_hwfn->p_dev))
1267                 rc = ecore_eth_pf_tx_queue_stop(p_hwfn, p_cid);
1268         else
1269                 rc = ecore_vf_pf_txq_stop(p_hwfn, p_cid);
1270
1271         if (rc == ECORE_SUCCESS)
1272                 ecore_eth_queue_cid_release(p_hwfn, p_cid);
1273         return rc;
1274 }
1275
1276 static enum eth_filter_action
1277 ecore_filter_action(enum ecore_filter_opcode opcode)
1278 {
1279         enum eth_filter_action action = MAX_ETH_FILTER_ACTION;
1280
1281         switch (opcode) {
1282         case ECORE_FILTER_ADD:
1283                 action = ETH_FILTER_ACTION_ADD;
1284                 break;
1285         case ECORE_FILTER_REMOVE:
1286                 action = ETH_FILTER_ACTION_REMOVE;
1287                 break;
1288         case ECORE_FILTER_FLUSH:
1289                 action = ETH_FILTER_ACTION_REMOVE_ALL;
1290                 break;
1291         default:
1292                 action = MAX_ETH_FILTER_ACTION;
1293         }
1294
1295         return action;
1296 }
1297
1298 static enum _ecore_status_t
1299 ecore_filter_ucast_common(struct ecore_hwfn *p_hwfn,
1300                           u16 opaque_fid,
1301                           struct ecore_filter_ucast *p_filter_cmd,
1302                           struct vport_filter_update_ramrod_data **pp_ramrod,
1303                           struct ecore_spq_entry **pp_ent,
1304                           enum spq_mode comp_mode,
1305                           struct ecore_spq_comp_cb *p_comp_data)
1306 {
1307         u8 vport_to_add_to = 0, vport_to_remove_from = 0;
1308         struct vport_filter_update_ramrod_data *p_ramrod;
1309         struct eth_filter_cmd *p_first_filter;
1310         struct eth_filter_cmd *p_second_filter;
1311         struct ecore_sp_init_data init_data;
1312         enum eth_filter_action action;
1313         enum _ecore_status_t rc;
1314
1315         rc = ecore_fw_vport(p_hwfn, p_filter_cmd->vport_to_remove_from,
1316                             &vport_to_remove_from);
1317         if (rc != ECORE_SUCCESS)
1318                 return rc;
1319
1320         rc = ecore_fw_vport(p_hwfn, p_filter_cmd->vport_to_add_to,
1321                             &vport_to_add_to);
1322         if (rc != ECORE_SUCCESS)
1323                 return rc;
1324
1325         /* Get SPQ entry */
1326         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
1327         init_data.cid = ecore_spq_get_cid(p_hwfn);
1328         init_data.opaque_fid = opaque_fid;
1329         init_data.comp_mode = comp_mode;
1330         init_data.p_comp_data = p_comp_data;
1331
1332         rc = ecore_sp_init_request(p_hwfn, pp_ent,
1333                                    ETH_RAMROD_FILTERS_UPDATE,
1334                                    PROTOCOLID_ETH, &init_data);
1335         if (rc != ECORE_SUCCESS)
1336                 return rc;
1337
1338         *pp_ramrod = &(*pp_ent)->ramrod.vport_filter_update;
1339         p_ramrod = *pp_ramrod;
1340         p_ramrod->filter_cmd_hdr.rx = p_filter_cmd->is_rx_filter ? 1 : 0;
1341         p_ramrod->filter_cmd_hdr.tx = p_filter_cmd->is_tx_filter ? 1 : 0;
1342
1343 #ifndef ASIC_ONLY
1344         if (CHIP_REV_IS_SLOW(p_hwfn->p_dev)) {
1345                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1346                            "Non-Asic - prevent Tx filters\n");
1347                 p_ramrod->filter_cmd_hdr.tx = 0;
1348         }
1349 #endif
1350
1351         switch (p_filter_cmd->opcode) {
1352         case ECORE_FILTER_REPLACE:
1353         case ECORE_FILTER_MOVE:
1354                 p_ramrod->filter_cmd_hdr.cmd_cnt = 2;
1355                 break;
1356         default:
1357                 p_ramrod->filter_cmd_hdr.cmd_cnt = 1;
1358                 break;
1359         }
1360
1361         p_first_filter = &p_ramrod->filter_cmds[0];
1362         p_second_filter = &p_ramrod->filter_cmds[1];
1363
1364         switch (p_filter_cmd->type) {
1365         case ECORE_FILTER_MAC:
1366                 p_first_filter->type = ETH_FILTER_TYPE_MAC;
1367                 break;
1368         case ECORE_FILTER_VLAN:
1369                 p_first_filter->type = ETH_FILTER_TYPE_VLAN;
1370                 break;
1371         case ECORE_FILTER_MAC_VLAN:
1372                 p_first_filter->type = ETH_FILTER_TYPE_PAIR;
1373                 break;
1374         case ECORE_FILTER_INNER_MAC:
1375                 p_first_filter->type = ETH_FILTER_TYPE_INNER_MAC;
1376                 break;
1377         case ECORE_FILTER_INNER_VLAN:
1378                 p_first_filter->type = ETH_FILTER_TYPE_INNER_VLAN;
1379                 break;
1380         case ECORE_FILTER_INNER_PAIR:
1381                 p_first_filter->type = ETH_FILTER_TYPE_INNER_PAIR;
1382                 break;
1383         case ECORE_FILTER_INNER_MAC_VNI_PAIR:
1384                 p_first_filter->type = ETH_FILTER_TYPE_INNER_MAC_VNI_PAIR;
1385                 break;
1386         case ECORE_FILTER_MAC_VNI_PAIR:
1387                 p_first_filter->type = ETH_FILTER_TYPE_MAC_VNI_PAIR;
1388                 break;
1389         case ECORE_FILTER_VNI:
1390                 p_first_filter->type = ETH_FILTER_TYPE_VNI;
1391                 break;
1392         case ECORE_FILTER_UNUSED: /* @DPDK */
1393                 p_first_filter->type = MAX_ETH_FILTER_TYPE;
1394                 break;
1395         }
1396
1397         if ((p_first_filter->type == ETH_FILTER_TYPE_MAC) ||
1398             (p_first_filter->type == ETH_FILTER_TYPE_PAIR) ||
1399             (p_first_filter->type == ETH_FILTER_TYPE_INNER_MAC) ||
1400             (p_first_filter->type == ETH_FILTER_TYPE_INNER_PAIR) ||
1401             (p_first_filter->type == ETH_FILTER_TYPE_INNER_MAC_VNI_PAIR) ||
1402             (p_first_filter->type == ETH_FILTER_TYPE_MAC_VNI_PAIR))
1403                 ecore_set_fw_mac_addr(&p_first_filter->mac_msb,
1404                                       &p_first_filter->mac_mid,
1405                                       &p_first_filter->mac_lsb,
1406                                       (u8 *)p_filter_cmd->mac);
1407
1408         if ((p_first_filter->type == ETH_FILTER_TYPE_VLAN) ||
1409             (p_first_filter->type == ETH_FILTER_TYPE_PAIR) ||
1410             (p_first_filter->type == ETH_FILTER_TYPE_INNER_VLAN) ||
1411             (p_first_filter->type == ETH_FILTER_TYPE_INNER_PAIR))
1412                 p_first_filter->vlan_id = OSAL_CPU_TO_LE16(p_filter_cmd->vlan);
1413
1414         if ((p_first_filter->type == ETH_FILTER_TYPE_INNER_MAC_VNI_PAIR) ||
1415             (p_first_filter->type == ETH_FILTER_TYPE_MAC_VNI_PAIR) ||
1416             (p_first_filter->type == ETH_FILTER_TYPE_VNI))
1417                 p_first_filter->vni = OSAL_CPU_TO_LE32(p_filter_cmd->vni);
1418
1419         if (p_filter_cmd->opcode == ECORE_FILTER_MOVE) {
1420                 p_second_filter->type = p_first_filter->type;
1421                 p_second_filter->mac_msb = p_first_filter->mac_msb;
1422                 p_second_filter->mac_mid = p_first_filter->mac_mid;
1423                 p_second_filter->mac_lsb = p_first_filter->mac_lsb;
1424                 p_second_filter->vlan_id = p_first_filter->vlan_id;
1425                 p_second_filter->vni = p_first_filter->vni;
1426
1427                 p_first_filter->action = ETH_FILTER_ACTION_REMOVE;
1428
1429                 p_first_filter->vport_id = vport_to_remove_from;
1430
1431                 p_second_filter->action = ETH_FILTER_ACTION_ADD;
1432                 p_second_filter->vport_id = vport_to_add_to;
1433         } else if (p_filter_cmd->opcode == ECORE_FILTER_REPLACE) {
1434                 p_first_filter->vport_id = vport_to_add_to;
1435                 OSAL_MEMCPY(p_second_filter, p_first_filter,
1436                             sizeof(*p_second_filter));
1437                 p_first_filter->action = ETH_FILTER_ACTION_REMOVE_ALL;
1438                 p_second_filter->action = ETH_FILTER_ACTION_ADD;
1439         } else {
1440                 action = ecore_filter_action(p_filter_cmd->opcode);
1441
1442                 if (action == MAX_ETH_FILTER_ACTION) {
1443                         DP_NOTICE(p_hwfn, true,
1444                                   "%d is not supported yet\n",
1445                                   p_filter_cmd->opcode);
1446                         return ECORE_NOTIMPL;
1447                 }
1448
1449                 p_first_filter->action = action;
1450                 p_first_filter->vport_id =
1451                     (p_filter_cmd->opcode == ECORE_FILTER_REMOVE) ?
1452                     vport_to_remove_from : vport_to_add_to;
1453         }
1454
1455         return ECORE_SUCCESS;
1456 }
1457
1458 enum _ecore_status_t
1459 ecore_sp_eth_filter_ucast(struct ecore_hwfn *p_hwfn,
1460                           u16 opaque_fid,
1461                           struct ecore_filter_ucast *p_filter_cmd,
1462                           enum spq_mode comp_mode,
1463                           struct ecore_spq_comp_cb *p_comp_data)
1464 {
1465         struct vport_filter_update_ramrod_data *p_ramrod = OSAL_NULL;
1466         struct ecore_spq_entry *p_ent = OSAL_NULL;
1467         struct eth_filter_cmd_header *p_header;
1468         enum _ecore_status_t rc;
1469
1470         rc = ecore_filter_ucast_common(p_hwfn, opaque_fid, p_filter_cmd,
1471                                        &p_ramrod, &p_ent,
1472                                        comp_mode, p_comp_data);
1473         if (rc != ECORE_SUCCESS) {
1474                 DP_ERR(p_hwfn, "Uni. filter command failed %d\n", rc);
1475                 return rc;
1476         }
1477         p_header = &p_ramrod->filter_cmd_hdr;
1478         p_header->assert_on_error = p_filter_cmd->assert_on_error;
1479
1480         rc = ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1481         if (rc != ECORE_SUCCESS) {
1482                 DP_ERR(p_hwfn, "Unicast filter ADD command failed %d\n", rc);
1483                 return rc;
1484         }
1485
1486         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1487                    "Unicast filter configured, opcode = %s, type = %s, cmd_cnt = %d, is_rx_filter = %d, is_tx_filter = %d\n",
1488                    (p_filter_cmd->opcode == ECORE_FILTER_ADD) ? "ADD" :
1489                    ((p_filter_cmd->opcode == ECORE_FILTER_REMOVE) ?
1490                     "REMOVE" :
1491                     ((p_filter_cmd->opcode == ECORE_FILTER_MOVE) ?
1492                      "MOVE" : "REPLACE")),
1493                    (p_filter_cmd->type == ECORE_FILTER_MAC) ? "MAC" :
1494                    ((p_filter_cmd->type == ECORE_FILTER_VLAN) ?
1495                     "VLAN" : "MAC & VLAN"),
1496                    p_ramrod->filter_cmd_hdr.cmd_cnt,
1497                    p_filter_cmd->is_rx_filter, p_filter_cmd->is_tx_filter);
1498         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
1499                    "vport_to_add_to = %d, vport_to_remove_from = %d, mac = %2x:%2x:%2x:%2x:%2x:%2x, vlan = %d\n",
1500                    p_filter_cmd->vport_to_add_to,
1501                    p_filter_cmd->vport_to_remove_from,
1502                    p_filter_cmd->mac[0], p_filter_cmd->mac[1],
1503                    p_filter_cmd->mac[2], p_filter_cmd->mac[3],
1504                    p_filter_cmd->mac[4], p_filter_cmd->mac[5],
1505                    p_filter_cmd->vlan);
1506
1507         return ECORE_SUCCESS;
1508 }
1509
1510 /*******************************************************************************
1511  * Description:
1512  *         Calculates crc 32 on a buffer
1513  *         Note: crc32_length MUST be aligned to 8
1514  * Return:
1515  ******************************************************************************/
1516 static u32 ecore_calc_crc32c(u8 *crc32_packet, u32 crc32_length, u32 crc32_seed)
1517 {
1518         u32 byte = 0, bit = 0, crc32_result = crc32_seed;
1519         u8 msb = 0, current_byte = 0;
1520
1521         if ((crc32_packet == OSAL_NULL) ||
1522             (crc32_length == 0) || ((crc32_length % 8) != 0)) {
1523                 return crc32_result;
1524         }
1525
1526         for (byte = 0; byte < crc32_length; byte++) {
1527                 current_byte = crc32_packet[byte];
1528                 for (bit = 0; bit < 8; bit++) {
1529                         msb = (u8)(crc32_result >> 31);
1530                         crc32_result = crc32_result << 1;
1531                         if (msb != (0x1 & (current_byte >> bit))) {
1532                                 crc32_result = crc32_result ^ CRC32_POLY;
1533                                 crc32_result |= 1;
1534                         }
1535                 }
1536         }
1537
1538         return crc32_result;
1539 }
1540
1541 static u32 ecore_crc32c_le(u32 seed, u8 *mac)
1542 {
1543         u32 packet_buf[2] = { 0 };
1544
1545         OSAL_MEMCPY((u8 *)(&packet_buf[0]), &mac[0], 6);
1546         return ecore_calc_crc32c((u8 *)packet_buf, 8, seed);
1547 }
1548
1549 u8 ecore_mcast_bin_from_mac(u8 *mac)
1550 {
1551         u32 crc = ecore_crc32c_le(ETH_MULTICAST_BIN_FROM_MAC_SEED, mac);
1552
1553         return crc & 0xff;
1554 }
1555
1556 static enum _ecore_status_t
1557 ecore_sp_eth_filter_mcast(struct ecore_hwfn *p_hwfn,
1558                           struct ecore_filter_mcast *p_filter_cmd,
1559                           enum spq_mode comp_mode,
1560                           struct ecore_spq_comp_cb *p_comp_data)
1561 {
1562         unsigned long bins[ETH_MULTICAST_MAC_BINS_IN_REGS];
1563         struct vport_update_ramrod_data *p_ramrod = OSAL_NULL;
1564         struct ecore_spq_entry *p_ent = OSAL_NULL;
1565         struct ecore_sp_init_data init_data;
1566         u8 abs_vport_id = 0;
1567         enum _ecore_status_t rc;
1568         int i;
1569
1570         if (p_filter_cmd->opcode == ECORE_FILTER_ADD)
1571                 rc = ecore_fw_vport(p_hwfn,
1572                                     p_filter_cmd->vport_to_add_to,
1573                                     &abs_vport_id);
1574         else
1575                 rc = ecore_fw_vport(p_hwfn,
1576                                     p_filter_cmd->vport_to_remove_from,
1577                                     &abs_vport_id);
1578         if (rc != ECORE_SUCCESS)
1579                 return rc;
1580
1581         /* Get SPQ entry */
1582         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
1583         init_data.cid = ecore_spq_get_cid(p_hwfn);
1584         init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
1585         init_data.comp_mode = comp_mode;
1586         init_data.p_comp_data = p_comp_data;
1587
1588         rc = ecore_sp_init_request(p_hwfn, &p_ent,
1589                                    ETH_RAMROD_VPORT_UPDATE,
1590                                    PROTOCOLID_ETH, &init_data);
1591         if (rc != ECORE_SUCCESS) {
1592                 DP_ERR(p_hwfn, "Multi-cast command failed %d\n", rc);
1593                 return rc;
1594         }
1595
1596         p_ramrod = &p_ent->ramrod.vport_update;
1597         p_ramrod->common.update_approx_mcast_flg = 1;
1598
1599         /* explicitly clear out the entire vector */
1600         OSAL_MEMSET(&p_ramrod->approx_mcast.bins,
1601                     0, sizeof(p_ramrod->approx_mcast.bins));
1602         OSAL_MEMSET(bins, 0, sizeof(unsigned long) *
1603                     ETH_MULTICAST_MAC_BINS_IN_REGS);
1604         /* filter ADD op is explicit set op and it removes
1605         *  any existing filters for the vport.
1606         */
1607         if (p_filter_cmd->opcode == ECORE_FILTER_ADD) {
1608                 for (i = 0; i < p_filter_cmd->num_mc_addrs; i++) {
1609                         u32 bit;
1610
1611                         bit = ecore_mcast_bin_from_mac(p_filter_cmd->mac[i]);
1612                         OSAL_SET_BIT(bit, bins);
1613                 }
1614
1615                 /* Convert to correct endianity */
1616                 for (i = 0; i < ETH_MULTICAST_MAC_BINS_IN_REGS; i++) {
1617                         struct vport_update_ramrod_mcast *p_ramrod_bins;
1618                         u32 *p_bins = (u32 *)bins;
1619
1620                         p_ramrod_bins = &p_ramrod->approx_mcast;
1621                         p_ramrod_bins->bins[i] = OSAL_CPU_TO_LE32(p_bins[i]);
1622                 }
1623         }
1624
1625         p_ramrod->common.vport_id = abs_vport_id;
1626
1627         rc = ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1628         if (rc != ECORE_SUCCESS)
1629                 DP_ERR(p_hwfn, "Multicast filter command failed %d\n", rc);
1630
1631         return rc;
1632 }
1633
1634 enum _ecore_status_t
1635 ecore_filter_mcast_cmd(struct ecore_dev *p_dev,
1636                        struct ecore_filter_mcast *p_filter_cmd,
1637                        enum spq_mode comp_mode,
1638                        struct ecore_spq_comp_cb *p_comp_data)
1639 {
1640         enum _ecore_status_t rc = ECORE_SUCCESS;
1641         int i;
1642
1643         /* only ADD and REMOVE operations are supported for multi-cast */
1644         if ((p_filter_cmd->opcode != ECORE_FILTER_ADD &&
1645              (p_filter_cmd->opcode != ECORE_FILTER_REMOVE)) ||
1646             (p_filter_cmd->num_mc_addrs > ECORE_MAX_MC_ADDRS)) {
1647                 return ECORE_INVAL;
1648         }
1649
1650         for_each_hwfn(p_dev, i) {
1651                 struct ecore_hwfn *p_hwfn = &p_dev->hwfns[i];
1652
1653                 if (IS_VF(p_dev)) {
1654                         ecore_vf_pf_filter_mcast(p_hwfn, p_filter_cmd);
1655                         continue;
1656                 }
1657
1658                 rc = ecore_sp_eth_filter_mcast(p_hwfn,
1659                                                p_filter_cmd,
1660                                                comp_mode, p_comp_data);
1661                 if (rc != ECORE_SUCCESS)
1662                         break;
1663         }
1664
1665         return rc;
1666 }
1667
1668 enum _ecore_status_t
1669 ecore_filter_ucast_cmd(struct ecore_dev *p_dev,
1670                        struct ecore_filter_ucast *p_filter_cmd,
1671                        enum spq_mode comp_mode,
1672                        struct ecore_spq_comp_cb *p_comp_data)
1673 {
1674         enum _ecore_status_t rc = ECORE_SUCCESS;
1675         int i;
1676
1677         for_each_hwfn(p_dev, i) {
1678                 struct ecore_hwfn *p_hwfn = &p_dev->hwfns[i];
1679                 u16 opaque_fid;
1680
1681                 if (IS_VF(p_dev)) {
1682                         rc = ecore_vf_pf_filter_ucast(p_hwfn, p_filter_cmd);
1683                         continue;
1684                 }
1685
1686                 opaque_fid = p_hwfn->hw_info.opaque_fid;
1687                 rc = ecore_sp_eth_filter_ucast(p_hwfn,
1688                                                opaque_fid,
1689                                                p_filter_cmd,
1690                                                comp_mode, p_comp_data);
1691                 if (rc != ECORE_SUCCESS)
1692                         break;
1693         }
1694
1695         return rc;
1696 }
1697
1698 /* Statistics related code */
1699 static void __ecore_get_vport_pstats_addrlen(struct ecore_hwfn *p_hwfn,
1700                                              u32 *p_addr, u32 *p_len,
1701                                              u16 statistics_bin)
1702 {
1703         if (IS_PF(p_hwfn->p_dev)) {
1704                 *p_addr = BAR0_MAP_REG_PSDM_RAM +
1705                     PSTORM_QUEUE_STAT_OFFSET(statistics_bin);
1706                 *p_len = sizeof(struct eth_pstorm_per_queue_stat);
1707         } else {
1708                 struct ecore_vf_iov *p_iov = p_hwfn->vf_iov_info;
1709                 struct pfvf_acquire_resp_tlv *p_resp = &p_iov->acquire_resp;
1710
1711                 *p_addr = p_resp->pfdev_info.stats_info.pstats.address;
1712                 *p_len = p_resp->pfdev_info.stats_info.pstats.len;
1713         }
1714 }
1715
1716 static void __ecore_get_vport_pstats(struct ecore_hwfn *p_hwfn,
1717                                      struct ecore_ptt *p_ptt,
1718                                      struct ecore_eth_stats *p_stats,
1719                                      u16 statistics_bin)
1720 {
1721         struct eth_pstorm_per_queue_stat pstats;
1722         u32 pstats_addr = 0, pstats_len = 0;
1723
1724         __ecore_get_vport_pstats_addrlen(p_hwfn, &pstats_addr, &pstats_len,
1725                                          statistics_bin);
1726
1727         OSAL_MEMSET(&pstats, 0, sizeof(pstats));
1728         ecore_memcpy_from(p_hwfn, p_ptt, &pstats, pstats_addr, pstats_len);
1729
1730         p_stats->common.tx_ucast_bytes +=
1731                 HILO_64_REGPAIR(pstats.sent_ucast_bytes);
1732         p_stats->common.tx_mcast_bytes +=
1733                 HILO_64_REGPAIR(pstats.sent_mcast_bytes);
1734         p_stats->common.tx_bcast_bytes +=
1735                 HILO_64_REGPAIR(pstats.sent_bcast_bytes);
1736         p_stats->common.tx_ucast_pkts +=
1737                 HILO_64_REGPAIR(pstats.sent_ucast_pkts);
1738         p_stats->common.tx_mcast_pkts +=
1739                 HILO_64_REGPAIR(pstats.sent_mcast_pkts);
1740         p_stats->common.tx_bcast_pkts +=
1741                 HILO_64_REGPAIR(pstats.sent_bcast_pkts);
1742         p_stats->common.tx_err_drop_pkts +=
1743                 HILO_64_REGPAIR(pstats.error_drop_pkts);
1744 }
1745
1746 static void __ecore_get_vport_tstats(struct ecore_hwfn *p_hwfn,
1747                                      struct ecore_ptt *p_ptt,
1748                                      struct ecore_eth_stats *p_stats)
1749 {
1750         struct tstorm_per_port_stat tstats;
1751         u32 tstats_addr, tstats_len;
1752
1753         if (IS_PF(p_hwfn->p_dev)) {
1754                 tstats_addr = BAR0_MAP_REG_TSDM_RAM +
1755                     TSTORM_PORT_STAT_OFFSET(MFW_PORT(p_hwfn));
1756                 tstats_len = sizeof(struct tstorm_per_port_stat);
1757         } else {
1758                 struct ecore_vf_iov *p_iov = p_hwfn->vf_iov_info;
1759                 struct pfvf_acquire_resp_tlv *p_resp = &p_iov->acquire_resp;
1760
1761                 tstats_addr = p_resp->pfdev_info.stats_info.tstats.address;
1762                 tstats_len = p_resp->pfdev_info.stats_info.tstats.len;
1763         }
1764
1765         OSAL_MEMSET(&tstats, 0, sizeof(tstats));
1766         ecore_memcpy_from(p_hwfn, p_ptt, &tstats, tstats_addr, tstats_len);
1767
1768         p_stats->common.mftag_filter_discards +=
1769                 HILO_64_REGPAIR(tstats.mftag_filter_discard);
1770         p_stats->common.mac_filter_discards +=
1771                 HILO_64_REGPAIR(tstats.eth_mac_filter_discard);
1772 }
1773
1774 static void __ecore_get_vport_ustats_addrlen(struct ecore_hwfn *p_hwfn,
1775                                              u32 *p_addr, u32 *p_len,
1776                                              u16 statistics_bin)
1777 {
1778         if (IS_PF(p_hwfn->p_dev)) {
1779                 *p_addr = BAR0_MAP_REG_USDM_RAM +
1780                     USTORM_QUEUE_STAT_OFFSET(statistics_bin);
1781                 *p_len = sizeof(struct eth_ustorm_per_queue_stat);
1782         } else {
1783                 struct ecore_vf_iov *p_iov = p_hwfn->vf_iov_info;
1784                 struct pfvf_acquire_resp_tlv *p_resp = &p_iov->acquire_resp;
1785
1786                 *p_addr = p_resp->pfdev_info.stats_info.ustats.address;
1787                 *p_len = p_resp->pfdev_info.stats_info.ustats.len;
1788         }
1789 }
1790
1791 static void __ecore_get_vport_ustats(struct ecore_hwfn *p_hwfn,
1792                                      struct ecore_ptt *p_ptt,
1793                                      struct ecore_eth_stats *p_stats,
1794                                      u16 statistics_bin)
1795 {
1796         struct eth_ustorm_per_queue_stat ustats;
1797         u32 ustats_addr = 0, ustats_len = 0;
1798
1799         __ecore_get_vport_ustats_addrlen(p_hwfn, &ustats_addr, &ustats_len,
1800                                          statistics_bin);
1801
1802         OSAL_MEMSET(&ustats, 0, sizeof(ustats));
1803         ecore_memcpy_from(p_hwfn, p_ptt, &ustats, ustats_addr, ustats_len);
1804
1805         p_stats->common.rx_ucast_bytes +=
1806                 HILO_64_REGPAIR(ustats.rcv_ucast_bytes);
1807         p_stats->common.rx_mcast_bytes +=
1808                 HILO_64_REGPAIR(ustats.rcv_mcast_bytes);
1809         p_stats->common.rx_bcast_bytes +=
1810                 HILO_64_REGPAIR(ustats.rcv_bcast_bytes);
1811         p_stats->common.rx_ucast_pkts +=
1812                 HILO_64_REGPAIR(ustats.rcv_ucast_pkts);
1813         p_stats->common.rx_mcast_pkts +=
1814                 HILO_64_REGPAIR(ustats.rcv_mcast_pkts);
1815         p_stats->common.rx_bcast_pkts +=
1816                 HILO_64_REGPAIR(ustats.rcv_bcast_pkts);
1817 }
1818
1819 static void __ecore_get_vport_mstats_addrlen(struct ecore_hwfn *p_hwfn,
1820                                              u32 *p_addr, u32 *p_len,
1821                                              u16 statistics_bin)
1822 {
1823         if (IS_PF(p_hwfn->p_dev)) {
1824                 *p_addr = BAR0_MAP_REG_MSDM_RAM +
1825                     MSTORM_QUEUE_STAT_OFFSET(statistics_bin);
1826                 *p_len = sizeof(struct eth_mstorm_per_queue_stat);
1827         } else {
1828                 struct ecore_vf_iov *p_iov = p_hwfn->vf_iov_info;
1829                 struct pfvf_acquire_resp_tlv *p_resp = &p_iov->acquire_resp;
1830
1831                 *p_addr = p_resp->pfdev_info.stats_info.mstats.address;
1832                 *p_len = p_resp->pfdev_info.stats_info.mstats.len;
1833         }
1834 }
1835
1836 static void __ecore_get_vport_mstats(struct ecore_hwfn *p_hwfn,
1837                                      struct ecore_ptt *p_ptt,
1838                                      struct ecore_eth_stats *p_stats,
1839                                      u16 statistics_bin)
1840 {
1841         struct eth_mstorm_per_queue_stat mstats;
1842         u32 mstats_addr = 0, mstats_len = 0;
1843
1844         __ecore_get_vport_mstats_addrlen(p_hwfn, &mstats_addr, &mstats_len,
1845                                          statistics_bin);
1846
1847         OSAL_MEMSET(&mstats, 0, sizeof(mstats));
1848         ecore_memcpy_from(p_hwfn, p_ptt, &mstats, mstats_addr, mstats_len);
1849
1850         p_stats->common.no_buff_discards +=
1851                 HILO_64_REGPAIR(mstats.no_buff_discard);
1852         p_stats->common.packet_too_big_discard +=
1853                 HILO_64_REGPAIR(mstats.packet_too_big_discard);
1854         p_stats->common.ttl0_discard +=
1855                 HILO_64_REGPAIR(mstats.ttl0_discard);
1856         p_stats->common.tpa_coalesced_pkts +=
1857                 HILO_64_REGPAIR(mstats.tpa_coalesced_pkts);
1858         p_stats->common.tpa_coalesced_events +=
1859                 HILO_64_REGPAIR(mstats.tpa_coalesced_events);
1860         p_stats->common.tpa_aborts_num +=
1861                 HILO_64_REGPAIR(mstats.tpa_aborts_num);
1862         p_stats->common.tpa_coalesced_bytes +=
1863                 HILO_64_REGPAIR(mstats.tpa_coalesced_bytes);
1864 }
1865
1866 static void __ecore_get_vport_port_stats(struct ecore_hwfn *p_hwfn,
1867                                          struct ecore_ptt *p_ptt,
1868                                          struct ecore_eth_stats *p_stats)
1869 {
1870         struct ecore_eth_stats_common *p_common = &p_stats->common;
1871         struct port_stats port_stats;
1872         int j;
1873
1874         OSAL_MEMSET(&port_stats, 0, sizeof(port_stats));
1875
1876         ecore_memcpy_from(p_hwfn, p_ptt, &port_stats,
1877                           p_hwfn->mcp_info->port_addr +
1878                           OFFSETOF(struct public_port, stats),
1879                           sizeof(port_stats));
1880
1881         p_common->rx_64_byte_packets += port_stats.eth.r64;
1882         p_common->rx_65_to_127_byte_packets += port_stats.eth.r127;
1883         p_common->rx_128_to_255_byte_packets += port_stats.eth.r255;
1884         p_common->rx_256_to_511_byte_packets += port_stats.eth.r511;
1885         p_common->rx_512_to_1023_byte_packets += port_stats.eth.r1023;
1886         p_common->rx_1024_to_1518_byte_packets += port_stats.eth.r1518;
1887         p_common->rx_crc_errors += port_stats.eth.rfcs;
1888         p_common->rx_mac_crtl_frames += port_stats.eth.rxcf;
1889         p_common->rx_pause_frames += port_stats.eth.rxpf;
1890         p_common->rx_pfc_frames += port_stats.eth.rxpp;
1891         p_common->rx_align_errors += port_stats.eth.raln;
1892         p_common->rx_carrier_errors += port_stats.eth.rfcr;
1893         p_common->rx_oversize_packets += port_stats.eth.rovr;
1894         p_common->rx_jabbers += port_stats.eth.rjbr;
1895         p_common->rx_undersize_packets += port_stats.eth.rund;
1896         p_common->rx_fragments += port_stats.eth.rfrg;
1897         p_common->tx_64_byte_packets += port_stats.eth.t64;
1898         p_common->tx_65_to_127_byte_packets += port_stats.eth.t127;
1899         p_common->tx_128_to_255_byte_packets += port_stats.eth.t255;
1900         p_common->tx_256_to_511_byte_packets += port_stats.eth.t511;
1901         p_common->tx_512_to_1023_byte_packets += port_stats.eth.t1023;
1902         p_common->tx_1024_to_1518_byte_packets += port_stats.eth.t1518;
1903         p_common->tx_pause_frames += port_stats.eth.txpf;
1904         p_common->tx_pfc_frames += port_stats.eth.txpp;
1905         p_common->rx_mac_bytes += port_stats.eth.rbyte;
1906         p_common->rx_mac_uc_packets += port_stats.eth.rxuca;
1907         p_common->rx_mac_mc_packets += port_stats.eth.rxmca;
1908         p_common->rx_mac_bc_packets += port_stats.eth.rxbca;
1909         p_common->rx_mac_frames_ok += port_stats.eth.rxpok;
1910         p_common->tx_mac_bytes += port_stats.eth.tbyte;
1911         p_common->tx_mac_uc_packets += port_stats.eth.txuca;
1912         p_common->tx_mac_mc_packets += port_stats.eth.txmca;
1913         p_common->tx_mac_bc_packets += port_stats.eth.txbca;
1914         p_common->tx_mac_ctrl_frames += port_stats.eth.txcf;
1915         for (j = 0; j < 8; j++) {
1916                 p_common->brb_truncates += port_stats.brb.brb_truncate[j];
1917                 p_common->brb_discards += port_stats.brb.brb_discard[j];
1918         }
1919
1920         if (ECORE_IS_BB(p_hwfn->p_dev)) {
1921                 struct ecore_eth_stats_bb *p_bb = &p_stats->bb;
1922
1923                 p_bb->rx_1519_to_1522_byte_packets +=
1924                         port_stats.eth.u0.bb0.r1522;
1925                 p_bb->rx_1519_to_2047_byte_packets +=
1926                         port_stats.eth.u0.bb0.r2047;
1927                 p_bb->rx_2048_to_4095_byte_packets +=
1928                         port_stats.eth.u0.bb0.r4095;
1929                 p_bb->rx_4096_to_9216_byte_packets +=
1930                         port_stats.eth.u0.bb0.r9216;
1931                 p_bb->rx_9217_to_16383_byte_packets +=
1932                         port_stats.eth.u0.bb0.r16383;
1933                 p_bb->tx_1519_to_2047_byte_packets +=
1934                         port_stats.eth.u1.bb1.t2047;
1935                 p_bb->tx_2048_to_4095_byte_packets +=
1936                         port_stats.eth.u1.bb1.t4095;
1937                 p_bb->tx_4096_to_9216_byte_packets +=
1938                         port_stats.eth.u1.bb1.t9216;
1939                 p_bb->tx_9217_to_16383_byte_packets +=
1940                         port_stats.eth.u1.bb1.t16383;
1941                 p_bb->tx_lpi_entry_count += port_stats.eth.u2.bb2.tlpiec;
1942                 p_bb->tx_total_collisions += port_stats.eth.u2.bb2.tncl;
1943         } else {
1944                 struct ecore_eth_stats_ah *p_ah = &p_stats->ah;
1945
1946                 p_ah->rx_1519_to_max_byte_packets +=
1947                         port_stats.eth.u0.ah0.r1519_to_max;
1948                 p_ah->tx_1519_to_max_byte_packets =
1949                         port_stats.eth.u1.ah1.t1519_to_max;
1950         }
1951 }
1952
1953 void __ecore_get_vport_stats(struct ecore_hwfn *p_hwfn,
1954                              struct ecore_ptt *p_ptt,
1955                              struct ecore_eth_stats *stats,
1956                              u16 statistics_bin, bool b_get_port_stats)
1957 {
1958         __ecore_get_vport_mstats(p_hwfn, p_ptt, stats, statistics_bin);
1959         __ecore_get_vport_ustats(p_hwfn, p_ptt, stats, statistics_bin);
1960         __ecore_get_vport_tstats(p_hwfn, p_ptt, stats);
1961         __ecore_get_vport_pstats(p_hwfn, p_ptt, stats, statistics_bin);
1962
1963 #ifndef ASIC_ONLY
1964         /* Avoid getting PORT stats for emulation. */
1965         if (CHIP_REV_IS_EMUL(p_hwfn->p_dev))
1966                 return;
1967 #endif
1968
1969         if (b_get_port_stats && p_hwfn->mcp_info)
1970                 __ecore_get_vport_port_stats(p_hwfn, p_ptt, stats);
1971 }
1972
1973 static void _ecore_get_vport_stats(struct ecore_dev *p_dev,
1974                                    struct ecore_eth_stats *stats)
1975 {
1976         u8 fw_vport = 0;
1977         int i;
1978
1979         OSAL_MEMSET(stats, 0, sizeof(*stats));
1980
1981         for_each_hwfn(p_dev, i) {
1982                 struct ecore_hwfn *p_hwfn = &p_dev->hwfns[i];
1983                 struct ecore_ptt *p_ptt = IS_PF(p_dev) ?
1984                     ecore_ptt_acquire(p_hwfn) : OSAL_NULL;
1985                 bool b_get_port_stats;
1986
1987                 if (IS_PF(p_dev)) {
1988                         /* The main vport index is relative first */
1989                         if (ecore_fw_vport(p_hwfn, 0, &fw_vport)) {
1990                                 DP_ERR(p_hwfn, "No vport available!\n");
1991                                 goto out;
1992                         }
1993                 }
1994
1995                 if (IS_PF(p_dev) && !p_ptt) {
1996                         DP_ERR(p_hwfn, "Failed to acquire ptt\n");
1997                         continue;
1998                 }
1999
2000                 b_get_port_stats = IS_PF(p_dev) && IS_LEAD_HWFN(p_hwfn);
2001                 __ecore_get_vport_stats(p_hwfn, p_ptt, stats, fw_vport,
2002                                         b_get_port_stats);
2003
2004 out:
2005                 if (IS_PF(p_dev) && p_ptt)
2006                         ecore_ptt_release(p_hwfn, p_ptt);
2007         }
2008 }
2009
2010 void ecore_get_vport_stats(struct ecore_dev *p_dev,
2011                            struct ecore_eth_stats *stats)
2012 {
2013         u32 i;
2014
2015         if (!p_dev) {
2016                 OSAL_MEMSET(stats, 0, sizeof(*stats));
2017                 return;
2018         }
2019
2020         _ecore_get_vport_stats(p_dev, stats);
2021
2022         if (!p_dev->reset_stats)
2023                 return;
2024
2025         /* Reduce the statistics baseline */
2026         for (i = 0; i < sizeof(struct ecore_eth_stats) / sizeof(u64); i++)
2027                 ((u64 *)stats)[i] -= ((u64 *)p_dev->reset_stats)[i];
2028 }
2029
2030 /* zeroes V-PORT specific portion of stats (Port stats remains untouched) */
2031 void ecore_reset_vport_stats(struct ecore_dev *p_dev)
2032 {
2033         int i;
2034
2035         for_each_hwfn(p_dev, i) {
2036                 struct ecore_hwfn *p_hwfn = &p_dev->hwfns[i];
2037                 struct eth_mstorm_per_queue_stat mstats;
2038                 struct eth_ustorm_per_queue_stat ustats;
2039                 struct eth_pstorm_per_queue_stat pstats;
2040                 struct ecore_ptt *p_ptt = IS_PF(p_dev) ?
2041                     ecore_ptt_acquire(p_hwfn) : OSAL_NULL;
2042                 u32 addr = 0, len = 0;
2043
2044                 if (IS_PF(p_dev) && !p_ptt) {
2045                         DP_ERR(p_hwfn, "Failed to acquire ptt\n");
2046                         continue;
2047                 }
2048
2049                 OSAL_MEMSET(&mstats, 0, sizeof(mstats));
2050                 __ecore_get_vport_mstats_addrlen(p_hwfn, &addr, &len, 0);
2051                 ecore_memcpy_to(p_hwfn, p_ptt, addr, &mstats, len);
2052
2053                 OSAL_MEMSET(&ustats, 0, sizeof(ustats));
2054                 __ecore_get_vport_ustats_addrlen(p_hwfn, &addr, &len, 0);
2055                 ecore_memcpy_to(p_hwfn, p_ptt, addr, &ustats, len);
2056
2057                 OSAL_MEMSET(&pstats, 0, sizeof(pstats));
2058                 __ecore_get_vport_pstats_addrlen(p_hwfn, &addr, &len, 0);
2059                 ecore_memcpy_to(p_hwfn, p_ptt, addr, &pstats, len);
2060
2061                 if (IS_PF(p_dev))
2062                         ecore_ptt_release(p_hwfn, p_ptt);
2063         }
2064
2065         /* PORT statistics are not necessarily reset, so we need to
2066          * read and create a baseline for future statistics.
2067          */
2068         if (!p_dev->reset_stats)
2069                 DP_INFO(p_dev, "Reset stats not allocated\n");
2070         else
2071                 _ecore_get_vport_stats(p_dev, p_dev->reset_stats);
2072 }
2073
2074 void ecore_arfs_mode_configure(struct ecore_hwfn *p_hwfn,
2075                                struct ecore_ptt *p_ptt,
2076                                struct ecore_arfs_config_params *p_cfg_params)
2077 {
2078         if (OSAL_TEST_BIT(ECORE_MF_DISABLE_ARFS, &p_hwfn->p_dev->mf_bits))
2079                 return;
2080
2081         if (p_cfg_params->arfs_enable) {
2082                 ecore_gft_config(p_hwfn, p_ptt, p_hwfn->rel_pf_id,
2083                                  p_cfg_params->tcp,
2084                                  p_cfg_params->udp,
2085                                  p_cfg_params->ipv4,
2086                                  p_cfg_params->ipv6,
2087                                  GFT_PROFILE_TYPE_4_TUPLE);
2088                 DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
2089                            "tcp = %s, udp = %s, ipv4 = %s, ipv6 =%s\n",
2090                            p_cfg_params->tcp ? "Enable" : "Disable",
2091                            p_cfg_params->udp ? "Enable" : "Disable",
2092                            p_cfg_params->ipv4 ? "Enable" : "Disable",
2093                            p_cfg_params->ipv6 ? "Enable" : "Disable");
2094         } else {
2095                 ecore_gft_disable(p_hwfn, p_ptt, p_hwfn->rel_pf_id);
2096         }
2097         DP_VERBOSE(p_hwfn, ECORE_MSG_SP, "Configured ARFS mode : %s\n",
2098                    p_cfg_params->arfs_enable ? "Enable" : "Disable");
2099 }
2100
2101 enum _ecore_status_t
2102 ecore_configure_rfs_ntuple_filter(struct ecore_hwfn *p_hwfn,
2103                                   struct ecore_spq_comp_cb *p_cb,
2104                                   dma_addr_t p_addr, u16 length,
2105                                   u16 qid, u8 vport_id,
2106                                   bool b_is_add)
2107 {
2108         struct rx_update_gft_filter_data *p_ramrod = OSAL_NULL;
2109         struct ecore_spq_entry *p_ent = OSAL_NULL;
2110         struct ecore_sp_init_data init_data;
2111         u16 abs_rx_q_id = 0;
2112         u8 abs_vport_id = 0;
2113         enum _ecore_status_t rc = ECORE_NOTIMPL;
2114
2115         rc = ecore_fw_vport(p_hwfn, vport_id, &abs_vport_id);
2116         if (rc != ECORE_SUCCESS)
2117                 return rc;
2118
2119         rc = ecore_fw_l2_queue(p_hwfn, qid, &abs_rx_q_id);
2120         if (rc != ECORE_SUCCESS)
2121                 return rc;
2122
2123         /* Get SPQ entry */
2124         OSAL_MEMSET(&init_data, 0, sizeof(init_data));
2125         init_data.cid = ecore_spq_get_cid(p_hwfn);
2126
2127         init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
2128
2129         if (p_cb) {
2130                 init_data.comp_mode = ECORE_SPQ_MODE_CB;
2131                 init_data.p_comp_data = p_cb;
2132         } else {
2133                 init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
2134         }
2135
2136         rc = ecore_sp_init_request(p_hwfn, &p_ent,
2137                                    ETH_RAMROD_GFT_UPDATE_FILTER,
2138                                    PROTOCOLID_ETH, &init_data);
2139         if (rc != ECORE_SUCCESS)
2140                 return rc;
2141
2142         p_ramrod = &p_ent->ramrod.rx_update_gft;
2143
2144         DMA_REGPAIR_LE(p_ramrod->pkt_hdr_addr, p_addr);
2145         p_ramrod->pkt_hdr_length = OSAL_CPU_TO_LE16(length);
2146
2147         p_ramrod->action_icid_valid = 0;
2148         p_ramrod->action_icid = 0;
2149
2150         p_ramrod->rx_qid_valid = 1;
2151         p_ramrod->rx_qid = OSAL_CPU_TO_LE16(abs_rx_q_id);
2152
2153         p_ramrod->flow_id_valid = 0;
2154         p_ramrod->flow_id = 0;
2155
2156         p_ramrod->vport_id = OSAL_CPU_TO_LE16((u16)abs_vport_id);
2157         p_ramrod->filter_action = b_is_add ? GFT_ADD_FILTER
2158                                            : GFT_DELETE_FILTER;
2159
2160         DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
2161                    "V[%0x], Q[%04x] - %s filter from 0x%lx [length %04xb]\n",
2162                    abs_vport_id, abs_rx_q_id,
2163                    b_is_add ? "Adding" : "Removing",
2164                    (unsigned long)p_addr, length);
2165
2166         return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
2167 }
2168
2169 int ecore_get_rxq_coalesce(struct ecore_hwfn *p_hwfn,
2170                            struct ecore_ptt *p_ptt,
2171                            struct ecore_queue_cid *p_cid,
2172                            u16 *p_rx_coal)
2173 {
2174         u32 coalesce, address, is_valid;
2175         struct cau_sb_entry sb_entry;
2176         u8 timer_res;
2177         enum _ecore_status_t rc;
2178
2179         rc = ecore_dmae_grc2host(p_hwfn, p_ptt, CAU_REG_SB_VAR_MEMORY +
2180                                  p_cid->sb_igu_id * sizeof(u64),
2181                                  (u64)(osal_uintptr_t)&sb_entry, 2, 0);
2182         if (rc != ECORE_SUCCESS) {
2183                 DP_ERR(p_hwfn, "dmae_grc2host failed %d\n", rc);
2184                 return rc;
2185         }
2186
2187         timer_res = GET_FIELD(sb_entry.params, CAU_SB_ENTRY_TIMER_RES0);
2188
2189         address = BAR0_MAP_REG_USDM_RAM +
2190                   USTORM_ETH_QUEUE_ZONE_OFFSET(p_cid->abs.queue_id);
2191         coalesce = ecore_rd(p_hwfn, p_ptt, address);
2192
2193         is_valid = GET_FIELD(coalesce, COALESCING_TIMESET_VALID);
2194         if (!is_valid)
2195                 return ECORE_INVAL;
2196
2197         coalesce = GET_FIELD(coalesce, COALESCING_TIMESET_TIMESET);
2198         *p_rx_coal = (u16)(coalesce << timer_res);
2199
2200         return ECORE_SUCCESS;
2201 }
2202
2203 int ecore_get_txq_coalesce(struct ecore_hwfn *p_hwfn,
2204                            struct ecore_ptt *p_ptt,
2205                            struct ecore_queue_cid *p_cid,
2206                            u16 *p_tx_coal)
2207 {
2208         u32 coalesce, address, is_valid;
2209         struct cau_sb_entry sb_entry;
2210         u8 timer_res;
2211         enum _ecore_status_t rc;
2212
2213         rc = ecore_dmae_grc2host(p_hwfn, p_ptt, CAU_REG_SB_VAR_MEMORY +
2214                                  p_cid->sb_igu_id * sizeof(u64),
2215                                  (u64)(osal_uintptr_t)&sb_entry, 2, 0);
2216         if (rc != ECORE_SUCCESS) {
2217                 DP_ERR(p_hwfn, "dmae_grc2host failed %d\n", rc);
2218                 return rc;
2219         }
2220
2221         timer_res = GET_FIELD(sb_entry.params, CAU_SB_ENTRY_TIMER_RES1);
2222
2223         address = BAR0_MAP_REG_XSDM_RAM +
2224                   XSTORM_ETH_QUEUE_ZONE_OFFSET(p_cid->abs.queue_id);
2225         coalesce = ecore_rd(p_hwfn, p_ptt, address);
2226
2227         is_valid = GET_FIELD(coalesce, COALESCING_TIMESET_VALID);
2228         if (!is_valid)
2229                 return ECORE_INVAL;
2230
2231         coalesce = GET_FIELD(coalesce, COALESCING_TIMESET_TIMESET);
2232         *p_tx_coal = (u16)(coalesce << timer_res);
2233
2234         return ECORE_SUCCESS;
2235 }
2236
2237 enum _ecore_status_t
2238 ecore_get_queue_coalesce(struct ecore_hwfn *p_hwfn, u16 *p_coal,
2239                          void *handle)
2240 {
2241         struct ecore_queue_cid *p_cid = (struct ecore_queue_cid *)handle;
2242         enum _ecore_status_t rc = ECORE_SUCCESS;
2243         struct ecore_ptt *p_ptt;
2244
2245         if (IS_VF(p_hwfn->p_dev)) {
2246                 rc = ecore_vf_pf_get_coalesce(p_hwfn, p_coal, p_cid);
2247                 if (rc != ECORE_SUCCESS)
2248                         DP_NOTICE(p_hwfn, false,
2249                                   "Unable to read queue calescing\n");
2250
2251                 return rc;
2252         }
2253
2254         p_ptt = ecore_ptt_acquire(p_hwfn);
2255         if (!p_ptt)
2256                 return ECORE_AGAIN;
2257
2258         if (p_cid->b_is_rx) {
2259                 rc = ecore_get_rxq_coalesce(p_hwfn, p_ptt, p_cid, p_coal);
2260                 if (rc != ECORE_SUCCESS)
2261                         goto out;
2262         } else {
2263                 rc = ecore_get_txq_coalesce(p_hwfn, p_ptt, p_cid, p_coal);
2264                 if (rc != ECORE_SUCCESS)
2265                         goto out;
2266         }
2267
2268 out:
2269         ecore_ptt_release(p_hwfn, p_ptt);
2270
2271         return rc;
2272 }